// Code generated by MockGen. DO NOT EDIT. // Source: github.com/zitadel/zitadel/internal/notification/handlers (interfaces: Commands) // // Generated by this command: // // mockgen -typed -package mock -destination ./mock/commands.mock.go . Commands // // Package mock is a generated GoMock package. package mock import ( context "context" reflect "reflect" senders "github.com/zitadel/zitadel/internal/notification/senders" milestone "github.com/zitadel/zitadel/internal/repository/milestone" quota "github.com/zitadel/zitadel/internal/repository/quota" gomock "go.uber.org/mock/gomock" ) // MockCommands is a mock of Commands interface. type MockCommands struct { ctrl *gomock.Controller recorder *MockCommandsMockRecorder isgomock struct{} } // MockCommandsMockRecorder is the mock recorder for MockCommands. type MockCommandsMockRecorder struct { mock *MockCommands } // NewMockCommands creates a new mock instance. func NewMockCommands(ctrl *gomock.Controller) *MockCommands { mock := &MockCommands{ctrl: ctrl} mock.recorder = &MockCommandsMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. func (m *MockCommands) EXPECT() *MockCommandsMockRecorder { return m.recorder } // BackChannelLogoutSent mocks base method. func (m *MockCommands) BackChannelLogoutSent(arg0 context.Context, arg1, arg2, arg3 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "BackChannelLogoutSent", arg0, arg1, arg2, arg3) ret0, _ := ret[0].(error) return ret0 } // BackChannelLogoutSent indicates an expected call of BackChannelLogoutSent. func (mr *MockCommandsMockRecorder) BackChannelLogoutSent(arg0, arg1, arg2, arg3 any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BackChannelLogoutSent", reflect.TypeOf((*MockCommands)(nil).BackChannelLogoutSent), arg0, arg1, arg2, arg3) } // HumanEmailVerificationCodeSent mocks base method. func (m *MockCommands) HumanEmailVerificationCodeSent(ctx context.Context, orgID, userID string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "HumanEmailVerificationCodeSent", ctx, orgID, userID) ret0, _ := ret[0].(error) return ret0 } // HumanEmailVerificationCodeSent indicates an expected call of HumanEmailVerificationCodeSent. func (mr *MockCommandsMockRecorder) HumanEmailVerificationCodeSent(ctx, orgID, userID any) *MockCommandsHumanEmailVerificationCodeSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanEmailVerificationCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanEmailVerificationCodeSent), ctx, orgID, userID) return &MockCommandsHumanEmailVerificationCodeSentCall{Call: call} } // MockCommandsHumanEmailVerificationCodeSentCall wrap *gomock.Call type MockCommandsHumanEmailVerificationCodeSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockCommandsHumanEmailVerificationCodeSentCall) Return(arg0 error) *MockCommandsHumanEmailVerificationCodeSentCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockCommandsHumanEmailVerificationCodeSentCall) Do(f func(context.Context, string, string) error) *MockCommandsHumanEmailVerificationCodeSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockCommandsHumanEmailVerificationCodeSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsHumanEmailVerificationCodeSentCall { c.Call = c.Call.DoAndReturn(f) return c } // HumanInitCodeSent mocks base method. func (m *MockCommands) HumanInitCodeSent(ctx context.Context, orgID, userID string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "HumanInitCodeSent", ctx, orgID, userID) ret0, _ := ret[0].(error) return ret0 } // HumanInitCodeSent indicates an expected call of HumanInitCodeSent. func (mr *MockCommandsMockRecorder) HumanInitCodeSent(ctx, orgID, userID any) *MockCommandsHumanInitCodeSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanInitCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanInitCodeSent), ctx, orgID, userID) return &MockCommandsHumanInitCodeSentCall{Call: call} } // MockCommandsHumanInitCodeSentCall wrap *gomock.Call type MockCommandsHumanInitCodeSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockCommandsHumanInitCodeSentCall) Return(arg0 error) *MockCommandsHumanInitCodeSentCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockCommandsHumanInitCodeSentCall) Do(f func(context.Context, string, string) error) *MockCommandsHumanInitCodeSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockCommandsHumanInitCodeSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsHumanInitCodeSentCall { c.Call = c.Call.DoAndReturn(f) return c } // HumanOTPEmailCodeSent mocks base method. func (m *MockCommands) HumanOTPEmailCodeSent(ctx context.Context, userID, resourceOwner string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "HumanOTPEmailCodeSent", ctx, userID, resourceOwner) ret0, _ := ret[0].(error) return ret0 } // HumanOTPEmailCodeSent indicates an expected call of HumanOTPEmailCodeSent. func (mr *MockCommandsMockRecorder) HumanOTPEmailCodeSent(ctx, userID, resourceOwner any) *MockCommandsHumanOTPEmailCodeSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanOTPEmailCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanOTPEmailCodeSent), ctx, userID, resourceOwner) return &MockCommandsHumanOTPEmailCodeSentCall{Call: call} } // MockCommandsHumanOTPEmailCodeSentCall wrap *gomock.Call type MockCommandsHumanOTPEmailCodeSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockCommandsHumanOTPEmailCodeSentCall) Return(arg0 error) *MockCommandsHumanOTPEmailCodeSentCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockCommandsHumanOTPEmailCodeSentCall) Do(f func(context.Context, string, string) error) *MockCommandsHumanOTPEmailCodeSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockCommandsHumanOTPEmailCodeSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsHumanOTPEmailCodeSentCall { c.Call = c.Call.DoAndReturn(f) return c } // HumanOTPSMSCodeSent mocks base method. func (m *MockCommands) HumanOTPSMSCodeSent(ctx context.Context, userID, resourceOwner string, generatorInfo *senders.CodeGeneratorInfo) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "HumanOTPSMSCodeSent", ctx, userID, resourceOwner, generatorInfo) ret0, _ := ret[0].(error) return ret0 } // HumanOTPSMSCodeSent indicates an expected call of HumanOTPSMSCodeSent. func (mr *MockCommandsMockRecorder) HumanOTPSMSCodeSent(ctx, userID, resourceOwner, generatorInfo any) *MockCommandsHumanOTPSMSCodeSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanOTPSMSCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanOTPSMSCodeSent), ctx, userID, resourceOwner, generatorInfo) return &MockCommandsHumanOTPSMSCodeSentCall{Call: call} } // MockCommandsHumanOTPSMSCodeSentCall wrap *gomock.Call type MockCommandsHumanOTPSMSCodeSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockCommandsHumanOTPSMSCodeSentCall) Return(arg0 error) *MockCommandsHumanOTPSMSCodeSentCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockCommandsHumanOTPSMSCodeSentCall) Do(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsHumanOTPSMSCodeSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockCommandsHumanOTPSMSCodeSentCall) DoAndReturn(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsHumanOTPSMSCodeSentCall { c.Call = c.Call.DoAndReturn(f) return c } // HumanPasswordlessInitCodeSent mocks base method. func (m *MockCommands) HumanPasswordlessInitCodeSent(ctx context.Context, userID, resourceOwner, codeID string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "HumanPasswordlessInitCodeSent", ctx, userID, resourceOwner, codeID) ret0, _ := ret[0].(error) return ret0 } // HumanPasswordlessInitCodeSent indicates an expected call of HumanPasswordlessInitCodeSent. func (mr *MockCommandsMockRecorder) HumanPasswordlessInitCodeSent(ctx, userID, resourceOwner, codeID any) *MockCommandsHumanPasswordlessInitCodeSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanPasswordlessInitCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanPasswordlessInitCodeSent), ctx, userID, resourceOwner, codeID) return &MockCommandsHumanPasswordlessInitCodeSentCall{Call: call} } // MockCommandsHumanPasswordlessInitCodeSentCall wrap *gomock.Call type MockCommandsHumanPasswordlessInitCodeSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockCommandsHumanPasswordlessInitCodeSentCall) Return(arg0 error) *MockCommandsHumanPasswordlessInitCodeSentCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockCommandsHumanPasswordlessInitCodeSentCall) Do(f func(context.Context, string, string, string) error) *MockCommandsHumanPasswordlessInitCodeSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockCommandsHumanPasswordlessInitCodeSentCall) DoAndReturn(f func(context.Context, string, string, string) error) *MockCommandsHumanPasswordlessInitCodeSentCall { c.Call = c.Call.DoAndReturn(f) return c } // HumanPhoneVerificationCodeSent mocks base method. func (m *MockCommands) HumanPhoneVerificationCodeSent(ctx context.Context, orgID, userID string, generatorInfo *senders.CodeGeneratorInfo) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "HumanPhoneVerificationCodeSent", ctx, orgID, userID, generatorInfo) ret0, _ := ret[0].(error) return ret0 } // HumanPhoneVerificationCodeSent indicates an expected call of HumanPhoneVerificationCodeSent. func (mr *MockCommandsMockRecorder) HumanPhoneVerificationCodeSent(ctx, orgID, userID, generatorInfo any) *MockCommandsHumanPhoneVerificationCodeSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanPhoneVerificationCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanPhoneVerificationCodeSent), ctx, orgID, userID, generatorInfo) return &MockCommandsHumanPhoneVerificationCodeSentCall{Call: call} } // MockCommandsHumanPhoneVerificationCodeSentCall wrap *gomock.Call type MockCommandsHumanPhoneVerificationCodeSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockCommandsHumanPhoneVerificationCodeSentCall) Return(arg0 error) *MockCommandsHumanPhoneVerificationCodeSentCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockCommandsHumanPhoneVerificationCodeSentCall) Do(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsHumanPhoneVerificationCodeSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockCommandsHumanPhoneVerificationCodeSentCall) DoAndReturn(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsHumanPhoneVerificationCodeSentCall { c.Call = c.Call.DoAndReturn(f) return c } // InviteCodeSent mocks base method. func (m *MockCommands) InviteCodeSent(ctx context.Context, orgID, userID string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "InviteCodeSent", ctx, orgID, userID) ret0, _ := ret[0].(error) return ret0 } // InviteCodeSent indicates an expected call of InviteCodeSent. func (mr *MockCommandsMockRecorder) InviteCodeSent(ctx, orgID, userID any) *MockCommandsInviteCodeSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InviteCodeSent", reflect.TypeOf((*MockCommands)(nil).InviteCodeSent), ctx, orgID, userID) return &MockCommandsInviteCodeSentCall{Call: call} } // MockCommandsInviteCodeSentCall wrap *gomock.Call type MockCommandsInviteCodeSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockCommandsInviteCodeSentCall) Return(arg0 error) *MockCommandsInviteCodeSentCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockCommandsInviteCodeSentCall) Do(f func(context.Context, string, string) error) *MockCommandsInviteCodeSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockCommandsInviteCodeSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsInviteCodeSentCall { c.Call = c.Call.DoAndReturn(f) return c } // MilestonePushed mocks base method. func (m *MockCommands) MilestonePushed(ctx context.Context, instanceID string, msType milestone.Type, endpoints []string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "MilestonePushed", ctx, instanceID, msType, endpoints) ret0, _ := ret[0].(error) return ret0 } // MilestonePushed indicates an expected call of MilestonePushed. func (mr *MockCommandsMockRecorder) MilestonePushed(ctx, instanceID, msType, endpoints any) *MockCommandsMilestonePushedCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MilestonePushed", reflect.TypeOf((*MockCommands)(nil).MilestonePushed), ctx, instanceID, msType, endpoints) return &MockCommandsMilestonePushedCall{Call: call} } // MockCommandsMilestonePushedCall wrap *gomock.Call type MockCommandsMilestonePushedCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockCommandsMilestonePushedCall) Return(arg0 error) *MockCommandsMilestonePushedCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockCommandsMilestonePushedCall) Do(f func(context.Context, string, milestone.Type, []string) error) *MockCommandsMilestonePushedCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockCommandsMilestonePushedCall) DoAndReturn(f func(context.Context, string, milestone.Type, []string) error) *MockCommandsMilestonePushedCall { c.Call = c.Call.DoAndReturn(f) return c } // OTPEmailSent mocks base method. func (m *MockCommands) OTPEmailSent(ctx context.Context, sessionID, resourceOwner string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "OTPEmailSent", ctx, sessionID, resourceOwner) ret0, _ := ret[0].(error) return ret0 } // OTPEmailSent indicates an expected call of OTPEmailSent. func (mr *MockCommandsMockRecorder) OTPEmailSent(ctx, sessionID, resourceOwner any) *MockCommandsOTPEmailSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OTPEmailSent", reflect.TypeOf((*MockCommands)(nil).OTPEmailSent), ctx, sessionID, resourceOwner) return &MockCommandsOTPEmailSentCall{Call: call} } // MockCommandsOTPEmailSentCall wrap *gomock.Call type MockCommandsOTPEmailSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockCommandsOTPEmailSentCall) Return(arg0 error) *MockCommandsOTPEmailSentCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockCommandsOTPEmailSentCall) Do(f func(context.Context, string, string) error) *MockCommandsOTPEmailSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockCommandsOTPEmailSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsOTPEmailSentCall { c.Call = c.Call.DoAndReturn(f) return c } // OTPSMSSent mocks base method. func (m *MockCommands) OTPSMSSent(ctx context.Context, sessionID, resourceOwner string, generatorInfo *senders.CodeGeneratorInfo) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "OTPSMSSent", ctx, sessionID, resourceOwner, generatorInfo) ret0, _ := ret[0].(error) return ret0 } // OTPSMSSent indicates an expected call of OTPSMSSent. func (mr *MockCommandsMockRecorder) OTPSMSSent(ctx, sessionID, resourceOwner, generatorInfo any) *MockCommandsOTPSMSSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OTPSMSSent", reflect.TypeOf((*MockCommands)(nil).OTPSMSSent), ctx, sessionID, resourceOwner, generatorInfo) return &MockCommandsOTPSMSSentCall{Call: call} } // MockCommandsOTPSMSSentCall wrap *gomock.Call type MockCommandsOTPSMSSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockCommandsOTPSMSSentCall) Return(arg0 error) *MockCommandsOTPSMSSentCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockCommandsOTPSMSSentCall) Do(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsOTPSMSSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockCommandsOTPSMSSentCall) DoAndReturn(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsOTPSMSSentCall { c.Call = c.Call.DoAndReturn(f) return c } // PasswordChangeSent mocks base method. func (m *MockCommands) PasswordChangeSent(ctx context.Context, orgID, userID string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PasswordChangeSent", ctx, orgID, userID) ret0, _ := ret[0].(error) return ret0 } // PasswordChangeSent indicates an expected call of PasswordChangeSent. func (mr *MockCommandsMockRecorder) PasswordChangeSent(ctx, orgID, userID any) *MockCommandsPasswordChangeSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PasswordChangeSent", reflect.TypeOf((*MockCommands)(nil).PasswordChangeSent), ctx, orgID, userID) return &MockCommandsPasswordChangeSentCall{Call: call} } // MockCommandsPasswordChangeSentCall wrap *gomock.Call type MockCommandsPasswordChangeSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockCommandsPasswordChangeSentCall) Return(arg0 error) *MockCommandsPasswordChangeSentCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockCommandsPasswordChangeSentCall) Do(f func(context.Context, string, string) error) *MockCommandsPasswordChangeSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockCommandsPasswordChangeSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsPasswordChangeSentCall { c.Call = c.Call.DoAndReturn(f) return c } // PasswordCodeSent mocks base method. func (m *MockCommands) PasswordCodeSent(ctx context.Context, orgID, userID string, generatorInfo *senders.CodeGeneratorInfo) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PasswordCodeSent", ctx, orgID, userID, generatorInfo) ret0, _ := ret[0].(error) return ret0 } // PasswordCodeSent indicates an expected call of PasswordCodeSent. func (mr *MockCommandsMockRecorder) PasswordCodeSent(ctx, orgID, userID, generatorInfo any) *MockCommandsPasswordCodeSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PasswordCodeSent", reflect.TypeOf((*MockCommands)(nil).PasswordCodeSent), ctx, orgID, userID, generatorInfo) return &MockCommandsPasswordCodeSentCall{Call: call} } // MockCommandsPasswordCodeSentCall wrap *gomock.Call type MockCommandsPasswordCodeSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockCommandsPasswordCodeSentCall) Return(arg0 error) *MockCommandsPasswordCodeSentCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockCommandsPasswordCodeSentCall) Do(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsPasswordCodeSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockCommandsPasswordCodeSentCall) DoAndReturn(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsPasswordCodeSentCall { c.Call = c.Call.DoAndReturn(f) return c } // UsageNotificationSent mocks base method. func (m *MockCommands) UsageNotificationSent(ctx context.Context, dueEvent *quota.NotificationDueEvent) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UsageNotificationSent", ctx, dueEvent) ret0, _ := ret[0].(error) return ret0 } // UsageNotificationSent indicates an expected call of UsageNotificationSent. func (mr *MockCommandsMockRecorder) UsageNotificationSent(ctx, dueEvent any) *MockCommandsUsageNotificationSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UsageNotificationSent", reflect.TypeOf((*MockCommands)(nil).UsageNotificationSent), ctx, dueEvent) return &MockCommandsUsageNotificationSentCall{Call: call} } // MockCommandsUsageNotificationSentCall wrap *gomock.Call type MockCommandsUsageNotificationSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockCommandsUsageNotificationSentCall) Return(arg0 error) *MockCommandsUsageNotificationSentCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockCommandsUsageNotificationSentCall) Do(f func(context.Context, *quota.NotificationDueEvent) error) *MockCommandsUsageNotificationSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockCommandsUsageNotificationSentCall) DoAndReturn(f func(context.Context, *quota.NotificationDueEvent) error) *MockCommandsUsageNotificationSentCall { c.Call = c.Call.DoAndReturn(f) return c } // UserDomainClaimedSent mocks base method. func (m *MockCommands) UserDomainClaimedSent(ctx context.Context, orgID, userID string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UserDomainClaimedSent", ctx, orgID, userID) ret0, _ := ret[0].(error) return ret0 } // UserDomainClaimedSent indicates an expected call of UserDomainClaimedSent. func (mr *MockCommandsMockRecorder) UserDomainClaimedSent(ctx, orgID, userID any) *MockCommandsUserDomainClaimedSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserDomainClaimedSent", reflect.TypeOf((*MockCommands)(nil).UserDomainClaimedSent), ctx, orgID, userID) return &MockCommandsUserDomainClaimedSentCall{Call: call} } // MockCommandsUserDomainClaimedSentCall wrap *gomock.Call type MockCommandsUserDomainClaimedSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return func (c *MockCommandsUserDomainClaimedSentCall) Return(arg0 error) *MockCommandsUserDomainClaimedSentCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do func (c *MockCommandsUserDomainClaimedSentCall) Do(f func(context.Context, string, string) error) *MockCommandsUserDomainClaimedSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn func (c *MockCommandsUserDomainClaimedSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsUserDomainClaimedSentCall { c.Call = c.Call.DoAndReturn(f) return c }