front.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/techspaceco/front-go (interfaces: ClientWithResponsesInterface)

// Package front is a generated GoMock package.
package front

import (
	context "context"
	io "io"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	front "github.com/techspaceco/front-go"
)

// MockClientWithResponsesInterface is a mock of ClientWithResponsesInterface interface.
type MockClientWithResponsesInterface struct {
	ctrl     *gomock.Controller
	recorder *MockClientWithResponsesInterfaceMockRecorder
}

// MockClientWithResponsesInterfaceMockRecorder is the mock recorder for MockClientWithResponsesInterface.
type MockClientWithResponsesInterfaceMockRecorder struct {
	mock *MockClientWithResponsesInterface
}

// NewMockClientWithResponsesInterface creates a new mock instance.
func NewMockClientWithResponsesInterface(ctrl *gomock.Controller) *MockClientWithResponsesInterface {
	mock := &MockClientWithResponsesInterface{ctrl: ctrl}
	mock.recorder = &MockClientWithResponsesInterfaceMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClientWithResponsesInterface) EXPECT() *MockClientWithResponsesInterfaceMockRecorder {
	return m.recorder
}

// CreateAnalyticsExportWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) CreateAnalyticsExportWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...front.RequestEditorFn) (*front.CreateAnalyticsExportResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateAnalyticsExportWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.CreateAnalyticsExportResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAnalyticsExportWithBodyWithResponse indicates an expected call of CreateAnalyticsExportWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) CreateAnalyticsExportWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAnalyticsExportWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).CreateAnalyticsExportWithBodyWithResponse), varargs...)
}

// CreateAnalyticsExportWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) CreateAnalyticsExportWithResponse(arg0 context.Context, arg1 front.CreateAnalyticsExportJSONRequestBody, arg2 ...front.RequestEditorFn) (*front.CreateAnalyticsExportResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateAnalyticsExportWithResponse", varargs...)
	ret0, _ := ret[0].(*front.CreateAnalyticsExportResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAnalyticsExportWithResponse indicates an expected call of CreateAnalyticsExportWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) CreateAnalyticsExportWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAnalyticsExportWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).CreateAnalyticsExportWithResponse), varargs...)
}

// CreateAnalyticsReportWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) CreateAnalyticsReportWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...front.RequestEditorFn) (*front.CreateAnalyticsReportResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateAnalyticsReportWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.CreateAnalyticsReportResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAnalyticsReportWithBodyWithResponse indicates an expected call of CreateAnalyticsReportWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) CreateAnalyticsReportWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAnalyticsReportWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).CreateAnalyticsReportWithBodyWithResponse), varargs...)
}

// CreateAnalyticsReportWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) CreateAnalyticsReportWithResponse(arg0 context.Context, arg1 front.CreateAnalyticsReportJSONRequestBody, arg2 ...front.RequestEditorFn) (*front.CreateAnalyticsReportResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateAnalyticsReportWithResponse", varargs...)
	ret0, _ := ret[0].(*front.CreateAnalyticsReportResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAnalyticsReportWithResponse indicates an expected call of CreateAnalyticsReportWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) CreateAnalyticsReportWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAnalyticsReportWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).CreateAnalyticsReportWithResponse), varargs...)
}

// CreateExportWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) CreateExportWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...front.RequestEditorFn) (*front.CreateExportResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateExportWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.CreateExportResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateExportWithBodyWithResponse indicates an expected call of CreateExportWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) CreateExportWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExportWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).CreateExportWithBodyWithResponse), varargs...)
}

// CreateExportWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) CreateExportWithResponse(arg0 context.Context, arg1 front.CreateExportJSONRequestBody, arg2 ...front.RequestEditorFn) (*front.CreateExportResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateExportWithResponse", varargs...)
	ret0, _ := ret[0].(*front.CreateExportResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateExportWithResponse indicates an expected call of CreateExportWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) CreateExportWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExportWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).CreateExportWithResponse), varargs...)
}

// DeleteAccountsAccountIdContactsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteAccountsAccountIdContactsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.DeleteAccountsAccountIdContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAccountsAccountIdContactsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteAccountsAccountIdContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAccountsAccountIdContactsWithBodyWithResponse indicates an expected call of DeleteAccountsAccountIdContactsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteAccountsAccountIdContactsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountsAccountIdContactsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteAccountsAccountIdContactsWithBodyWithResponse), varargs...)
}

// DeleteAccountsAccountIdContactsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteAccountsAccountIdContactsWithResponse(arg0 context.Context, arg1 string, arg2 front.DeleteAccountsAccountIdContactsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.DeleteAccountsAccountIdContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAccountsAccountIdContactsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteAccountsAccountIdContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAccountsAccountIdContactsWithResponse indicates an expected call of DeleteAccountsAccountIdContactsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteAccountsAccountIdContactsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountsAccountIdContactsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteAccountsAccountIdContactsWithResponse), varargs...)
}

// DeleteAccountsAccountIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteAccountsAccountIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.DeleteAccountsAccountIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAccountsAccountIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteAccountsAccountIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAccountsAccountIdWithResponse indicates an expected call of DeleteAccountsAccountIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteAccountsAccountIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountsAccountIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteAccountsAccountIdWithResponse), varargs...)
}

// DeleteContactGroupsContactGroupIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteContactGroupsContactGroupIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.DeleteContactGroupsContactGroupIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteContactGroupsContactGroupIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteContactGroupsContactGroupIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteContactGroupsContactGroupIdWithResponse indicates an expected call of DeleteContactGroupsContactGroupIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteContactGroupsContactGroupIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContactGroupsContactGroupIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteContactGroupsContactGroupIdWithResponse), varargs...)
}

// DeleteContactsContactIdHandlesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteContactsContactIdHandlesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.DeleteContactsContactIdHandlesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteContactsContactIdHandlesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteContactsContactIdHandlesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteContactsContactIdHandlesWithBodyWithResponse indicates an expected call of DeleteContactsContactIdHandlesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteContactsContactIdHandlesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContactsContactIdHandlesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteContactsContactIdHandlesWithBodyWithResponse), varargs...)
}

// DeleteContactsContactIdHandlesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteContactsContactIdHandlesWithResponse(arg0 context.Context, arg1 string, arg2 front.DeleteContactsContactIdHandlesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.DeleteContactsContactIdHandlesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteContactsContactIdHandlesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteContactsContactIdHandlesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteContactsContactIdHandlesWithResponse indicates an expected call of DeleteContactsContactIdHandlesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteContactsContactIdHandlesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContactsContactIdHandlesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteContactsContactIdHandlesWithResponse), varargs...)
}

// DeleteContactsContactIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteContactsContactIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.DeleteContactsContactIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteContactsContactIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteContactsContactIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteContactsContactIdWithResponse indicates an expected call of DeleteContactsContactIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteContactsContactIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteContactsContactIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteContactsContactIdWithResponse), varargs...)
}

// DeleteConversationsConversationIdFollowersWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteConversationsConversationIdFollowersWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.DeleteConversationsConversationIdFollowersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteConversationsConversationIdFollowersWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteConversationsConversationIdFollowersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteConversationsConversationIdFollowersWithBodyWithResponse indicates an expected call of DeleteConversationsConversationIdFollowersWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteConversationsConversationIdFollowersWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConversationsConversationIdFollowersWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteConversationsConversationIdFollowersWithBodyWithResponse), varargs...)
}

// DeleteConversationsConversationIdFollowersWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteConversationsConversationIdFollowersWithResponse(arg0 context.Context, arg1 string, arg2 front.DeleteConversationsConversationIdFollowersJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.DeleteConversationsConversationIdFollowersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteConversationsConversationIdFollowersWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteConversationsConversationIdFollowersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteConversationsConversationIdFollowersWithResponse indicates an expected call of DeleteConversationsConversationIdFollowersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteConversationsConversationIdFollowersWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConversationsConversationIdFollowersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteConversationsConversationIdFollowersWithResponse), varargs...)
}

// DeleteConversationsConversationIdLinksWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteConversationsConversationIdLinksWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.DeleteConversationsConversationIdLinksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteConversationsConversationIdLinksWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteConversationsConversationIdLinksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteConversationsConversationIdLinksWithBodyWithResponse indicates an expected call of DeleteConversationsConversationIdLinksWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteConversationsConversationIdLinksWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConversationsConversationIdLinksWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteConversationsConversationIdLinksWithBodyWithResponse), varargs...)
}

// DeleteConversationsConversationIdLinksWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteConversationsConversationIdLinksWithResponse(arg0 context.Context, arg1 string, arg2 front.DeleteConversationsConversationIdLinksJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.DeleteConversationsConversationIdLinksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteConversationsConversationIdLinksWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteConversationsConversationIdLinksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteConversationsConversationIdLinksWithResponse indicates an expected call of DeleteConversationsConversationIdLinksWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteConversationsConversationIdLinksWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConversationsConversationIdLinksWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteConversationsConversationIdLinksWithResponse), varargs...)
}

// DeleteConversationsConversationIdTagsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteConversationsConversationIdTagsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.DeleteConversationsConversationIdTagsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteConversationsConversationIdTagsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteConversationsConversationIdTagsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteConversationsConversationIdTagsWithBodyWithResponse indicates an expected call of DeleteConversationsConversationIdTagsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteConversationsConversationIdTagsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConversationsConversationIdTagsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteConversationsConversationIdTagsWithBodyWithResponse), varargs...)
}

// DeleteConversationsConversationIdTagsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteConversationsConversationIdTagsWithResponse(arg0 context.Context, arg1 string, arg2 front.DeleteConversationsConversationIdTagsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.DeleteConversationsConversationIdTagsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteConversationsConversationIdTagsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteConversationsConversationIdTagsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteConversationsConversationIdTagsWithResponse indicates an expected call of DeleteConversationsConversationIdTagsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteConversationsConversationIdTagsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConversationsConversationIdTagsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteConversationsConversationIdTagsWithResponse), varargs...)
}

// DeleteDraftsDraftIdWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteDraftsDraftIdWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.DeleteDraftsDraftIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteDraftsDraftIdWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteDraftsDraftIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteDraftsDraftIdWithBodyWithResponse indicates an expected call of DeleteDraftsDraftIdWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteDraftsDraftIdWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDraftsDraftIdWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteDraftsDraftIdWithBodyWithResponse), varargs...)
}

// DeleteDraftsDraftIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteDraftsDraftIdWithResponse(arg0 context.Context, arg1 string, arg2 front.DeleteDraftsDraftIdJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.DeleteDraftsDraftIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteDraftsDraftIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteDraftsDraftIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteDraftsDraftIdWithResponse indicates an expected call of DeleteDraftsDraftIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteDraftsDraftIdWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDraftsDraftIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteDraftsDraftIdWithResponse), varargs...)
}

// DeleteInboxesInboxIdTeammatesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteInboxesInboxIdTeammatesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.DeleteInboxesInboxIdTeammatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteInboxesInboxIdTeammatesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteInboxesInboxIdTeammatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteInboxesInboxIdTeammatesWithBodyWithResponse indicates an expected call of DeleteInboxesInboxIdTeammatesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteInboxesInboxIdTeammatesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInboxesInboxIdTeammatesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteInboxesInboxIdTeammatesWithBodyWithResponse), varargs...)
}

// DeleteInboxesInboxIdTeammatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteInboxesInboxIdTeammatesWithResponse(arg0 context.Context, arg1 string, arg2 front.DeleteInboxesInboxIdTeammatesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.DeleteInboxesInboxIdTeammatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteInboxesInboxIdTeammatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteInboxesInboxIdTeammatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteInboxesInboxIdTeammatesWithResponse indicates an expected call of DeleteInboxesInboxIdTeammatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteInboxesInboxIdTeammatesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInboxesInboxIdTeammatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteInboxesInboxIdTeammatesWithResponse), varargs...)
}

// DeleteMessageTemplateFoldersMessageTemplateFolderIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteMessageTemplateFoldersMessageTemplateFolderIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.DeleteMessageTemplateFoldersMessageTemplateFolderIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMessageTemplateFoldersMessageTemplateFolderIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteMessageTemplateFoldersMessageTemplateFolderIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteMessageTemplateFoldersMessageTemplateFolderIdWithResponse indicates an expected call of DeleteMessageTemplateFoldersMessageTemplateFolderIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteMessageTemplateFoldersMessageTemplateFolderIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageTemplateFoldersMessageTemplateFolderIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteMessageTemplateFoldersMessageTemplateFolderIdWithResponse), varargs...)
}

// DeleteMessageTemplatesMessageTemplateIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteMessageTemplatesMessageTemplateIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.DeleteMessageTemplatesMessageTemplateIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMessageTemplatesMessageTemplateIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteMessageTemplatesMessageTemplateIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteMessageTemplatesMessageTemplateIdWithResponse indicates an expected call of DeleteMessageTemplatesMessageTemplateIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteMessageTemplatesMessageTemplateIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageTemplatesMessageTemplateIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteMessageTemplatesMessageTemplateIdWithResponse), varargs...)
}

// DeleteShiftShiftIdTeammatesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteShiftShiftIdTeammatesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.DeleteShiftShiftIdTeammatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteShiftShiftIdTeammatesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteShiftShiftIdTeammatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteShiftShiftIdTeammatesWithBodyWithResponse indicates an expected call of DeleteShiftShiftIdTeammatesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteShiftShiftIdTeammatesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteShiftShiftIdTeammatesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteShiftShiftIdTeammatesWithBodyWithResponse), varargs...)
}

// DeleteShiftShiftIdTeammatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteShiftShiftIdTeammatesWithResponse(arg0 context.Context, arg1 string, arg2 front.DeleteShiftShiftIdTeammatesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.DeleteShiftShiftIdTeammatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteShiftShiftIdTeammatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteShiftShiftIdTeammatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteShiftShiftIdTeammatesWithResponse indicates an expected call of DeleteShiftShiftIdTeammatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteShiftShiftIdTeammatesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteShiftShiftIdTeammatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteShiftShiftIdTeammatesWithResponse), varargs...)
}

// DeleteTagsTagIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteTagsTagIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.DeleteTagsTagIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTagsTagIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteTagsTagIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTagsTagIdWithResponse indicates an expected call of DeleteTagsTagIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteTagsTagIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagsTagIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteTagsTagIdWithResponse), varargs...)
}

// DeleteTeamsTeamIdTeammatesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteTeamsTeamIdTeammatesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.DeleteTeamsTeamIdTeammatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTeamsTeamIdTeammatesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteTeamsTeamIdTeammatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTeamsTeamIdTeammatesWithBodyWithResponse indicates an expected call of DeleteTeamsTeamIdTeammatesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteTeamsTeamIdTeammatesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTeamsTeamIdTeammatesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteTeamsTeamIdTeammatesWithBodyWithResponse), varargs...)
}

// DeleteTeamsTeamIdTeammatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteTeamsTeamIdTeammatesWithResponse(arg0 context.Context, arg1 string, arg2 front.DeleteTeamsTeamIdTeammatesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.DeleteTeamsTeamIdTeammatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTeamsTeamIdTeammatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.DeleteTeamsTeamIdTeammatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTeamsTeamIdTeammatesWithResponse indicates an expected call of DeleteTeamsTeamIdTeammatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteTeamsTeamIdTeammatesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTeamsTeamIdTeammatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteTeamsTeamIdTeammatesWithResponse), varargs...)
}

// GetAccountsAccountIdContactsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetAccountsAccountIdContactsWithResponse(arg0 context.Context, arg1 string, arg2 *front.GetAccountsAccountIdContactsParams, arg3 ...front.RequestEditorFn) (*front.GetAccountsAccountIdContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAccountsAccountIdContactsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetAccountsAccountIdContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccountsAccountIdContactsWithResponse indicates an expected call of GetAccountsAccountIdContactsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetAccountsAccountIdContactsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountsAccountIdContactsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetAccountsAccountIdContactsWithResponse), varargs...)
}

// GetAccountsAccountIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetAccountsAccountIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetAccountsAccountIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAccountsAccountIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetAccountsAccountIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccountsAccountIdWithResponse indicates an expected call of GetAccountsAccountIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetAccountsAccountIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountsAccountIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetAccountsAccountIdWithResponse), varargs...)
}

// GetAccountsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetAccountsWithResponse(arg0 context.Context, arg1 *front.GetAccountsParams, arg2 ...front.RequestEditorFn) (*front.GetAccountsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAccountsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetAccountsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccountsWithResponse indicates an expected call of GetAccountsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetAccountsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetAccountsWithResponse), varargs...)
}

// GetAnalyticsExportWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetAnalyticsExportWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetAnalyticsExportResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAnalyticsExportWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetAnalyticsExportResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAnalyticsExportWithResponse indicates an expected call of GetAnalyticsExportWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetAnalyticsExportWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAnalyticsExportWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetAnalyticsExportWithResponse), varargs...)
}

// GetAnalyticsReportWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetAnalyticsReportWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetAnalyticsReportResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAnalyticsReportWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetAnalyticsReportResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAnalyticsReportWithResponse indicates an expected call of GetAnalyticsReportWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetAnalyticsReportWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAnalyticsReportWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetAnalyticsReportWithResponse), varargs...)
}

// GetAnalyticsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetAnalyticsWithResponse(arg0 context.Context, arg1 *front.GetAnalyticsParams, arg2 ...front.RequestEditorFn) (*front.GetAnalyticsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAnalyticsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetAnalyticsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAnalyticsWithResponse indicates an expected call of GetAnalyticsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetAnalyticsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAnalyticsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetAnalyticsWithResponse), varargs...)
}

// GetChannelsChannelIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetChannelsChannelIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetChannelsChannelIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetChannelsChannelIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetChannelsChannelIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChannelsChannelIdWithResponse indicates an expected call of GetChannelsChannelIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetChannelsChannelIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChannelsChannelIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetChannelsChannelIdWithResponse), varargs...)
}

// GetChannelsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetChannelsWithResponse(arg0 context.Context, arg1 ...front.RequestEditorFn) (*front.GetChannelsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetChannelsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetChannelsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChannelsWithResponse indicates an expected call of GetChannelsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetChannelsWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChannelsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetChannelsWithResponse), varargs...)
}

// GetCommentsCommentIdMentionsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetCommentsCommentIdMentionsWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetCommentsCommentIdMentionsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCommentsCommentIdMentionsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetCommentsCommentIdMentionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCommentsCommentIdMentionsWithResponse indicates an expected call of GetCommentsCommentIdMentionsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetCommentsCommentIdMentionsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommentsCommentIdMentionsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetCommentsCommentIdMentionsWithResponse), varargs...)
}

// GetCommentsCommentIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetCommentsCommentIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetCommentsCommentIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCommentsCommentIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetCommentsCommentIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCommentsCommentIdWithResponse indicates an expected call of GetCommentsCommentIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetCommentsCommentIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommentsCommentIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetCommentsCommentIdWithResponse), varargs...)
}

// GetContactGroupsContactGroupIdContactsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetContactGroupsContactGroupIdContactsWithResponse(arg0 context.Context, arg1 string, arg2 *front.GetContactGroupsContactGroupIdContactsParams, arg3 ...front.RequestEditorFn) (*front.GetContactGroupsContactGroupIdContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetContactGroupsContactGroupIdContactsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetContactGroupsContactGroupIdContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContactGroupsContactGroupIdContactsWithResponse indicates an expected call of GetContactGroupsContactGroupIdContactsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetContactGroupsContactGroupIdContactsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContactGroupsContactGroupIdContactsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetContactGroupsContactGroupIdContactsWithResponse), varargs...)
}

// GetContactGroupsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetContactGroupsWithResponse(arg0 context.Context, arg1 ...front.RequestEditorFn) (*front.GetContactGroupsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetContactGroupsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetContactGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContactGroupsWithResponse indicates an expected call of GetContactGroupsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetContactGroupsWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContactGroupsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetContactGroupsWithResponse), varargs...)
}

// GetContactsContactIdConversationsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetContactsContactIdConversationsWithResponse(arg0 context.Context, arg1 string, arg2 *front.GetContactsContactIdConversationsParams, arg3 ...front.RequestEditorFn) (*front.GetContactsContactIdConversationsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetContactsContactIdConversationsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetContactsContactIdConversationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContactsContactIdConversationsWithResponse indicates an expected call of GetContactsContactIdConversationsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetContactsContactIdConversationsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContactsContactIdConversationsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetContactsContactIdConversationsWithResponse), varargs...)
}

// GetContactsContactIdNotesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetContactsContactIdNotesWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetContactsContactIdNotesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetContactsContactIdNotesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetContactsContactIdNotesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContactsContactIdNotesWithResponse indicates an expected call of GetContactsContactIdNotesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetContactsContactIdNotesWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContactsContactIdNotesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetContactsContactIdNotesWithResponse), varargs...)
}

// GetContactsContactIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetContactsContactIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetContactsContactIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetContactsContactIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetContactsContactIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContactsContactIdWithResponse indicates an expected call of GetContactsContactIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetContactsContactIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContactsContactIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetContactsContactIdWithResponse), varargs...)
}

// GetContactsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetContactsWithResponse(arg0 context.Context, arg1 *front.GetContactsParams, arg2 ...front.RequestEditorFn) (*front.GetContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetContactsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContactsWithResponse indicates an expected call of GetContactsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetContactsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContactsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetContactsWithResponse), varargs...)
}

// GetConversationByIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetConversationByIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetConversationByIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetConversationByIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetConversationByIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConversationByIdWithResponse indicates an expected call of GetConversationByIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetConversationByIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConversationByIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetConversationByIdWithResponse), varargs...)
}

// GetConversationsConversationIdCommentsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetConversationsConversationIdCommentsWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetConversationsConversationIdCommentsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetConversationsConversationIdCommentsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetConversationsConversationIdCommentsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConversationsConversationIdCommentsWithResponse indicates an expected call of GetConversationsConversationIdCommentsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetConversationsConversationIdCommentsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConversationsConversationIdCommentsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetConversationsConversationIdCommentsWithResponse), varargs...)
}

// GetConversationsConversationIdDraftsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetConversationsConversationIdDraftsWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetConversationsConversationIdDraftsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetConversationsConversationIdDraftsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetConversationsConversationIdDraftsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConversationsConversationIdDraftsWithResponse indicates an expected call of GetConversationsConversationIdDraftsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetConversationsConversationIdDraftsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConversationsConversationIdDraftsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetConversationsConversationIdDraftsWithResponse), varargs...)
}

// GetConversationsConversationIdEventsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetConversationsConversationIdEventsWithResponse(arg0 context.Context, arg1 string, arg2 *front.GetConversationsConversationIdEventsParams, arg3 ...front.RequestEditorFn) (*front.GetConversationsConversationIdEventsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetConversationsConversationIdEventsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetConversationsConversationIdEventsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConversationsConversationIdEventsWithResponse indicates an expected call of GetConversationsConversationIdEventsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetConversationsConversationIdEventsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConversationsConversationIdEventsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetConversationsConversationIdEventsWithResponse), varargs...)
}

// GetConversationsConversationIdFollowersWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetConversationsConversationIdFollowersWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetConversationsConversationIdFollowersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetConversationsConversationIdFollowersWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetConversationsConversationIdFollowersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConversationsConversationIdFollowersWithResponse indicates an expected call of GetConversationsConversationIdFollowersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetConversationsConversationIdFollowersWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConversationsConversationIdFollowersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetConversationsConversationIdFollowersWithResponse), varargs...)
}

// GetConversationsConversationIdInboxesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetConversationsConversationIdInboxesWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetConversationsConversationIdInboxesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetConversationsConversationIdInboxesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetConversationsConversationIdInboxesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConversationsConversationIdInboxesWithResponse indicates an expected call of GetConversationsConversationIdInboxesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetConversationsConversationIdInboxesWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConversationsConversationIdInboxesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetConversationsConversationIdInboxesWithResponse), varargs...)
}

// GetConversationsConversationIdMessagesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetConversationsConversationIdMessagesWithResponse(arg0 context.Context, arg1 string, arg2 *front.GetConversationsConversationIdMessagesParams, arg3 ...front.RequestEditorFn) (*front.GetConversationsConversationIdMessagesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetConversationsConversationIdMessagesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetConversationsConversationIdMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConversationsConversationIdMessagesWithResponse indicates an expected call of GetConversationsConversationIdMessagesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetConversationsConversationIdMessagesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConversationsConversationIdMessagesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetConversationsConversationIdMessagesWithResponse), varargs...)
}

// GetDownloadAttachmentLinkIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetDownloadAttachmentLinkIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetDownloadAttachmentLinkIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDownloadAttachmentLinkIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetDownloadAttachmentLinkIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDownloadAttachmentLinkIdWithResponse indicates an expected call of GetDownloadAttachmentLinkIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDownloadAttachmentLinkIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDownloadAttachmentLinkIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDownloadAttachmentLinkIdWithResponse), varargs...)
}

// GetEventsEventIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetEventsEventIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetEventsEventIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetEventsEventIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetEventsEventIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEventsEventIdWithResponse indicates an expected call of GetEventsEventIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetEventsEventIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventsEventIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetEventsEventIdWithResponse), varargs...)
}

// GetEventsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetEventsWithResponse(arg0 context.Context, arg1 *front.GetEventsParams, arg2 ...front.RequestEditorFn) (*front.GetEventsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetEventsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetEventsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEventsWithResponse indicates an expected call of GetEventsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetEventsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEventsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetEventsWithResponse), varargs...)
}

// GetExportsExportIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetExportsExportIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetExportsExportIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetExportsExportIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetExportsExportIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExportsExportIdWithResponse indicates an expected call of GetExportsExportIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetExportsExportIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExportsExportIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetExportsExportIdWithResponse), varargs...)
}

// GetExportsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetExportsWithResponse(arg0 context.Context, arg1 *front.GetExportsParams, arg2 ...front.RequestEditorFn) (*front.GetExportsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetExportsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetExportsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExportsWithResponse indicates an expected call of GetExportsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetExportsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExportsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetExportsWithResponse), varargs...)
}

// GetInboxesInboxIdChannelsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetInboxesInboxIdChannelsWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetInboxesInboxIdChannelsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInboxesInboxIdChannelsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetInboxesInboxIdChannelsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInboxesInboxIdChannelsWithResponse indicates an expected call of GetInboxesInboxIdChannelsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetInboxesInboxIdChannelsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInboxesInboxIdChannelsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetInboxesInboxIdChannelsWithResponse), varargs...)
}

// GetInboxesInboxIdConversationsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetInboxesInboxIdConversationsWithResponse(arg0 context.Context, arg1 string, arg2 *front.GetInboxesInboxIdConversationsParams, arg3 ...front.RequestEditorFn) (*front.GetInboxesInboxIdConversationsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInboxesInboxIdConversationsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetInboxesInboxIdConversationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInboxesInboxIdConversationsWithResponse indicates an expected call of GetInboxesInboxIdConversationsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetInboxesInboxIdConversationsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInboxesInboxIdConversationsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetInboxesInboxIdConversationsWithResponse), varargs...)
}

// GetInboxesInboxIdTeammatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetInboxesInboxIdTeammatesWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetInboxesInboxIdTeammatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInboxesInboxIdTeammatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetInboxesInboxIdTeammatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInboxesInboxIdTeammatesWithResponse indicates an expected call of GetInboxesInboxIdTeammatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetInboxesInboxIdTeammatesWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInboxesInboxIdTeammatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetInboxesInboxIdTeammatesWithResponse), varargs...)
}

// GetInboxesInboxIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetInboxesInboxIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetInboxesInboxIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInboxesInboxIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetInboxesInboxIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInboxesInboxIdWithResponse indicates an expected call of GetInboxesInboxIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetInboxesInboxIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInboxesInboxIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetInboxesInboxIdWithResponse), varargs...)
}

// GetInboxesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetInboxesWithResponse(arg0 context.Context, arg1 ...front.RequestEditorFn) (*front.GetInboxesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetInboxesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetInboxesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInboxesWithResponse indicates an expected call of GetInboxesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetInboxesWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInboxesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetInboxesWithResponse), varargs...)
}

// GetLinksLinkIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetLinksLinkIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetLinksLinkIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLinksLinkIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetLinksLinkIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLinksLinkIdWithResponse indicates an expected call of GetLinksLinkIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetLinksLinkIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLinksLinkIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetLinksLinkIdWithResponse), varargs...)
}

// GetLinksWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetLinksWithResponse(arg0 context.Context, arg1 *front.GetLinksParams, arg2 ...front.RequestEditorFn) (*front.GetLinksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLinksWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetLinksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLinksWithResponse indicates an expected call of GetLinksWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetLinksWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLinksWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetLinksWithResponse), varargs...)
}

// GetMeWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetMeWithResponse(arg0 context.Context, arg1 ...front.RequestEditorFn) (*front.GetMeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMeWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetMeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMeWithResponse indicates an expected call of GetMeWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetMeWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMeWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetMeWithResponse), varargs...)
}

// GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse indicates an expected call of GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse), varargs...)
}

// GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse indicates an expected call of GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse), varargs...)
}

// GetMessageTemplateFoldersMessageTemplateFolderIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetMessageTemplateFoldersMessageTemplateFolderIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetMessageTemplateFoldersMessageTemplateFolderIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMessageTemplateFoldersMessageTemplateFolderIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetMessageTemplateFoldersMessageTemplateFolderIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMessageTemplateFoldersMessageTemplateFolderIdWithResponse indicates an expected call of GetMessageTemplateFoldersMessageTemplateFolderIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetMessageTemplateFoldersMessageTemplateFolderIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMessageTemplateFoldersMessageTemplateFolderIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetMessageTemplateFoldersMessageTemplateFolderIdWithResponse), varargs...)
}

// GetMessageTemplateFoldersWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetMessageTemplateFoldersWithResponse(arg0 context.Context, arg1 ...front.RequestEditorFn) (*front.GetMessageTemplateFoldersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMessageTemplateFoldersWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetMessageTemplateFoldersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMessageTemplateFoldersWithResponse indicates an expected call of GetMessageTemplateFoldersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetMessageTemplateFoldersWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMessageTemplateFoldersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetMessageTemplateFoldersWithResponse), varargs...)
}

// GetMessageTemplatesMessageTemplateIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetMessageTemplatesMessageTemplateIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetMessageTemplatesMessageTemplateIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMessageTemplatesMessageTemplateIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetMessageTemplatesMessageTemplateIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMessageTemplatesMessageTemplateIdWithResponse indicates an expected call of GetMessageTemplatesMessageTemplateIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetMessageTemplatesMessageTemplateIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMessageTemplatesMessageTemplateIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetMessageTemplatesMessageTemplateIdWithResponse), varargs...)
}

// GetMessageTemplatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetMessageTemplatesWithResponse(arg0 context.Context, arg1 ...front.RequestEditorFn) (*front.GetMessageTemplatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMessageTemplatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetMessageTemplatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMessageTemplatesWithResponse indicates an expected call of GetMessageTemplatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetMessageTemplatesWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMessageTemplatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetMessageTemplatesWithResponse), varargs...)
}

// GetMessagesMessageIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetMessagesMessageIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetMessagesMessageIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMessagesMessageIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetMessagesMessageIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMessagesMessageIdWithResponse indicates an expected call of GetMessagesMessageIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetMessagesMessageIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMessagesMessageIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetMessagesMessageIdWithResponse), varargs...)
}

// GetRulesRuleIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetRulesRuleIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetRulesRuleIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetRulesRuleIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetRulesRuleIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRulesRuleIdWithResponse indicates an expected call of GetRulesRuleIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetRulesRuleIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRulesRuleIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetRulesRuleIdWithResponse), varargs...)
}

// GetRulesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetRulesWithResponse(arg0 context.Context, arg1 ...front.RequestEditorFn) (*front.GetRulesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetRulesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetRulesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRulesWithResponse indicates an expected call of GetRulesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetRulesWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRulesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetRulesWithResponse), varargs...)
}

// GetShiftShiftIdTeammatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetShiftShiftIdTeammatesWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetShiftShiftIdTeammatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetShiftShiftIdTeammatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetShiftShiftIdTeammatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetShiftShiftIdTeammatesWithResponse indicates an expected call of GetShiftShiftIdTeammatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetShiftShiftIdTeammatesWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShiftShiftIdTeammatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetShiftShiftIdTeammatesWithResponse), varargs...)
}

// GetShiftShiftIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetShiftShiftIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetShiftShiftIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetShiftShiftIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetShiftShiftIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetShiftShiftIdWithResponse indicates an expected call of GetShiftShiftIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetShiftShiftIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShiftShiftIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetShiftShiftIdWithResponse), varargs...)
}

// GetTagsTagIdChildrenWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTagsTagIdChildrenWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTagsTagIdChildrenResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTagsTagIdChildrenWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTagsTagIdChildrenResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTagsTagIdChildrenWithResponse indicates an expected call of GetTagsTagIdChildrenWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTagsTagIdChildrenWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagsTagIdChildrenWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTagsTagIdChildrenWithResponse), varargs...)
}

// GetTagsTagIdConversationsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTagsTagIdConversationsWithResponse(arg0 context.Context, arg1 string, arg2 *front.GetTagsTagIdConversationsParams, arg3 ...front.RequestEditorFn) (*front.GetTagsTagIdConversationsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTagsTagIdConversationsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTagsTagIdConversationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTagsTagIdConversationsWithResponse indicates an expected call of GetTagsTagIdConversationsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTagsTagIdConversationsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagsTagIdConversationsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTagsTagIdConversationsWithResponse), varargs...)
}

// GetTagsTagIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTagsTagIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTagsTagIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTagsTagIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTagsTagIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTagsTagIdWithResponse indicates an expected call of GetTagsTagIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTagsTagIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagsTagIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTagsTagIdWithResponse), varargs...)
}

// GetTagsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTagsWithResponse(arg0 context.Context, arg1 ...front.RequestEditorFn) (*front.GetTagsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTagsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTagsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTagsWithResponse indicates an expected call of GetTagsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTagsWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTagsWithResponse), varargs...)
}

// GetTeamTeamIdRulesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeamTeamIdRulesWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeamTeamIdRulesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeamTeamIdRulesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeamTeamIdRulesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeamTeamIdRulesWithResponse indicates an expected call of GetTeamTeamIdRulesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeamTeamIdRulesWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamTeamIdRulesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeamTeamIdRulesWithResponse), varargs...)
}

// GetTeammatesTeammateIdChannelsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeammatesTeammateIdChannelsWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeammatesTeammateIdChannelsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeammatesTeammateIdChannelsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeammatesTeammateIdChannelsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeammatesTeammateIdChannelsWithResponse indicates an expected call of GetTeammatesTeammateIdChannelsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeammatesTeammateIdChannelsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeammatesTeammateIdChannelsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeammatesTeammateIdChannelsWithResponse), varargs...)
}

// GetTeammatesTeammateIdContactGroupsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeammatesTeammateIdContactGroupsWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeammatesTeammateIdContactGroupsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeammatesTeammateIdContactGroupsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeammatesTeammateIdContactGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeammatesTeammateIdContactGroupsWithResponse indicates an expected call of GetTeammatesTeammateIdContactGroupsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeammatesTeammateIdContactGroupsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeammatesTeammateIdContactGroupsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeammatesTeammateIdContactGroupsWithResponse), varargs...)
}

// GetTeammatesTeammateIdContactsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeammatesTeammateIdContactsWithResponse(arg0 context.Context, arg1 string, arg2 *front.GetTeammatesTeammateIdContactsParams, arg3 ...front.RequestEditorFn) (*front.GetTeammatesTeammateIdContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeammatesTeammateIdContactsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeammatesTeammateIdContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeammatesTeammateIdContactsWithResponse indicates an expected call of GetTeammatesTeammateIdContactsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeammatesTeammateIdContactsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeammatesTeammateIdContactsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeammatesTeammateIdContactsWithResponse), varargs...)
}

// GetTeammatesTeammateIdConversationsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeammatesTeammateIdConversationsWithResponse(arg0 context.Context, arg1 string, arg2 *front.GetTeammatesTeammateIdConversationsParams, arg3 ...front.RequestEditorFn) (*front.GetTeammatesTeammateIdConversationsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeammatesTeammateIdConversationsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeammatesTeammateIdConversationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeammatesTeammateIdConversationsWithResponse indicates an expected call of GetTeammatesTeammateIdConversationsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeammatesTeammateIdConversationsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeammatesTeammateIdConversationsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeammatesTeammateIdConversationsWithResponse), varargs...)
}

// GetTeammatesTeammateIdInboxesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeammatesTeammateIdInboxesWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeammatesTeammateIdInboxesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeammatesTeammateIdInboxesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeammatesTeammateIdInboxesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeammatesTeammateIdInboxesWithResponse indicates an expected call of GetTeammatesTeammateIdInboxesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeammatesTeammateIdInboxesWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeammatesTeammateIdInboxesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeammatesTeammateIdInboxesWithResponse), varargs...)
}

// GetTeammatesTeammateIdMessageTemplateFoldersWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeammatesTeammateIdMessageTemplateFoldersWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeammatesTeammateIdMessageTemplateFoldersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeammatesTeammateIdMessageTemplateFoldersWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeammatesTeammateIdMessageTemplateFoldersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeammatesTeammateIdMessageTemplateFoldersWithResponse indicates an expected call of GetTeammatesTeammateIdMessageTemplateFoldersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeammatesTeammateIdMessageTemplateFoldersWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeammatesTeammateIdMessageTemplateFoldersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeammatesTeammateIdMessageTemplateFoldersWithResponse), varargs...)
}

// GetTeammatesTeammateIdMessageTemplatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeammatesTeammateIdMessageTemplatesWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeammatesTeammateIdMessageTemplatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeammatesTeammateIdMessageTemplatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeammatesTeammateIdMessageTemplatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeammatesTeammateIdMessageTemplatesWithResponse indicates an expected call of GetTeammatesTeammateIdMessageTemplatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeammatesTeammateIdMessageTemplatesWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeammatesTeammateIdMessageTemplatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeammatesTeammateIdMessageTemplatesWithResponse), varargs...)
}

// GetTeammatesTeammateIdRulesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeammatesTeammateIdRulesWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeammatesTeammateIdRulesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeammatesTeammateIdRulesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeammatesTeammateIdRulesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeammatesTeammateIdRulesWithResponse indicates an expected call of GetTeammatesTeammateIdRulesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeammatesTeammateIdRulesWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeammatesTeammateIdRulesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeammatesTeammateIdRulesWithResponse), varargs...)
}

// GetTeammatesTeammateIdShiftsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeammatesTeammateIdShiftsWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeammatesTeammateIdShiftsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeammatesTeammateIdShiftsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeammatesTeammateIdShiftsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeammatesTeammateIdShiftsWithResponse indicates an expected call of GetTeammatesTeammateIdShiftsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeammatesTeammateIdShiftsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeammatesTeammateIdShiftsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeammatesTeammateIdShiftsWithResponse), varargs...)
}

// GetTeammatesTeammateIdTagsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeammatesTeammateIdTagsWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeammatesTeammateIdTagsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeammatesTeammateIdTagsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeammatesTeammateIdTagsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeammatesTeammateIdTagsWithResponse indicates an expected call of GetTeammatesTeammateIdTagsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeammatesTeammateIdTagsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeammatesTeammateIdTagsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeammatesTeammateIdTagsWithResponse), varargs...)
}

// GetTeammatesTeammateIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeammatesTeammateIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeammatesTeammateIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeammatesTeammateIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeammatesTeammateIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeammatesTeammateIdWithResponse indicates an expected call of GetTeammatesTeammateIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeammatesTeammateIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeammatesTeammateIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeammatesTeammateIdWithResponse), varargs...)
}

// GetTeammatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeammatesWithResponse(arg0 context.Context, arg1 ...front.RequestEditorFn) (*front.GetTeammatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeammatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeammatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeammatesWithResponse indicates an expected call of GetTeammatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeammatesWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeammatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeammatesWithResponse), varargs...)
}

// GetTeamsTeamIdAnalyticsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeamsTeamIdAnalyticsWithResponse(arg0 context.Context, arg1 string, arg2 *front.GetTeamsTeamIdAnalyticsParams, arg3 ...front.RequestEditorFn) (*front.GetTeamsTeamIdAnalyticsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeamsTeamIdAnalyticsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeamsTeamIdAnalyticsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeamsTeamIdAnalyticsWithResponse indicates an expected call of GetTeamsTeamIdAnalyticsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeamsTeamIdAnalyticsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamsTeamIdAnalyticsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeamsTeamIdAnalyticsWithResponse), varargs...)
}

// GetTeamsTeamIdChannelsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeamsTeamIdChannelsWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeamsTeamIdChannelsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeamsTeamIdChannelsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeamsTeamIdChannelsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeamsTeamIdChannelsWithResponse indicates an expected call of GetTeamsTeamIdChannelsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeamsTeamIdChannelsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamsTeamIdChannelsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeamsTeamIdChannelsWithResponse), varargs...)
}

// GetTeamsTeamIdContactGroupsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeamsTeamIdContactGroupsWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeamsTeamIdContactGroupsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeamsTeamIdContactGroupsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeamsTeamIdContactGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeamsTeamIdContactGroupsWithResponse indicates an expected call of GetTeamsTeamIdContactGroupsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeamsTeamIdContactGroupsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamsTeamIdContactGroupsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeamsTeamIdContactGroupsWithResponse), varargs...)
}

// GetTeamsTeamIdContactsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeamsTeamIdContactsWithResponse(arg0 context.Context, arg1 string, arg2 *front.GetTeamsTeamIdContactsParams, arg3 ...front.RequestEditorFn) (*front.GetTeamsTeamIdContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeamsTeamIdContactsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeamsTeamIdContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeamsTeamIdContactsWithResponse indicates an expected call of GetTeamsTeamIdContactsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeamsTeamIdContactsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamsTeamIdContactsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeamsTeamIdContactsWithResponse), varargs...)
}

// GetTeamsTeamIdInboxesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeamsTeamIdInboxesWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeamsTeamIdInboxesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeamsTeamIdInboxesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeamsTeamIdInboxesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeamsTeamIdInboxesWithResponse indicates an expected call of GetTeamsTeamIdInboxesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeamsTeamIdInboxesWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamsTeamIdInboxesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeamsTeamIdInboxesWithResponse), varargs...)
}

// GetTeamsTeamIdMessageTemplateFoldersWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeamsTeamIdMessageTemplateFoldersWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeamsTeamIdMessageTemplateFoldersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeamsTeamIdMessageTemplateFoldersWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeamsTeamIdMessageTemplateFoldersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeamsTeamIdMessageTemplateFoldersWithResponse indicates an expected call of GetTeamsTeamIdMessageTemplateFoldersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeamsTeamIdMessageTemplateFoldersWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamsTeamIdMessageTemplateFoldersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeamsTeamIdMessageTemplateFoldersWithResponse), varargs...)
}

// GetTeamsTeamIdMessageTemplatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeamsTeamIdMessageTemplatesWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeamsTeamIdMessageTemplatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeamsTeamIdMessageTemplatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeamsTeamIdMessageTemplatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeamsTeamIdMessageTemplatesWithResponse indicates an expected call of GetTeamsTeamIdMessageTemplatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeamsTeamIdMessageTemplatesWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamsTeamIdMessageTemplatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeamsTeamIdMessageTemplatesWithResponse), varargs...)
}

// GetTeamsTeamIdShiftsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeamsTeamIdShiftsWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeamsTeamIdShiftsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeamsTeamIdShiftsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeamsTeamIdShiftsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeamsTeamIdShiftsWithResponse indicates an expected call of GetTeamsTeamIdShiftsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeamsTeamIdShiftsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamsTeamIdShiftsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeamsTeamIdShiftsWithResponse), varargs...)
}

// GetTeamsTeamIdTagsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeamsTeamIdTagsWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeamsTeamIdTagsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeamsTeamIdTagsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeamsTeamIdTagsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeamsTeamIdTagsWithResponse indicates an expected call of GetTeamsTeamIdTagsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeamsTeamIdTagsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamsTeamIdTagsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeamsTeamIdTagsWithResponse), varargs...)
}

// GetTeamsTeamIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeamsTeamIdWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.GetTeamsTeamIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeamsTeamIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeamsTeamIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeamsTeamIdWithResponse indicates an expected call of GetTeamsTeamIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeamsTeamIdWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamsTeamIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeamsTeamIdWithResponse), varargs...)
}

// GetTeamsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetTeamsWithResponse(arg0 context.Context, arg1 ...front.RequestEditorFn) (*front.GetTeamsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTeamsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.GetTeamsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTeamsWithResponse indicates an expected call of GetTeamsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTeamsWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTeamsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTeamsWithResponse), varargs...)
}

// ImportInboxMessageWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) ImportInboxMessageWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.ImportInboxMessageResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImportInboxMessageWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.ImportInboxMessageResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImportInboxMessageWithBodyWithResponse indicates an expected call of ImportInboxMessageWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ImportInboxMessageWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInboxMessageWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ImportInboxMessageWithBodyWithResponse), varargs...)
}

// ImportInboxMessageWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) ImportInboxMessageWithResponse(arg0 context.Context, arg1 string, arg2 front.ImportInboxMessageJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.ImportInboxMessageResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImportInboxMessageWithResponse", varargs...)
	ret0, _ := ret[0].(*front.ImportInboxMessageResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImportInboxMessageWithResponse indicates an expected call of ImportInboxMessageWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ImportInboxMessageWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInboxMessageWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ImportInboxMessageWithResponse), varargs...)
}

// ListContactCustomFieldsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) ListContactCustomFieldsWithResponse(arg0 context.Context, arg1 ...front.RequestEditorFn) (*front.ListContactCustomFieldsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListContactCustomFieldsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.ListContactCustomFieldsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListContactCustomFieldsWithResponse indicates an expected call of ListContactCustomFieldsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ListContactCustomFieldsWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContactCustomFieldsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ListContactCustomFieldsWithResponse), varargs...)
}

// ListConversationsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) ListConversationsWithResponse(arg0 context.Context, arg1 *front.ListConversationsParams, arg2 ...front.RequestEditorFn) (*front.ListConversationsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListConversationsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.ListConversationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListConversationsWithResponse indicates an expected call of ListConversationsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ListConversationsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConversationsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ListConversationsWithResponse), varargs...)
}

// ListCustomFieldsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) ListCustomFieldsWithResponse(arg0 context.Context, arg1 ...front.RequestEditorFn) (*front.ListCustomFieldsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCustomFieldsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.ListCustomFieldsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCustomFieldsWithResponse indicates an expected call of ListCustomFieldsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ListCustomFieldsWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCustomFieldsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ListCustomFieldsWithResponse), varargs...)
}

// ListLinkConversationsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) ListLinkConversationsWithResponse(arg0 context.Context, arg1 string, arg2 *front.ListLinkConversationsParams, arg3 ...front.RequestEditorFn) (*front.ListLinkConversationsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListLinkConversationsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.ListLinkConversationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLinkConversationsWithResponse indicates an expected call of ListLinkConversationsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ListLinkConversationsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLinkConversationsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ListLinkConversationsWithResponse), varargs...)
}

// ListShiftsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) ListShiftsWithResponse(arg0 context.Context, arg1 ...front.RequestEditorFn) (*front.ListShiftsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListShiftsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.ListShiftsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListShiftsWithResponse indicates an expected call of ListShiftsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ListShiftsWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListShiftsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ListShiftsWithResponse), varargs...)
}

// PatchAccountsAccountIdWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchAccountsAccountIdWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PatchAccountsAccountIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchAccountsAccountIdWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchAccountsAccountIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchAccountsAccountIdWithBodyWithResponse indicates an expected call of PatchAccountsAccountIdWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchAccountsAccountIdWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchAccountsAccountIdWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchAccountsAccountIdWithBodyWithResponse), varargs...)
}

// PatchAccountsAccountIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchAccountsAccountIdWithResponse(arg0 context.Context, arg1 string, arg2 front.PatchAccountsAccountIdJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PatchAccountsAccountIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchAccountsAccountIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchAccountsAccountIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchAccountsAccountIdWithResponse indicates an expected call of PatchAccountsAccountIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchAccountsAccountIdWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchAccountsAccountIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchAccountsAccountIdWithResponse), varargs...)
}

// PatchChannelsChannelIdWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchChannelsChannelIdWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PatchChannelsChannelIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchChannelsChannelIdWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchChannelsChannelIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchChannelsChannelIdWithBodyWithResponse indicates an expected call of PatchChannelsChannelIdWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchChannelsChannelIdWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchChannelsChannelIdWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchChannelsChannelIdWithBodyWithResponse), varargs...)
}

// PatchChannelsChannelIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchChannelsChannelIdWithResponse(arg0 context.Context, arg1 string, arg2 front.PatchChannelsChannelIdJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PatchChannelsChannelIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchChannelsChannelIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchChannelsChannelIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchChannelsChannelIdWithResponse indicates an expected call of PatchChannelsChannelIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchChannelsChannelIdWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchChannelsChannelIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchChannelsChannelIdWithResponse), varargs...)
}

// PatchContactsContactIdWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchContactsContactIdWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PatchContactsContactIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchContactsContactIdWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchContactsContactIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchContactsContactIdWithBodyWithResponse indicates an expected call of PatchContactsContactIdWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchContactsContactIdWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchContactsContactIdWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchContactsContactIdWithBodyWithResponse), varargs...)
}

// PatchContactsContactIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchContactsContactIdWithResponse(arg0 context.Context, arg1 string, arg2 front.PatchContactsContactIdJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PatchContactsContactIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchContactsContactIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchContactsContactIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchContactsContactIdWithResponse indicates an expected call of PatchContactsContactIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchContactsContactIdWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchContactsContactIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchContactsContactIdWithResponse), varargs...)
}

// PatchConversationsConversationIdRemindersWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchConversationsConversationIdRemindersWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PatchConversationsConversationIdRemindersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchConversationsConversationIdRemindersWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchConversationsConversationIdRemindersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchConversationsConversationIdRemindersWithBodyWithResponse indicates an expected call of PatchConversationsConversationIdRemindersWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchConversationsConversationIdRemindersWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchConversationsConversationIdRemindersWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchConversationsConversationIdRemindersWithBodyWithResponse), varargs...)
}

// PatchConversationsConversationIdRemindersWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchConversationsConversationIdRemindersWithResponse(arg0 context.Context, arg1 string, arg2 front.PatchConversationsConversationIdRemindersJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PatchConversationsConversationIdRemindersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchConversationsConversationIdRemindersWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchConversationsConversationIdRemindersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchConversationsConversationIdRemindersWithResponse indicates an expected call of PatchConversationsConversationIdRemindersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchConversationsConversationIdRemindersWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchConversationsConversationIdRemindersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchConversationsConversationIdRemindersWithResponse), varargs...)
}

// PatchConversationsConversationIdWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchConversationsConversationIdWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PatchConversationsConversationIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchConversationsConversationIdWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchConversationsConversationIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchConversationsConversationIdWithBodyWithResponse indicates an expected call of PatchConversationsConversationIdWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchConversationsConversationIdWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchConversationsConversationIdWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchConversationsConversationIdWithBodyWithResponse), varargs...)
}

// PatchConversationsConversationIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchConversationsConversationIdWithResponse(arg0 context.Context, arg1 string, arg2 front.PatchConversationsConversationIdJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PatchConversationsConversationIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchConversationsConversationIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchConversationsConversationIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchConversationsConversationIdWithResponse indicates an expected call of PatchConversationsConversationIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchConversationsConversationIdWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchConversationsConversationIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchConversationsConversationIdWithResponse), varargs...)
}

// PatchCustomFieldsCustomFieldIdWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchCustomFieldsCustomFieldIdWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PatchCustomFieldsCustomFieldIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchCustomFieldsCustomFieldIdWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchCustomFieldsCustomFieldIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchCustomFieldsCustomFieldIdWithBodyWithResponse indicates an expected call of PatchCustomFieldsCustomFieldIdWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchCustomFieldsCustomFieldIdWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchCustomFieldsCustomFieldIdWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchCustomFieldsCustomFieldIdWithBodyWithResponse), varargs...)
}

// PatchCustomFieldsCustomFieldIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchCustomFieldsCustomFieldIdWithResponse(arg0 context.Context, arg1 string, arg2 front.PatchCustomFieldsCustomFieldIdJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PatchCustomFieldsCustomFieldIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchCustomFieldsCustomFieldIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchCustomFieldsCustomFieldIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchCustomFieldsCustomFieldIdWithResponse indicates an expected call of PatchCustomFieldsCustomFieldIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchCustomFieldsCustomFieldIdWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchCustomFieldsCustomFieldIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchCustomFieldsCustomFieldIdWithResponse), varargs...)
}

// PatchDraftsMessageIdWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchDraftsMessageIdWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PatchDraftsMessageIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchDraftsMessageIdWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchDraftsMessageIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchDraftsMessageIdWithBodyWithResponse indicates an expected call of PatchDraftsMessageIdWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchDraftsMessageIdWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDraftsMessageIdWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchDraftsMessageIdWithBodyWithResponse), varargs...)
}

// PatchDraftsMessageIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchDraftsMessageIdWithResponse(arg0 context.Context, arg1 string, arg2 front.PatchDraftsMessageIdJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PatchDraftsMessageIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchDraftsMessageIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchDraftsMessageIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchDraftsMessageIdWithResponse indicates an expected call of PatchDraftsMessageIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchDraftsMessageIdWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDraftsMessageIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchDraftsMessageIdWithResponse), varargs...)
}

// PatchLinksLinkIdWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchLinksLinkIdWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PatchLinksLinkIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchLinksLinkIdWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchLinksLinkIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchLinksLinkIdWithBodyWithResponse indicates an expected call of PatchLinksLinkIdWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchLinksLinkIdWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchLinksLinkIdWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchLinksLinkIdWithBodyWithResponse), varargs...)
}

// PatchLinksLinkIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchLinksLinkIdWithResponse(arg0 context.Context, arg1 string, arg2 front.PatchLinksLinkIdJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PatchLinksLinkIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchLinksLinkIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchLinksLinkIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchLinksLinkIdWithResponse indicates an expected call of PatchLinksLinkIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchLinksLinkIdWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchLinksLinkIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchLinksLinkIdWithResponse), varargs...)
}

// PatchMessageTemplateFoldersMessageTemplateFolderIdWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchMessageTemplateFoldersMessageTemplateFolderIdWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PatchMessageTemplateFoldersMessageTemplateFolderIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchMessageTemplateFoldersMessageTemplateFolderIdWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchMessageTemplateFoldersMessageTemplateFolderIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchMessageTemplateFoldersMessageTemplateFolderIdWithBodyWithResponse indicates an expected call of PatchMessageTemplateFoldersMessageTemplateFolderIdWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchMessageTemplateFoldersMessageTemplateFolderIdWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchMessageTemplateFoldersMessageTemplateFolderIdWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchMessageTemplateFoldersMessageTemplateFolderIdWithBodyWithResponse), varargs...)
}

// PatchMessageTemplateFoldersMessageTemplateFolderIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchMessageTemplateFoldersMessageTemplateFolderIdWithResponse(arg0 context.Context, arg1 string, arg2 front.PatchMessageTemplateFoldersMessageTemplateFolderIdJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PatchMessageTemplateFoldersMessageTemplateFolderIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchMessageTemplateFoldersMessageTemplateFolderIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchMessageTemplateFoldersMessageTemplateFolderIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchMessageTemplateFoldersMessageTemplateFolderIdWithResponse indicates an expected call of PatchMessageTemplateFoldersMessageTemplateFolderIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchMessageTemplateFoldersMessageTemplateFolderIdWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchMessageTemplateFoldersMessageTemplateFolderIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchMessageTemplateFoldersMessageTemplateFolderIdWithResponse), varargs...)
}

// PatchMessageTemplatesMessageTemplateIdWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchMessageTemplatesMessageTemplateIdWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PatchMessageTemplatesMessageTemplateIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchMessageTemplatesMessageTemplateIdWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchMessageTemplatesMessageTemplateIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchMessageTemplatesMessageTemplateIdWithBodyWithResponse indicates an expected call of PatchMessageTemplatesMessageTemplateIdWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchMessageTemplatesMessageTemplateIdWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchMessageTemplatesMessageTemplateIdWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchMessageTemplatesMessageTemplateIdWithBodyWithResponse), varargs...)
}

// PatchMessageTemplatesMessageTemplateIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchMessageTemplatesMessageTemplateIdWithResponse(arg0 context.Context, arg1 string, arg2 front.PatchMessageTemplatesMessageTemplateIdJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PatchMessageTemplatesMessageTemplateIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchMessageTemplatesMessageTemplateIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchMessageTemplatesMessageTemplateIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchMessageTemplatesMessageTemplateIdWithResponse indicates an expected call of PatchMessageTemplatesMessageTemplateIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchMessageTemplatesMessageTemplateIdWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchMessageTemplatesMessageTemplateIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchMessageTemplatesMessageTemplateIdWithResponse), varargs...)
}

// PatchShiftsShiftIdWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchShiftsShiftIdWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PatchShiftsShiftIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchShiftsShiftIdWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchShiftsShiftIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchShiftsShiftIdWithBodyWithResponse indicates an expected call of PatchShiftsShiftIdWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchShiftsShiftIdWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchShiftsShiftIdWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchShiftsShiftIdWithBodyWithResponse), varargs...)
}

// PatchShiftsShiftIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchShiftsShiftIdWithResponse(arg0 context.Context, arg1 string, arg2 front.PatchShiftsShiftIdJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PatchShiftsShiftIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchShiftsShiftIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchShiftsShiftIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchShiftsShiftIdWithResponse indicates an expected call of PatchShiftsShiftIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchShiftsShiftIdWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchShiftsShiftIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchShiftsShiftIdWithResponse), varargs...)
}

// PatchTagsTagIdWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchTagsTagIdWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PatchTagsTagIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchTagsTagIdWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchTagsTagIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchTagsTagIdWithBodyWithResponse indicates an expected call of PatchTagsTagIdWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchTagsTagIdWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchTagsTagIdWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchTagsTagIdWithBodyWithResponse), varargs...)
}

// PatchTagsTagIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchTagsTagIdWithResponse(arg0 context.Context, arg1 string, arg2 front.PatchTagsTagIdJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PatchTagsTagIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchTagsTagIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchTagsTagIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchTagsTagIdWithResponse indicates an expected call of PatchTagsTagIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchTagsTagIdWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchTagsTagIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchTagsTagIdWithResponse), varargs...)
}

// PatchTeammatesTeammateIdWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchTeammatesTeammateIdWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PatchTeammatesTeammateIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchTeammatesTeammateIdWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchTeammatesTeammateIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchTeammatesTeammateIdWithBodyWithResponse indicates an expected call of PatchTeammatesTeammateIdWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchTeammatesTeammateIdWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchTeammatesTeammateIdWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchTeammatesTeammateIdWithBodyWithResponse), varargs...)
}

// PatchTeammatesTeammateIdWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PatchTeammatesTeammateIdWithResponse(arg0 context.Context, arg1 string, arg2 front.PatchTeammatesTeammateIdJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PatchTeammatesTeammateIdResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchTeammatesTeammateIdWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PatchTeammatesTeammateIdResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PatchTeammatesTeammateIdWithResponse indicates an expected call of PatchTeammatesTeammateIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchTeammatesTeammateIdWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchTeammatesTeammateIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchTeammatesTeammateIdWithResponse), varargs...)
}

// PostAccountsAccountIdContactsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostAccountsAccountIdContactsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostAccountsAccountIdContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostAccountsAccountIdContactsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostAccountsAccountIdContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostAccountsAccountIdContactsWithBodyWithResponse indicates an expected call of PostAccountsAccountIdContactsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostAccountsAccountIdContactsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostAccountsAccountIdContactsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostAccountsAccountIdContactsWithBodyWithResponse), varargs...)
}

// PostAccountsAccountIdContactsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostAccountsAccountIdContactsWithResponse(arg0 context.Context, arg1 string, arg2 front.PostAccountsAccountIdContactsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostAccountsAccountIdContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostAccountsAccountIdContactsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostAccountsAccountIdContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostAccountsAccountIdContactsWithResponse indicates an expected call of PostAccountsAccountIdContactsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostAccountsAccountIdContactsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostAccountsAccountIdContactsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostAccountsAccountIdContactsWithResponse), varargs...)
}

// PostAccountsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostAccountsWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...front.RequestEditorFn) (*front.PostAccountsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostAccountsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostAccountsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostAccountsWithBodyWithResponse indicates an expected call of PostAccountsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostAccountsWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostAccountsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostAccountsWithBodyWithResponse), varargs...)
}

// PostAccountsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostAccountsWithResponse(arg0 context.Context, arg1 front.PostAccountsJSONRequestBody, arg2 ...front.RequestEditorFn) (*front.PostAccountsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostAccountsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostAccountsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostAccountsWithResponse indicates an expected call of PostAccountsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostAccountsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostAccountsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostAccountsWithResponse), varargs...)
}

// PostChannelsChannelIdDraftsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostChannelsChannelIdDraftsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostChannelsChannelIdDraftsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostChannelsChannelIdDraftsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostChannelsChannelIdDraftsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostChannelsChannelIdDraftsWithBodyWithResponse indicates an expected call of PostChannelsChannelIdDraftsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostChannelsChannelIdDraftsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostChannelsChannelIdDraftsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostChannelsChannelIdDraftsWithBodyWithResponse), varargs...)
}

// PostChannelsChannelIdDraftsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostChannelsChannelIdDraftsWithResponse(arg0 context.Context, arg1 string, arg2 front.PostChannelsChannelIdDraftsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostChannelsChannelIdDraftsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostChannelsChannelIdDraftsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostChannelsChannelIdDraftsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostChannelsChannelIdDraftsWithResponse indicates an expected call of PostChannelsChannelIdDraftsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostChannelsChannelIdDraftsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostChannelsChannelIdDraftsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostChannelsChannelIdDraftsWithResponse), varargs...)
}

// PostChannelsChannelIdIncomingMessagesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostChannelsChannelIdIncomingMessagesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostChannelsChannelIdIncomingMessagesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostChannelsChannelIdIncomingMessagesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostChannelsChannelIdIncomingMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostChannelsChannelIdIncomingMessagesWithBodyWithResponse indicates an expected call of PostChannelsChannelIdIncomingMessagesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostChannelsChannelIdIncomingMessagesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostChannelsChannelIdIncomingMessagesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostChannelsChannelIdIncomingMessagesWithBodyWithResponse), varargs...)
}

// PostChannelsChannelIdIncomingMessagesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostChannelsChannelIdIncomingMessagesWithResponse(arg0 context.Context, arg1 string, arg2 front.PostChannelsChannelIdIncomingMessagesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostChannelsChannelIdIncomingMessagesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostChannelsChannelIdIncomingMessagesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostChannelsChannelIdIncomingMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostChannelsChannelIdIncomingMessagesWithResponse indicates an expected call of PostChannelsChannelIdIncomingMessagesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostChannelsChannelIdIncomingMessagesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostChannelsChannelIdIncomingMessagesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostChannelsChannelIdIncomingMessagesWithResponse), varargs...)
}

// PostChannelsChannelIdMessagesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostChannelsChannelIdMessagesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostChannelsChannelIdMessagesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostChannelsChannelIdMessagesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostChannelsChannelIdMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostChannelsChannelIdMessagesWithBodyWithResponse indicates an expected call of PostChannelsChannelIdMessagesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostChannelsChannelIdMessagesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostChannelsChannelIdMessagesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostChannelsChannelIdMessagesWithBodyWithResponse), varargs...)
}

// PostChannelsChannelIdMessagesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostChannelsChannelIdMessagesWithResponse(arg0 context.Context, arg1 string, arg2 front.PostChannelsChannelIdMessagesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostChannelsChannelIdMessagesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostChannelsChannelIdMessagesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostChannelsChannelIdMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostChannelsChannelIdMessagesWithResponse indicates an expected call of PostChannelsChannelIdMessagesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostChannelsChannelIdMessagesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostChannelsChannelIdMessagesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostChannelsChannelIdMessagesWithResponse), varargs...)
}

// PostChannelsChannelIdValidateWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostChannelsChannelIdValidateWithResponse(arg0 context.Context, arg1 string, arg2 ...front.RequestEditorFn) (*front.PostChannelsChannelIdValidateResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostChannelsChannelIdValidateWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostChannelsChannelIdValidateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostChannelsChannelIdValidateWithResponse indicates an expected call of PostChannelsChannelIdValidateWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostChannelsChannelIdValidateWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostChannelsChannelIdValidateWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostChannelsChannelIdValidateWithResponse), varargs...)
}

// PostContactGroupsContactGroupIdContactsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostContactGroupsContactGroupIdContactsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostContactGroupsContactGroupIdContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostContactGroupsContactGroupIdContactsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostContactGroupsContactGroupIdContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostContactGroupsContactGroupIdContactsWithBodyWithResponse indicates an expected call of PostContactGroupsContactGroupIdContactsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostContactGroupsContactGroupIdContactsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostContactGroupsContactGroupIdContactsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostContactGroupsContactGroupIdContactsWithBodyWithResponse), varargs...)
}

// PostContactGroupsContactGroupIdContactsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostContactGroupsContactGroupIdContactsWithResponse(arg0 context.Context, arg1 string, arg2 front.PostContactGroupsContactGroupIdContactsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostContactGroupsContactGroupIdContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostContactGroupsContactGroupIdContactsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostContactGroupsContactGroupIdContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostContactGroupsContactGroupIdContactsWithResponse indicates an expected call of PostContactGroupsContactGroupIdContactsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostContactGroupsContactGroupIdContactsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostContactGroupsContactGroupIdContactsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostContactGroupsContactGroupIdContactsWithResponse), varargs...)
}

// PostContactGroupsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostContactGroupsWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...front.RequestEditorFn) (*front.PostContactGroupsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostContactGroupsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostContactGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostContactGroupsWithBodyWithResponse indicates an expected call of PostContactGroupsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostContactGroupsWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostContactGroupsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostContactGroupsWithBodyWithResponse), varargs...)
}

// PostContactGroupsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostContactGroupsWithResponse(arg0 context.Context, arg1 front.PostContactGroupsJSONRequestBody, arg2 ...front.RequestEditorFn) (*front.PostContactGroupsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostContactGroupsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostContactGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostContactGroupsWithResponse indicates an expected call of PostContactGroupsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostContactGroupsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostContactGroupsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostContactGroupsWithResponse), varargs...)
}

// PostContactsContactIdHandlesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostContactsContactIdHandlesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostContactsContactIdHandlesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostContactsContactIdHandlesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostContactsContactIdHandlesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostContactsContactIdHandlesWithBodyWithResponse indicates an expected call of PostContactsContactIdHandlesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostContactsContactIdHandlesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostContactsContactIdHandlesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostContactsContactIdHandlesWithBodyWithResponse), varargs...)
}

// PostContactsContactIdHandlesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostContactsContactIdHandlesWithResponse(arg0 context.Context, arg1 string, arg2 front.PostContactsContactIdHandlesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostContactsContactIdHandlesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostContactsContactIdHandlesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostContactsContactIdHandlesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostContactsContactIdHandlesWithResponse indicates an expected call of PostContactsContactIdHandlesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostContactsContactIdHandlesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostContactsContactIdHandlesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostContactsContactIdHandlesWithResponse), varargs...)
}

// PostContactsContactIdNotesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostContactsContactIdNotesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostContactsContactIdNotesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostContactsContactIdNotesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostContactsContactIdNotesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostContactsContactIdNotesWithBodyWithResponse indicates an expected call of PostContactsContactIdNotesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostContactsContactIdNotesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostContactsContactIdNotesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostContactsContactIdNotesWithBodyWithResponse), varargs...)
}

// PostContactsContactIdNotesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostContactsContactIdNotesWithResponse(arg0 context.Context, arg1 string, arg2 front.PostContactsContactIdNotesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostContactsContactIdNotesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostContactsContactIdNotesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostContactsContactIdNotesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostContactsContactIdNotesWithResponse indicates an expected call of PostContactsContactIdNotesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostContactsContactIdNotesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostContactsContactIdNotesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostContactsContactIdNotesWithResponse), varargs...)
}

// PostContactsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostContactsWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...front.RequestEditorFn) (*front.PostContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostContactsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostContactsWithBodyWithResponse indicates an expected call of PostContactsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostContactsWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostContactsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostContactsWithBodyWithResponse), varargs...)
}

// PostContactsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostContactsWithResponse(arg0 context.Context, arg1 front.PostContactsJSONRequestBody, arg2 ...front.RequestEditorFn) (*front.PostContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostContactsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostContactsWithResponse indicates an expected call of PostContactsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostContactsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostContactsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostContactsWithResponse), varargs...)
}

// PostConversationsConversationIdCommentsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostConversationsConversationIdCommentsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostConversationsConversationIdCommentsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostConversationsConversationIdCommentsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostConversationsConversationIdCommentsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostConversationsConversationIdCommentsWithBodyWithResponse indicates an expected call of PostConversationsConversationIdCommentsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostConversationsConversationIdCommentsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostConversationsConversationIdCommentsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostConversationsConversationIdCommentsWithBodyWithResponse), varargs...)
}

// PostConversationsConversationIdCommentsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostConversationsConversationIdCommentsWithResponse(arg0 context.Context, arg1 string, arg2 front.PostConversationsConversationIdCommentsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostConversationsConversationIdCommentsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostConversationsConversationIdCommentsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostConversationsConversationIdCommentsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostConversationsConversationIdCommentsWithResponse indicates an expected call of PostConversationsConversationIdCommentsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostConversationsConversationIdCommentsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostConversationsConversationIdCommentsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostConversationsConversationIdCommentsWithResponse), varargs...)
}

// PostConversationsConversationIdDraftsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostConversationsConversationIdDraftsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostConversationsConversationIdDraftsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostConversationsConversationIdDraftsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostConversationsConversationIdDraftsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostConversationsConversationIdDraftsWithBodyWithResponse indicates an expected call of PostConversationsConversationIdDraftsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostConversationsConversationIdDraftsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostConversationsConversationIdDraftsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostConversationsConversationIdDraftsWithBodyWithResponse), varargs...)
}

// PostConversationsConversationIdDraftsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostConversationsConversationIdDraftsWithResponse(arg0 context.Context, arg1 string, arg2 front.PostConversationsConversationIdDraftsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostConversationsConversationIdDraftsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostConversationsConversationIdDraftsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostConversationsConversationIdDraftsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostConversationsConversationIdDraftsWithResponse indicates an expected call of PostConversationsConversationIdDraftsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostConversationsConversationIdDraftsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostConversationsConversationIdDraftsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostConversationsConversationIdDraftsWithResponse), varargs...)
}

// PostConversationsConversationIdFollowersWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostConversationsConversationIdFollowersWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostConversationsConversationIdFollowersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostConversationsConversationIdFollowersWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostConversationsConversationIdFollowersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostConversationsConversationIdFollowersWithBodyWithResponse indicates an expected call of PostConversationsConversationIdFollowersWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostConversationsConversationIdFollowersWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostConversationsConversationIdFollowersWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostConversationsConversationIdFollowersWithBodyWithResponse), varargs...)
}

// PostConversationsConversationIdFollowersWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostConversationsConversationIdFollowersWithResponse(arg0 context.Context, arg1 string, arg2 front.PostConversationsConversationIdFollowersJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostConversationsConversationIdFollowersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostConversationsConversationIdFollowersWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostConversationsConversationIdFollowersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostConversationsConversationIdFollowersWithResponse indicates an expected call of PostConversationsConversationIdFollowersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostConversationsConversationIdFollowersWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostConversationsConversationIdFollowersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostConversationsConversationIdFollowersWithResponse), varargs...)
}

// PostConversationsConversationIdLinksWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostConversationsConversationIdLinksWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostConversationsConversationIdLinksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostConversationsConversationIdLinksWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostConversationsConversationIdLinksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostConversationsConversationIdLinksWithBodyWithResponse indicates an expected call of PostConversationsConversationIdLinksWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostConversationsConversationIdLinksWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostConversationsConversationIdLinksWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostConversationsConversationIdLinksWithBodyWithResponse), varargs...)
}

// PostConversationsConversationIdLinksWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostConversationsConversationIdLinksWithResponse(arg0 context.Context, arg1 string, arg2 front.PostConversationsConversationIdLinksJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostConversationsConversationIdLinksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostConversationsConversationIdLinksWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostConversationsConversationIdLinksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostConversationsConversationIdLinksWithResponse indicates an expected call of PostConversationsConversationIdLinksWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostConversationsConversationIdLinksWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostConversationsConversationIdLinksWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostConversationsConversationIdLinksWithResponse), varargs...)
}

// PostConversationsConversationIdMessagesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostConversationsConversationIdMessagesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostConversationsConversationIdMessagesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostConversationsConversationIdMessagesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostConversationsConversationIdMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostConversationsConversationIdMessagesWithBodyWithResponse indicates an expected call of PostConversationsConversationIdMessagesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostConversationsConversationIdMessagesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostConversationsConversationIdMessagesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostConversationsConversationIdMessagesWithBodyWithResponse), varargs...)
}

// PostConversationsConversationIdMessagesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostConversationsConversationIdMessagesWithResponse(arg0 context.Context, arg1 string, arg2 front.PostConversationsConversationIdMessagesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostConversationsConversationIdMessagesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostConversationsConversationIdMessagesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostConversationsConversationIdMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostConversationsConversationIdMessagesWithResponse indicates an expected call of PostConversationsConversationIdMessagesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostConversationsConversationIdMessagesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostConversationsConversationIdMessagesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostConversationsConversationIdMessagesWithResponse), varargs...)
}

// PostConversationsConversationIdTagsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostConversationsConversationIdTagsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostConversationsConversationIdTagsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostConversationsConversationIdTagsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostConversationsConversationIdTagsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostConversationsConversationIdTagsWithBodyWithResponse indicates an expected call of PostConversationsConversationIdTagsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostConversationsConversationIdTagsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostConversationsConversationIdTagsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostConversationsConversationIdTagsWithBodyWithResponse), varargs...)
}

// PostConversationsConversationIdTagsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostConversationsConversationIdTagsWithResponse(arg0 context.Context, arg1 string, arg2 front.PostConversationsConversationIdTagsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostConversationsConversationIdTagsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostConversationsConversationIdTagsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostConversationsConversationIdTagsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostConversationsConversationIdTagsWithResponse indicates an expected call of PostConversationsConversationIdTagsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostConversationsConversationIdTagsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostConversationsConversationIdTagsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostConversationsConversationIdTagsWithResponse), varargs...)
}

// PostInboxesInboxIdChannelsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostInboxesInboxIdChannelsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostInboxesInboxIdChannelsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostInboxesInboxIdChannelsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostInboxesInboxIdChannelsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostInboxesInboxIdChannelsWithBodyWithResponse indicates an expected call of PostInboxesInboxIdChannelsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostInboxesInboxIdChannelsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostInboxesInboxIdChannelsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostInboxesInboxIdChannelsWithBodyWithResponse), varargs...)
}

// PostInboxesInboxIdChannelsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostInboxesInboxIdChannelsWithResponse(arg0 context.Context, arg1 string, arg2 front.PostInboxesInboxIdChannelsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostInboxesInboxIdChannelsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostInboxesInboxIdChannelsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostInboxesInboxIdChannelsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostInboxesInboxIdChannelsWithResponse indicates an expected call of PostInboxesInboxIdChannelsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostInboxesInboxIdChannelsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostInboxesInboxIdChannelsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostInboxesInboxIdChannelsWithResponse), varargs...)
}

// PostInboxesInboxIdTeammatesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostInboxesInboxIdTeammatesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostInboxesInboxIdTeammatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostInboxesInboxIdTeammatesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostInboxesInboxIdTeammatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostInboxesInboxIdTeammatesWithBodyWithResponse indicates an expected call of PostInboxesInboxIdTeammatesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostInboxesInboxIdTeammatesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostInboxesInboxIdTeammatesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostInboxesInboxIdTeammatesWithBodyWithResponse), varargs...)
}

// PostInboxesInboxIdTeammatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostInboxesInboxIdTeammatesWithResponse(arg0 context.Context, arg1 string, arg2 front.PostInboxesInboxIdTeammatesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostInboxesInboxIdTeammatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostInboxesInboxIdTeammatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostInboxesInboxIdTeammatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostInboxesInboxIdTeammatesWithResponse indicates an expected call of PostInboxesInboxIdTeammatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostInboxesInboxIdTeammatesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostInboxesInboxIdTeammatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostInboxesInboxIdTeammatesWithResponse), varargs...)
}

// PostInboxesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostInboxesWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...front.RequestEditorFn) (*front.PostInboxesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostInboxesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostInboxesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostInboxesWithBodyWithResponse indicates an expected call of PostInboxesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostInboxesWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostInboxesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostInboxesWithBodyWithResponse), varargs...)
}

// PostInboxesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostInboxesWithResponse(arg0 context.Context, arg1 front.PostInboxesJSONRequestBody, arg2 ...front.RequestEditorFn) (*front.PostInboxesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostInboxesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostInboxesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostInboxesWithResponse indicates an expected call of PostInboxesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostInboxesWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostInboxesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostInboxesWithResponse), varargs...)
}

// PostLinksWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostLinksWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...front.RequestEditorFn) (*front.PostLinksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostLinksWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostLinksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostLinksWithBodyWithResponse indicates an expected call of PostLinksWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostLinksWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostLinksWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostLinksWithBodyWithResponse), varargs...)
}

// PostLinksWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostLinksWithResponse(arg0 context.Context, arg1 front.PostLinksJSONRequestBody, arg2 ...front.RequestEditorFn) (*front.PostLinksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostLinksWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostLinksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostLinksWithResponse indicates an expected call of PostLinksWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostLinksWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostLinksWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostLinksWithResponse), varargs...)
}

// PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithBodyWithResponse indicates an expected call of PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithBodyWithResponse), varargs...)
}

// PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse(arg0 context.Context, arg1 string, arg2 front.PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse indicates an expected call of PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplateFoldersWithResponse), varargs...)
}

// PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithBodyWithResponse indicates an expected call of PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithBodyWithResponse), varargs...)
}

// PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse(arg0 context.Context, arg1 string, arg2 front.PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse indicates an expected call of PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostMessageTemplateFoldersMessageTemplateFolderIdMessageTemplatesWithResponse), varargs...)
}

// PostMessageTemplateFoldersWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostMessageTemplateFoldersWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...front.RequestEditorFn) (*front.PostMessageTemplateFoldersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostMessageTemplateFoldersWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostMessageTemplateFoldersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostMessageTemplateFoldersWithBodyWithResponse indicates an expected call of PostMessageTemplateFoldersWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostMessageTemplateFoldersWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMessageTemplateFoldersWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostMessageTemplateFoldersWithBodyWithResponse), varargs...)
}

// PostMessageTemplateFoldersWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostMessageTemplateFoldersWithResponse(arg0 context.Context, arg1 front.PostMessageTemplateFoldersJSONRequestBody, arg2 ...front.RequestEditorFn) (*front.PostMessageTemplateFoldersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostMessageTemplateFoldersWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostMessageTemplateFoldersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostMessageTemplateFoldersWithResponse indicates an expected call of PostMessageTemplateFoldersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostMessageTemplateFoldersWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMessageTemplateFoldersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostMessageTemplateFoldersWithResponse), varargs...)
}

// PostMessageTemplatesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostMessageTemplatesWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...front.RequestEditorFn) (*front.PostMessageTemplatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostMessageTemplatesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostMessageTemplatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostMessageTemplatesWithBodyWithResponse indicates an expected call of PostMessageTemplatesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostMessageTemplatesWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMessageTemplatesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostMessageTemplatesWithBodyWithResponse), varargs...)
}

// PostMessageTemplatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostMessageTemplatesWithResponse(arg0 context.Context, arg1 front.PostMessageTemplatesJSONRequestBody, arg2 ...front.RequestEditorFn) (*front.PostMessageTemplatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostMessageTemplatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostMessageTemplatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostMessageTemplatesWithResponse indicates an expected call of PostMessageTemplatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostMessageTemplatesWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostMessageTemplatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostMessageTemplatesWithResponse), varargs...)
}

// PostShiftShiftIdTeammatesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostShiftShiftIdTeammatesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostShiftShiftIdTeammatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostShiftShiftIdTeammatesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostShiftShiftIdTeammatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostShiftShiftIdTeammatesWithBodyWithResponse indicates an expected call of PostShiftShiftIdTeammatesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostShiftShiftIdTeammatesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostShiftShiftIdTeammatesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostShiftShiftIdTeammatesWithBodyWithResponse), varargs...)
}

// PostShiftShiftIdTeammatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostShiftShiftIdTeammatesWithResponse(arg0 context.Context, arg1 string, arg2 front.PostShiftShiftIdTeammatesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostShiftShiftIdTeammatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostShiftShiftIdTeammatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostShiftShiftIdTeammatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostShiftShiftIdTeammatesWithResponse indicates an expected call of PostShiftShiftIdTeammatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostShiftShiftIdTeammatesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostShiftShiftIdTeammatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostShiftShiftIdTeammatesWithResponse), varargs...)
}

// PostShiftsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostShiftsWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...front.RequestEditorFn) (*front.PostShiftsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostShiftsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostShiftsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostShiftsWithBodyWithResponse indicates an expected call of PostShiftsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostShiftsWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostShiftsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostShiftsWithBodyWithResponse), varargs...)
}

// PostShiftsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostShiftsWithResponse(arg0 context.Context, arg1 front.PostShiftsJSONRequestBody, arg2 ...front.RequestEditorFn) (*front.PostShiftsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostShiftsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostShiftsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostShiftsWithResponse indicates an expected call of PostShiftsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostShiftsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostShiftsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostShiftsWithResponse), varargs...)
}

// PostTagsTagIdChildrenWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTagsTagIdChildrenWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostTagsTagIdChildrenResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTagsTagIdChildrenWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTagsTagIdChildrenResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTagsTagIdChildrenWithBodyWithResponse indicates an expected call of PostTagsTagIdChildrenWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTagsTagIdChildrenWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTagsTagIdChildrenWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTagsTagIdChildrenWithBodyWithResponse), varargs...)
}

// PostTagsTagIdChildrenWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTagsTagIdChildrenWithResponse(arg0 context.Context, arg1 string, arg2 front.PostTagsTagIdChildrenJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostTagsTagIdChildrenResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTagsTagIdChildrenWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTagsTagIdChildrenResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTagsTagIdChildrenWithResponse indicates an expected call of PostTagsTagIdChildrenWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTagsTagIdChildrenWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTagsTagIdChildrenWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTagsTagIdChildrenWithResponse), varargs...)
}

// PostTagsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTagsWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...front.RequestEditorFn) (*front.PostTagsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTagsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTagsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTagsWithBodyWithResponse indicates an expected call of PostTagsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTagsWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTagsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTagsWithBodyWithResponse), varargs...)
}

// PostTagsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTagsWithResponse(arg0 context.Context, arg1 front.PostTagsJSONRequestBody, arg2 ...front.RequestEditorFn) (*front.PostTagsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTagsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTagsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTagsWithResponse indicates an expected call of PostTagsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTagsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTagsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTagsWithResponse), varargs...)
}

// PostTeammatesTeammateIdContactGroupsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeammatesTeammateIdContactGroupsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostTeammatesTeammateIdContactGroupsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeammatesTeammateIdContactGroupsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeammatesTeammateIdContactGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeammatesTeammateIdContactGroupsWithBodyWithResponse indicates an expected call of PostTeammatesTeammateIdContactGroupsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeammatesTeammateIdContactGroupsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeammatesTeammateIdContactGroupsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeammatesTeammateIdContactGroupsWithBodyWithResponse), varargs...)
}

// PostTeammatesTeammateIdContactGroupsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeammatesTeammateIdContactGroupsWithResponse(arg0 context.Context, arg1 string, arg2 front.PostTeammatesTeammateIdContactGroupsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostTeammatesTeammateIdContactGroupsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeammatesTeammateIdContactGroupsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeammatesTeammateIdContactGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeammatesTeammateIdContactGroupsWithResponse indicates an expected call of PostTeammatesTeammateIdContactGroupsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeammatesTeammateIdContactGroupsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeammatesTeammateIdContactGroupsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeammatesTeammateIdContactGroupsWithResponse), varargs...)
}

// PostTeammatesTeammateIdContactsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeammatesTeammateIdContactsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostTeammatesTeammateIdContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeammatesTeammateIdContactsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeammatesTeammateIdContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeammatesTeammateIdContactsWithBodyWithResponse indicates an expected call of PostTeammatesTeammateIdContactsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeammatesTeammateIdContactsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeammatesTeammateIdContactsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeammatesTeammateIdContactsWithBodyWithResponse), varargs...)
}

// PostTeammatesTeammateIdContactsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeammatesTeammateIdContactsWithResponse(arg0 context.Context, arg1 string, arg2 front.PostTeammatesTeammateIdContactsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostTeammatesTeammateIdContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeammatesTeammateIdContactsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeammatesTeammateIdContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeammatesTeammateIdContactsWithResponse indicates an expected call of PostTeammatesTeammateIdContactsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeammatesTeammateIdContactsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeammatesTeammateIdContactsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeammatesTeammateIdContactsWithResponse), varargs...)
}

// PostTeammatesTeammateIdMessageTemplateFoldersWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeammatesTeammateIdMessageTemplateFoldersWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostTeammatesTeammateIdMessageTemplateFoldersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeammatesTeammateIdMessageTemplateFoldersWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeammatesTeammateIdMessageTemplateFoldersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeammatesTeammateIdMessageTemplateFoldersWithBodyWithResponse indicates an expected call of PostTeammatesTeammateIdMessageTemplateFoldersWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeammatesTeammateIdMessageTemplateFoldersWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeammatesTeammateIdMessageTemplateFoldersWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeammatesTeammateIdMessageTemplateFoldersWithBodyWithResponse), varargs...)
}

// PostTeammatesTeammateIdMessageTemplateFoldersWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeammatesTeammateIdMessageTemplateFoldersWithResponse(arg0 context.Context, arg1 string, arg2 front.PostTeammatesTeammateIdMessageTemplateFoldersJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostTeammatesTeammateIdMessageTemplateFoldersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeammatesTeammateIdMessageTemplateFoldersWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeammatesTeammateIdMessageTemplateFoldersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeammatesTeammateIdMessageTemplateFoldersWithResponse indicates an expected call of PostTeammatesTeammateIdMessageTemplateFoldersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeammatesTeammateIdMessageTemplateFoldersWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeammatesTeammateIdMessageTemplateFoldersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeammatesTeammateIdMessageTemplateFoldersWithResponse), varargs...)
}

// PostTeammatesTeammateIdMessageTemplatesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeammatesTeammateIdMessageTemplatesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostTeammatesTeammateIdMessageTemplatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeammatesTeammateIdMessageTemplatesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeammatesTeammateIdMessageTemplatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeammatesTeammateIdMessageTemplatesWithBodyWithResponse indicates an expected call of PostTeammatesTeammateIdMessageTemplatesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeammatesTeammateIdMessageTemplatesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeammatesTeammateIdMessageTemplatesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeammatesTeammateIdMessageTemplatesWithBodyWithResponse), varargs...)
}

// PostTeammatesTeammateIdMessageTemplatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeammatesTeammateIdMessageTemplatesWithResponse(arg0 context.Context, arg1 string, arg2 front.PostTeammatesTeammateIdMessageTemplatesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostTeammatesTeammateIdMessageTemplatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeammatesTeammateIdMessageTemplatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeammatesTeammateIdMessageTemplatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeammatesTeammateIdMessageTemplatesWithResponse indicates an expected call of PostTeammatesTeammateIdMessageTemplatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeammatesTeammateIdMessageTemplatesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeammatesTeammateIdMessageTemplatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeammatesTeammateIdMessageTemplatesWithResponse), varargs...)
}

// PostTeammatesTeammateIdTagsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeammatesTeammateIdTagsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostTeammatesTeammateIdTagsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeammatesTeammateIdTagsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeammatesTeammateIdTagsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeammatesTeammateIdTagsWithBodyWithResponse indicates an expected call of PostTeammatesTeammateIdTagsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeammatesTeammateIdTagsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeammatesTeammateIdTagsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeammatesTeammateIdTagsWithBodyWithResponse), varargs...)
}

// PostTeammatesTeammateIdTagsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeammatesTeammateIdTagsWithResponse(arg0 context.Context, arg1 string, arg2 front.PostTeammatesTeammateIdTagsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostTeammatesTeammateIdTagsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeammatesTeammateIdTagsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeammatesTeammateIdTagsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeammatesTeammateIdTagsWithResponse indicates an expected call of PostTeammatesTeammateIdTagsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeammatesTeammateIdTagsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeammatesTeammateIdTagsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeammatesTeammateIdTagsWithResponse), varargs...)
}

// PostTeamsTeamIdContactGroupsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdContactGroupsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostTeamsTeamIdContactGroupsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdContactGroupsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdContactGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdContactGroupsWithBodyWithResponse indicates an expected call of PostTeamsTeamIdContactGroupsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdContactGroupsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdContactGroupsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdContactGroupsWithBodyWithResponse), varargs...)
}

// PostTeamsTeamIdContactGroupsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdContactGroupsWithResponse(arg0 context.Context, arg1 string, arg2 front.PostTeamsTeamIdContactGroupsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostTeamsTeamIdContactGroupsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdContactGroupsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdContactGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdContactGroupsWithResponse indicates an expected call of PostTeamsTeamIdContactGroupsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdContactGroupsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdContactGroupsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdContactGroupsWithResponse), varargs...)
}

// PostTeamsTeamIdContactsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdContactsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostTeamsTeamIdContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdContactsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdContactsWithBodyWithResponse indicates an expected call of PostTeamsTeamIdContactsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdContactsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdContactsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdContactsWithBodyWithResponse), varargs...)
}

// PostTeamsTeamIdContactsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdContactsWithResponse(arg0 context.Context, arg1 string, arg2 front.PostTeamsTeamIdContactsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostTeamsTeamIdContactsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdContactsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdContactsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdContactsWithResponse indicates an expected call of PostTeamsTeamIdContactsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdContactsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdContactsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdContactsWithResponse), varargs...)
}

// PostTeamsTeamIdExportsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdExportsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostTeamsTeamIdExportsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdExportsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdExportsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdExportsWithBodyWithResponse indicates an expected call of PostTeamsTeamIdExportsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdExportsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdExportsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdExportsWithBodyWithResponse), varargs...)
}

// PostTeamsTeamIdExportsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdExportsWithResponse(arg0 context.Context, arg1 string, arg2 front.PostTeamsTeamIdExportsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostTeamsTeamIdExportsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdExportsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdExportsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdExportsWithResponse indicates an expected call of PostTeamsTeamIdExportsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdExportsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdExportsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdExportsWithResponse), varargs...)
}

// PostTeamsTeamIdInboxesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdInboxesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostTeamsTeamIdInboxesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdInboxesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdInboxesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdInboxesWithBodyWithResponse indicates an expected call of PostTeamsTeamIdInboxesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdInboxesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdInboxesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdInboxesWithBodyWithResponse), varargs...)
}

// PostTeamsTeamIdInboxesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdInboxesWithResponse(arg0 context.Context, arg1 string, arg2 front.PostTeamsTeamIdInboxesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostTeamsTeamIdInboxesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdInboxesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdInboxesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdInboxesWithResponse indicates an expected call of PostTeamsTeamIdInboxesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdInboxesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdInboxesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdInboxesWithResponse), varargs...)
}

// PostTeamsTeamIdMessageTemplateFoldersWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdMessageTemplateFoldersWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostTeamsTeamIdMessageTemplateFoldersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdMessageTemplateFoldersWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdMessageTemplateFoldersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdMessageTemplateFoldersWithBodyWithResponse indicates an expected call of PostTeamsTeamIdMessageTemplateFoldersWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdMessageTemplateFoldersWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdMessageTemplateFoldersWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdMessageTemplateFoldersWithBodyWithResponse), varargs...)
}

// PostTeamsTeamIdMessageTemplateFoldersWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdMessageTemplateFoldersWithResponse(arg0 context.Context, arg1 string, arg2 front.PostTeamsTeamIdMessageTemplateFoldersJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostTeamsTeamIdMessageTemplateFoldersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdMessageTemplateFoldersWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdMessageTemplateFoldersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdMessageTemplateFoldersWithResponse indicates an expected call of PostTeamsTeamIdMessageTemplateFoldersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdMessageTemplateFoldersWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdMessageTemplateFoldersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdMessageTemplateFoldersWithResponse), varargs...)
}

// PostTeamsTeamIdMessageTemplatesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdMessageTemplatesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostTeamsTeamIdMessageTemplatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdMessageTemplatesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdMessageTemplatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdMessageTemplatesWithBodyWithResponse indicates an expected call of PostTeamsTeamIdMessageTemplatesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdMessageTemplatesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdMessageTemplatesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdMessageTemplatesWithBodyWithResponse), varargs...)
}

// PostTeamsTeamIdMessageTemplatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdMessageTemplatesWithResponse(arg0 context.Context, arg1 string, arg2 front.PostTeamsTeamIdMessageTemplatesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostTeamsTeamIdMessageTemplatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdMessageTemplatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdMessageTemplatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdMessageTemplatesWithResponse indicates an expected call of PostTeamsTeamIdMessageTemplatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdMessageTemplatesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdMessageTemplatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdMessageTemplatesWithResponse), varargs...)
}

// PostTeamsTeamIdShiftsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdShiftsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostTeamsTeamIdShiftsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdShiftsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdShiftsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdShiftsWithBodyWithResponse indicates an expected call of PostTeamsTeamIdShiftsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdShiftsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdShiftsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdShiftsWithBodyWithResponse), varargs...)
}

// PostTeamsTeamIdShiftsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdShiftsWithResponse(arg0 context.Context, arg1 string, arg2 front.PostTeamsTeamIdShiftsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostTeamsTeamIdShiftsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdShiftsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdShiftsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdShiftsWithResponse indicates an expected call of PostTeamsTeamIdShiftsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdShiftsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdShiftsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdShiftsWithResponse), varargs...)
}

// PostTeamsTeamIdTagsWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdTagsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostTeamsTeamIdTagsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdTagsWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdTagsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdTagsWithBodyWithResponse indicates an expected call of PostTeamsTeamIdTagsWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdTagsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdTagsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdTagsWithBodyWithResponse), varargs...)
}

// PostTeamsTeamIdTagsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdTagsWithResponse(arg0 context.Context, arg1 string, arg2 front.PostTeamsTeamIdTagsJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostTeamsTeamIdTagsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdTagsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdTagsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdTagsWithResponse indicates an expected call of PostTeamsTeamIdTagsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdTagsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdTagsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdTagsWithResponse), varargs...)
}

// PostTeamsTeamIdTeammatesWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdTeammatesWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PostTeamsTeamIdTeammatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdTeammatesWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdTeammatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdTeammatesWithBodyWithResponse indicates an expected call of PostTeamsTeamIdTeammatesWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdTeammatesWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdTeammatesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdTeammatesWithBodyWithResponse), varargs...)
}

// PostTeamsTeamIdTeammatesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PostTeamsTeamIdTeammatesWithResponse(arg0 context.Context, arg1 string, arg2 front.PostTeamsTeamIdTeammatesJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PostTeamsTeamIdTeammatesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostTeamsTeamIdTeammatesWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PostTeamsTeamIdTeammatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostTeamsTeamIdTeammatesWithResponse indicates an expected call of PostTeamsTeamIdTeammatesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTeamsTeamIdTeammatesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTeamsTeamIdTeammatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTeamsTeamIdTeammatesWithResponse), varargs...)
}

// PutConversationsConversationIdAssigneeWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PutConversationsConversationIdAssigneeWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...front.RequestEditorFn) (*front.PutConversationsConversationIdAssigneeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutConversationsConversationIdAssigneeWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PutConversationsConversationIdAssigneeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutConversationsConversationIdAssigneeWithBodyWithResponse indicates an expected call of PutConversationsConversationIdAssigneeWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PutConversationsConversationIdAssigneeWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutConversationsConversationIdAssigneeWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PutConversationsConversationIdAssigneeWithBodyWithResponse), varargs...)
}

// PutConversationsConversationIdAssigneeWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) PutConversationsConversationIdAssigneeWithResponse(arg0 context.Context, arg1 string, arg2 front.PutConversationsConversationIdAssigneeJSONRequestBody, arg3 ...front.RequestEditorFn) (*front.PutConversationsConversationIdAssigneeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutConversationsConversationIdAssigneeWithResponse", varargs...)
	ret0, _ := ret[0].(*front.PutConversationsConversationIdAssigneeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutConversationsConversationIdAssigneeWithResponse indicates an expected call of PutConversationsConversationIdAssigneeWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) PutConversationsConversationIdAssigneeWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutConversationsConversationIdAssigneeWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PutConversationsConversationIdAssigneeWithResponse), varargs...)
}

// SearchConversationsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) SearchConversationsWithResponse(arg0 context.Context, arg1 string, arg2 *front.SearchConversationsParams, arg3 ...front.RequestEditorFn) (*front.SearchConversationsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchConversationsWithResponse", varargs...)
	ret0, _ := ret[0].(*front.SearchConversationsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchConversationsWithResponse indicates an expected call of SearchConversationsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) SearchConversationsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchConversationsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).SearchConversationsWithResponse), varargs...)
}