gensql

package
v0.0.0-...-5261409 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 3, 2024 License: MIT Imports: 10 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrBatchAlreadyClosed = errors.New("batch already closed")
)

Functions

This section is empty.

Types

type AddReconcilerOptOutParams 

type AddReconcilerOptOutParams struct {
	TeamSlug       slug.Slug
	UserID         uuid.UUID
	ReconcilerName string
}

type AssignGlobalRoleToServiceAccountParams 

type AssignGlobalRoleToServiceAccountParams struct {
	ServiceAccountID uuid.UUID
	RoleName         RoleName
}

type AssignGlobalRoleToUserParams 

type AssignGlobalRoleToUserParams struct {
	UserID   uuid.UUID
	RoleName RoleName
}

type AssignTeamRoleToServiceAccountParams 

type AssignTeamRoleToServiceAccountParams struct {
	ServiceAccountID uuid.UUID
	RoleName         RoleName
	TargetTeamSlug   slug.Slug
}

type AssignTeamRoleToUserParams 

type AssignTeamRoleToUserParams struct {
	UserID         uuid.UUID
	RoleName       RoleName
	TargetTeamSlug slug.Slug
}

type AuditLog 

type AuditLog struct {
	ID               uuid.UUID
	CreatedAt        pgtype.Timestamptz
	CorrelationID    uuid.UUID
	Actor            *string
	Action           string
	Message          string
	TargetType       string
	TargetIdentifier string
}

type AverageResourceUtilizationForTeamParams 

type AverageResourceUtilizationForTeamParams struct {
	TeamSlug     slug.Slug
	ResourceType ResourceType
	Timestamp    pgtype.Timestamptz
}

type AverageResourceUtilizationForTeamRow 

type AverageResourceUtilizationForTeamRow struct {
	Usage   float64
	Request float64
}

type ClearReconcilerErrorsForTeamParams 

type ClearReconcilerErrorsForTeamParams struct {
	TeamSlug   slug.Slug
	Reconciler string
}

type ConfigureReconcilerParams 

type ConfigureReconcilerParams struct {
	Value          string
	ReconcilerName string
	Key            string
}

type Cost 

type Cost struct {
	ID          int32
	Environment *string
	TeamSlug    slug.Slug
	App         string
	CostType    string
	Date        pgtype.Date
	DailyCost   float32
}

type CostForSqlInstanceParams 

type CostForSqlInstanceParams struct {
	TeamSlug    slug.Slug
	AppName     string
	FromDate    pgtype.Date
	ToDate      pgtype.Date
	Environment string
}

type CostMonthlyTeam 

type CostMonthlyTeam struct {
	TeamSlug         slug.Slug
	Month            pgtype.Date
	LastRecordedDate pgtype.Date
	DailyCost        float32
}

type CostUpsertBatchResults 

type CostUpsertBatchResults struct {
	// contains filtered or unexported fields
}

func (*CostUpsertBatchResults) Close 

func (b *CostUpsertBatchResults) Close() error

func (*CostUpsertBatchResults) Exec 

func (b *CostUpsertBatchResults) Exec(f func(int, error))

type CostUpsertParams 

type CostUpsertParams struct {
	Environment *string
	TeamSlug    slug.Slug
	App         string
	CostType    string
	Date        pgtype.Date
	DailyCost   float32
}

type CreateAPIKeyParams 

type CreateAPIKeyParams struct {
	ApiKey           string
	ServiceAccountID uuid.UUID
}

type CreateAuditLogParams 

type CreateAuditLogParams struct {
	CorrelationID    uuid.UUID
	Actor            *string
	TargetType       string
	TargetIdentifier string
	Action           string
	Message          string
}

type CreateDependencytrackProjectParams 

type CreateDependencytrackProjectParams struct {
	ID          uuid.UUID
	Environment string
	TeamSlug    slug.Slug
	App         string
}

type CreateRepositoryAuthorizationParams 

type CreateRepositoryAuthorizationParams struct {
	TeamSlug                slug.Slug
	GithubRepository        string
	RepositoryAuthorization RepositoryAuthorizationEnum
}

type CreateSessionParams 

type CreateSessionParams struct {
	UserID  uuid.UUID
	Expires pgtype.Timestamptz
}

type CreateTeamDeleteKeyParams 

type CreateTeamDeleteKeyParams struct {
	TeamSlug  slug.Slug
	CreatedBy uuid.UUID
}

type CreateTeamParams 

type CreateTeamParams struct {
	Slug         slug.Slug
	Purpose      string
	SlackChannel string
}

type CreateUserParams 

type CreateUserParams struct {
	Name       string
	Email      string
	ExternalID string
}

type CurrentSqlInstancesCostForTeamParams 

type CurrentSqlInstancesCostForTeamParams struct {
	TeamSlug slug.Slug
	FromDate pgtype.Date
	ToDate   pgtype.Date
}

type DBTX 

type DBTX interface {
	Exec(context.Context, string, ...interface{}) (pgconn.CommandTag, error)
	Query(context.Context, string, ...interface{}) (pgx.Rows, error)
	QueryRow(context.Context, string, ...interface{}) pgx.Row
	SendBatch(context.Context, *pgx.Batch) pgx.BatchResults
}

type DailyCostForAppParams 

type DailyCostForAppParams struct {
	FromDate    pgtype.Date
	ToDate      pgtype.Date
	Environment string
	TeamSlug    slug.Slug
	App         string
}

type DailyCostForTeamParams 

type DailyCostForTeamParams struct {
	FromDate pgtype.Date
	ToDate   pgtype.Date
	TeamSlug slug.Slug
}

type DailyEnvCostForTeamParams 

type DailyEnvCostForTeamParams struct {
	FromDate    pgtype.Date
	ToDate      pgtype.Date
	Environment *string
	TeamSlug    slug.Slug
}

type DailyEnvCostForTeamRow 

type DailyEnvCostForTeamRow struct {
	TeamSlug  slug.Slug
	App       string
	Date      pgtype.Date
	DailyCost float32
}

type DailyVulnerabilityForTeamAndEnvironmentParams 

type DailyVulnerabilityForTeamAndEnvironmentParams struct {
	FromDate    pgtype.Date
	ToDate      pgtype.Date
	TeamSlug    slug.Slug
	Environment string
}

type DailyVulnerabilityForTeamAndEnvironmentRow 

type DailyVulnerabilityForTeamAndEnvironmentRow struct {
	Critical   int64
	High       int64
	Medium     int64
	Low        int64
	Unassigned int64
	RiskScore  int64
	Count      int64
	Date       pgtype.Date
}

type DailyVulnerabilityForTeamParams 

type DailyVulnerabilityForTeamParams struct {
	FromDate pgtype.Date
	ToDate   pgtype.Date
	TeamSlug slug.Slug
}

type DailyVulnerabilityForTeamRow 

type DailyVulnerabilityForTeamRow struct {
	Critical   int64
	High       int64
	Medium     int64
	Low        int64
	Unassigned int64
	RiskScore  int64
	Count      int64
	Date       pgtype.Date
}

type DeleteReconcilerConfigParams 

type DeleteReconcilerConfigParams struct {
	Reconciler string
	Keys       []string
}

type DeleteReconcilerStateForTeamParams 

type DeleteReconcilerStateForTeamParams struct {
	ReconcilerName string
	TeamSlug       slug.Slug
}

type GetAuditLogsForCorrelationIDParams 

type GetAuditLogsForCorrelationIDParams struct {
	CorrelationID uuid.UUID
	Offset        int32
	Limit         int32
}

type GetAuditLogsForReconcilerParams 

type GetAuditLogsForReconcilerParams struct {
	TargetIdentifier string
	Offset           int32
	Limit            int32
}

type GetAuditLogsForTeamParams 

type GetAuditLogsForTeamParams struct {
	TargetIdentifier string
	Offset           int32
	Limit            int32
}

type GetReconcilerConfigParams 

type GetReconcilerConfigParams struct {
	IncludeSecret  bool
	ReconcilerName string
}

type GetReconcilerConfigRow 

type GetReconcilerConfigRow struct {
	Reconciler  string
	Key         string
	DisplayName string
	Description string
	Configured  bool
	Value       *string
	Secret      bool
}

type GetReconcilerStateForTeamParams 

type GetReconcilerStateForTeamParams struct {
	ReconcilerName string
	TeamSlug       slug.Slug
}

type GetReconcilerStateRow 

type GetReconcilerStateRow struct {
	Team            Team
	ReconcilerState ReconcilerState
}

type GetReconcilersParams 

type GetReconcilersParams struct {
	Offset int32
	Limit  int32
}

type GetRepositoryAuthorizationsParams 

type GetRepositoryAuthorizationsParams struct {
	TeamSlug         slug.Slug
	GithubRepository string
}

type GetTeamEnvironmentsBySlugsAndEnvNamesParams 

type GetTeamEnvironmentsBySlugsAndEnvNamesParams struct {
	TeamSlugs    []slug.Slug
	Environments []string
}

type GetTeamEnvironmentsParams 

type GetTeamEnvironmentsParams struct {
	TeamSlug slug.Slug
	Offset   int32
	Limit    int32
}

type GetTeamMemberOptOutsParams 

type GetTeamMemberOptOutsParams struct {
	UserID   uuid.UUID
	TeamSlug slug.Slug
}

type GetTeamMemberOptOutsRow 

type GetTeamMemberOptOutsRow struct {
	Name    string
	Enabled bool
}

type GetTeamMemberParams 

type GetTeamMemberParams struct {
	TeamSlug slug.Slug
	UserID   uuid.UUID
}

type GetTeamMembersForReconcilerParams 

type GetTeamMembersForReconcilerParams struct {
	TeamSlug       slug.Slug
	ReconcilerName string
}

type GetTeamMembersParams 

type GetTeamMembersParams struct {
	TeamSlug slug.Slug
	Offset   int32
	Limit    int32
}

type GetTeamsParams 

type GetTeamsParams struct {
	Offset int32
	Limit  int32
}

type GetUserRolesForUsersRow 

type GetUserRolesForUsersRow struct {
	UserID                 uuid.UUID
	RoleName               RoleName
	TargetTeamSlug         *slug.Slug
	TargetServiceAccountID *uuid.UUID
}

type GetUserTeamsPaginatedParams 

type GetUserTeamsPaginatedParams struct {
	UserID uuid.UUID
	Offset int32
	Limit  int32
}

type GetUserTeamsPaginatedRow 

type GetUserTeamsPaginatedRow struct {
	Team     Team
	RoleName RoleName
}

type GetUserTeamsRow 

type GetUserTeamsRow struct {
	Team     Team
	RoleName RoleName
}

type GetUsersParams 

type GetUsersParams struct {
	Offset int32
	Limit  int32
}

type InsertEnvironmentParams 

type InsertEnvironmentParams struct {
	Name string
	Gcp  bool
}

type ListRepositoriesByAuthorizationParams 

type ListRepositoriesByAuthorizationParams struct {
	TeamSlug                slug.Slug
	RepositoryAuthorization RepositoryAuthorizationEnum
}

type MockQuerier 

type MockQuerier struct {
	mock.Mock
}

MockQuerier is an autogenerated mock type for the Querier type

func NewMockQuerier 

func NewMockQuerier(t interface {
	mock.TestingT
	Cleanup(func())
},
) *MockQuerier

NewMockQuerier creates a new instance of MockQuerier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockQuerier) AddReconcilerOptOut 

func (_m *MockQuerier) AddReconcilerOptOut(ctx context.Context, arg AddReconcilerOptOutParams) error

AddReconcilerOptOut provides a mock function with given fields: ctx, arg

func (*MockQuerier) AssignGlobalRoleToServiceAccount 

func (_m *MockQuerier) AssignGlobalRoleToServiceAccount(ctx context.Context, arg AssignGlobalRoleToServiceAccountParams) error

AssignGlobalRoleToServiceAccount provides a mock function with given fields: ctx, arg

func (*MockQuerier) AssignGlobalRoleToUser 

func (_m *MockQuerier) AssignGlobalRoleToUser(ctx context.Context, arg AssignGlobalRoleToUserParams) error

AssignGlobalRoleToUser provides a mock function with given fields: ctx, arg

func (*MockQuerier) AssignTeamRoleToServiceAccount 

func (_m *MockQuerier) AssignTeamRoleToServiceAccount(ctx context.Context, arg AssignTeamRoleToServiceAccountParams) error

AssignTeamRoleToServiceAccount provides a mock function with given fields: ctx, arg

func (*MockQuerier) AssignTeamRoleToUser 

func (_m *MockQuerier) AssignTeamRoleToUser(ctx context.Context, arg AssignTeamRoleToUserParams) error

AssignTeamRoleToUser provides a mock function with given fields: ctx, arg

func (*MockQuerier) AverageResourceUtilizationForTeam 

func (_m *MockQuerier) AverageResourceUtilizationForTeam(ctx context.Context, arg AverageResourceUtilizationForTeamParams) (*AverageResourceUtilizationForTeamRow, error)

AverageResourceUtilizationForTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) ClearReconcilerErrorsForTeam 

func (_m *MockQuerier) ClearReconcilerErrorsForTeam(ctx context.Context, arg ClearReconcilerErrorsForTeamParams) error

ClearReconcilerErrorsForTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) ConfigureReconciler 

func (_m *MockQuerier) ConfigureReconciler(ctx context.Context, arg ConfigureReconcilerParams) error

ConfigureReconciler provides a mock function with given fields: ctx, arg

func (*MockQuerier) ConfirmTeamDeleteKey 

func (_m *MockQuerier) ConfirmTeamDeleteKey(ctx context.Context, key uuid.UUID) error

ConfirmTeamDeleteKey provides a mock function with given fields: ctx, key

func (*MockQuerier) CostForSqlInstance 

func (_m *MockQuerier) CostForSqlInstance(ctx context.Context, arg CostForSqlInstanceParams) (float32, error)

CostForSqlInstance provides a mock function with given fields: ctx, arg

func (*MockQuerier) CostUpsert 

func (_m *MockQuerier) CostUpsert(ctx context.Context, arg []CostUpsertParams) *CostUpsertBatchResults

CostUpsert provides a mock function with given fields: ctx, arg

func (*MockQuerier) CreateAPIKey 

func (_m *MockQuerier) CreateAPIKey(ctx context.Context, arg CreateAPIKeyParams) error

CreateAPIKey provides a mock function with given fields: ctx, arg

func (*MockQuerier) CreateAuditLog 

func (_m *MockQuerier) CreateAuditLog(ctx context.Context, arg CreateAuditLogParams) error

CreateAuditLog provides a mock function with given fields: ctx, arg

func (*MockQuerier) CreateDependencytrackProject 

func (_m *MockQuerier) CreateDependencytrackProject(ctx context.Context, arg CreateDependencytrackProjectParams) error

CreateDependencytrackProject provides a mock function with given fields: ctx, arg

func (*MockQuerier) CreateRepositoryAuthorization 

func (_m *MockQuerier) CreateRepositoryAuthorization(ctx context.Context, arg CreateRepositoryAuthorizationParams) error

CreateRepositoryAuthorization provides a mock function with given fields: ctx, arg

func (*MockQuerier) CreateServiceAccount 

func (_m *MockQuerier) CreateServiceAccount(ctx context.Context, name string) (*ServiceAccount, error)

CreateServiceAccount provides a mock function with given fields: ctx, name

func (*MockQuerier) CreateSession 

func (_m *MockQuerier) CreateSession(ctx context.Context, arg CreateSessionParams) (*Session, error)

CreateSession provides a mock function with given fields: ctx, arg

func (*MockQuerier) CreateTeam 

func (_m *MockQuerier) CreateTeam(ctx context.Context, arg CreateTeamParams) (*Team, error)

CreateTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) CreateTeamDeleteKey 

func (_m *MockQuerier) CreateTeamDeleteKey(ctx context.Context, arg CreateTeamDeleteKeyParams) (*TeamDeleteKey, error)

CreateTeamDeleteKey provides a mock function with given fields: ctx, arg

func (*MockQuerier) CreateUser 

func (_m *MockQuerier) CreateUser(ctx context.Context, arg CreateUserParams) (*User, error)

CreateUser provides a mock function with given fields: ctx, arg

func (*MockQuerier) CurrentSqlInstancesCostForTeam 

func (_m *MockQuerier) CurrentSqlInstancesCostForTeam(ctx context.Context, arg CurrentSqlInstancesCostForTeamParams) (float32, error)

CurrentSqlInstancesCostForTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) DailyCostForApp 

func (_m *MockQuerier) DailyCostForApp(ctx context.Context, arg DailyCostForAppParams) ([]*Cost, error)

DailyCostForApp provides a mock function with given fields: ctx, arg

func (*MockQuerier) DailyCostForTeam 

func (_m *MockQuerier) DailyCostForTeam(ctx context.Context, arg DailyCostForTeamParams) ([]*Cost, error)

DailyCostForTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) DailyEnvCostForTeam 

func (_m *MockQuerier) DailyEnvCostForTeam(ctx context.Context, arg DailyEnvCostForTeamParams) ([]*DailyEnvCostForTeamRow, error)

DailyEnvCostForTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) DailyVulnerabilityForTeam 

func (_m *MockQuerier) DailyVulnerabilityForTeam(ctx context.Context, arg DailyVulnerabilityForTeamParams) ([]*DailyVulnerabilityForTeamRow, error)

DailyVulnerabilityForTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) DailyVulnerabilityForTeamAndEnvironment 

func (_m *MockQuerier) DailyVulnerabilityForTeamAndEnvironment(ctx context.Context, arg DailyVulnerabilityForTeamAndEnvironmentParams) ([]*DailyVulnerabilityForTeamAndEnvironmentRow, error)

DailyVulnerabilityForTeamAndEnvironment provides a mock function with given fields: ctx, arg

func (*MockQuerier) DeleteAllEnvironments 

func (_m *MockQuerier) DeleteAllEnvironments(ctx context.Context) error

DeleteAllEnvironments provides a mock function with given fields: ctx

func (*MockQuerier) DeleteReconcilerConfig 

func (_m *MockQuerier) DeleteReconcilerConfig(ctx context.Context, arg DeleteReconcilerConfigParams) error

DeleteReconcilerConfig provides a mock function with given fields: ctx, arg

func (*MockQuerier) DeleteReconcilerStateForTeam 

func (_m *MockQuerier) DeleteReconcilerStateForTeam(ctx context.Context, arg DeleteReconcilerStateForTeamParams) error

DeleteReconcilerStateForTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) DeleteServiceAccount 

func (_m *MockQuerier) DeleteServiceAccount(ctx context.Context, id uuid.UUID) error

DeleteServiceAccount provides a mock function with given fields: ctx, id

func (*MockQuerier) DeleteSession 

func (_m *MockQuerier) DeleteSession(ctx context.Context, id uuid.UUID) error

DeleteSession provides a mock function with given fields: ctx, id

func (*MockQuerier) DeleteTeam 

func (_m *MockQuerier) DeleteTeam(ctx context.Context, argSlug slug.Slug) error

DeleteTeam provides a mock function with given fields: ctx, argSlug

func (*MockQuerier) DeleteUser 

func (_m *MockQuerier) DeleteUser(ctx context.Context, id uuid.UUID) error

DeleteUser provides a mock function with given fields: ctx, id

func (*MockQuerier) DisableReconciler 

func (_m *MockQuerier) DisableReconciler(ctx context.Context, name string) (*Reconciler, error)

DisableReconciler provides a mock function with given fields: ctx, name

func (*MockQuerier) EXPECT 

func (_m *MockQuerier) EXPECT() *MockQuerier_Expecter

func (*MockQuerier) EnableReconciler 

func (_m *MockQuerier) EnableReconciler(ctx context.Context, name string) (*Reconciler, error)

EnableReconciler provides a mock function with given fields: ctx, name

func (*MockQuerier) GetActiveTeamBySlug 

func (_m *MockQuerier) GetActiveTeamBySlug(ctx context.Context, argSlug slug.Slug) (*Team, error)

GetActiveTeamBySlug provides a mock function with given fields: ctx, argSlug

func (*MockQuerier) GetActiveTeams 

func (_m *MockQuerier) GetActiveTeams(ctx context.Context) ([]*Team, error)

GetActiveTeams provides a mock function with given fields: ctx

func (*MockQuerier) GetAllTeamMembers 

func (_m *MockQuerier) GetAllTeamMembers(ctx context.Context, teamSlug *slug.Slug) ([]*User, error)

GetAllTeamMembers provides a mock function with given fields: ctx, teamSlug

func (*MockQuerier) GetAllTeamSlugs 

func (_m *MockQuerier) GetAllTeamSlugs(ctx context.Context) ([]slug.Slug, error)

GetAllTeamSlugs provides a mock function with given fields: ctx

func (*MockQuerier) GetAllUserRoles 

func (_m *MockQuerier) GetAllUserRoles(ctx context.Context) ([]*UserRole, error)

GetAllUserRoles provides a mock function with given fields: ctx

func (*MockQuerier) GetAuditLogsForCorrelationID 

func (_m *MockQuerier) GetAuditLogsForCorrelationID(ctx context.Context, arg GetAuditLogsForCorrelationIDParams) ([]*AuditLog, error)

GetAuditLogsForCorrelationID provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetAuditLogsForCorrelationIDCount 

func (_m *MockQuerier) GetAuditLogsForCorrelationIDCount(ctx context.Context, correlationID uuid.UUID) (int64, error)

GetAuditLogsForCorrelationIDCount provides a mock function with given fields: ctx, correlationID

func (*MockQuerier) GetAuditLogsForReconciler 

func (_m *MockQuerier) GetAuditLogsForReconciler(ctx context.Context, arg GetAuditLogsForReconcilerParams) ([]*AuditLog, error)

GetAuditLogsForReconciler provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetAuditLogsForReconcilerCount 

func (_m *MockQuerier) GetAuditLogsForReconcilerCount(ctx context.Context, targetIdentifier string) (int64, error)

GetAuditLogsForReconcilerCount provides a mock function with given fields: ctx, targetIdentifier

func (*MockQuerier) GetAuditLogsForTeam 

func (_m *MockQuerier) GetAuditLogsForTeam(ctx context.Context, arg GetAuditLogsForTeamParams) ([]*AuditLog, error)

GetAuditLogsForTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetAuditLogsForTeamCount 

func (_m *MockQuerier) GetAuditLogsForTeamCount(ctx context.Context, targetIdentifier string) (int64, error)

GetAuditLogsForTeamCount provides a mock function with given fields: ctx, targetIdentifier

func (*MockQuerier) GetEnabledReconcilers 

func (_m *MockQuerier) GetEnabledReconcilers(ctx context.Context) ([]*Reconciler, error)

GetEnabledReconcilers provides a mock function with given fields: ctx

func (*MockQuerier) GetReconciler 

func (_m *MockQuerier) GetReconciler(ctx context.Context, name string) (*Reconciler, error)

GetReconciler provides a mock function with given fields: ctx, name

func (*MockQuerier) GetReconcilerConfig 

func (_m *MockQuerier) GetReconcilerConfig(ctx context.Context, arg GetReconcilerConfigParams) ([]*GetReconcilerConfigRow, error)

GetReconcilerConfig provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetReconcilerState 

func (_m *MockQuerier) GetReconcilerState(ctx context.Context, reconcilerName string) ([]*GetReconcilerStateRow, error)

GetReconcilerState provides a mock function with given fields: ctx, reconcilerName

func (*MockQuerier) GetReconcilerStateForTeam 

func (_m *MockQuerier) GetReconcilerStateForTeam(ctx context.Context, arg GetReconcilerStateForTeamParams) (*ReconcilerState, error)

GetReconcilerStateForTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetReconcilers 

func (_m *MockQuerier) GetReconcilers(ctx context.Context, arg GetReconcilersParams) ([]*Reconciler, error)

GetReconcilers provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetReconcilersCount 

func (_m *MockQuerier) GetReconcilersCount(ctx context.Context) (int64, error)

GetReconcilersCount provides a mock function with given fields: ctx

func (*MockQuerier) GetRepositoryAuthorizations 

func (_m *MockQuerier) GetRepositoryAuthorizations(ctx context.Context, arg GetRepositoryAuthorizationsParams) ([]RepositoryAuthorizationEnum, error)

GetRepositoryAuthorizations provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetServiceAccountByApiKey 

func (_m *MockQuerier) GetServiceAccountByApiKey(ctx context.Context, apiKey string) (*ServiceAccount, error)

GetServiceAccountByApiKey provides a mock function with given fields: ctx, apiKey

func (*MockQuerier) GetServiceAccountByName 

func (_m *MockQuerier) GetServiceAccountByName(ctx context.Context, name string) (*ServiceAccount, error)

GetServiceAccountByName provides a mock function with given fields: ctx, name

func (*MockQuerier) GetServiceAccountRoles 

func (_m *MockQuerier) GetServiceAccountRoles(ctx context.Context, serviceAccountID uuid.UUID) ([]*ServiceAccountRole, error)

GetServiceAccountRoles provides a mock function with given fields: ctx, serviceAccountID

func (*MockQuerier) GetServiceAccounts 

func (_m *MockQuerier) GetServiceAccounts(ctx context.Context) ([]*ServiceAccount, error)

GetServiceAccounts provides a mock function with given fields: ctx

func (*MockQuerier) GetServiceAccountsByIDs 

func (_m *MockQuerier) GetServiceAccountsByIDs(ctx context.Context, ids []uuid.UUID) ([]*ServiceAccount, error)

GetServiceAccountsByIDs provides a mock function with given fields: ctx, ids

func (*MockQuerier) GetSessionByID 

func (_m *MockQuerier) GetSessionByID(ctx context.Context, id uuid.UUID) (*Session, error)

GetSessionByID provides a mock function with given fields: ctx, id

func (*MockQuerier) GetTeamBySlug 

func (_m *MockQuerier) GetTeamBySlug(ctx context.Context, argSlug slug.Slug) (*Team, error)

GetTeamBySlug provides a mock function with given fields: ctx, argSlug

func (*MockQuerier) GetTeamBySlugs 

func (_m *MockQuerier) GetTeamBySlugs(ctx context.Context, slugs []slug.Slug) ([]*Team, error)

GetTeamBySlugs provides a mock function with given fields: ctx, slugs

func (*MockQuerier) GetTeamDeleteKey 

func (_m *MockQuerier) GetTeamDeleteKey(ctx context.Context, key uuid.UUID) (*TeamDeleteKey, error)

GetTeamDeleteKey provides a mock function with given fields: ctx, key

func (*MockQuerier) GetTeamEnvironments 

func (_m *MockQuerier) GetTeamEnvironments(ctx context.Context, arg GetTeamEnvironmentsParams) ([]*TeamAllEnvironment, error)

GetTeamEnvironments provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetTeamEnvironmentsBySlugsAndEnvNames 

func (_m *MockQuerier) GetTeamEnvironmentsBySlugsAndEnvNames(ctx context.Context, arg GetTeamEnvironmentsBySlugsAndEnvNamesParams) ([]*TeamAllEnvironment, error)

GetTeamEnvironmentsBySlugsAndEnvNames provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetTeamEnvironmentsCount 

func (_m *MockQuerier) GetTeamEnvironmentsCount(ctx context.Context, teamSlug slug.Slug) (int64, error)

GetTeamEnvironmentsCount provides a mock function with given fields: ctx, teamSlug

func (*MockQuerier) GetTeamMember 

func (_m *MockQuerier) GetTeamMember(ctx context.Context, arg GetTeamMemberParams) (*User, error)

GetTeamMember provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetTeamMemberOptOuts 

func (_m *MockQuerier) GetTeamMemberOptOuts(ctx context.Context, arg GetTeamMemberOptOutsParams) ([]*GetTeamMemberOptOutsRow, error)

GetTeamMemberOptOuts provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetTeamMembers 

func (_m *MockQuerier) GetTeamMembers(ctx context.Context, arg GetTeamMembersParams) ([]*User, error)

GetTeamMembers provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetTeamMembersCount 

func (_m *MockQuerier) GetTeamMembersCount(ctx context.Context, teamSlug *slug.Slug) (int64, error)

GetTeamMembersCount provides a mock function with given fields: ctx, teamSlug

func (*MockQuerier) GetTeamMembersForReconciler 

func (_m *MockQuerier) GetTeamMembersForReconciler(ctx context.Context, arg GetTeamMembersForReconcilerParams) ([]*User, error)

GetTeamMembersForReconciler provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetTeamReconcilerErrors 

func (_m *MockQuerier) GetTeamReconcilerErrors(ctx context.Context, teamSlug slug.Slug) ([]*ReconcilerError, error)

GetTeamReconcilerErrors provides a mock function with given fields: ctx, teamSlug

func (*MockQuerier) GetTeams 

func (_m *MockQuerier) GetTeams(ctx context.Context, arg GetTeamsParams) ([]*Team, error)

GetTeams provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetTeamsCount 

func (_m *MockQuerier) GetTeamsCount(ctx context.Context) (int64, error)

GetTeamsCount provides a mock function with given fields: ctx

func (*MockQuerier) GetUserByEmail 

func (_m *MockQuerier) GetUserByEmail(ctx context.Context, email string) (*User, error)

GetUserByEmail provides a mock function with given fields: ctx, email

func (*MockQuerier) GetUserByExternalID 

func (_m *MockQuerier) GetUserByExternalID(ctx context.Context, externalID string) (*User, error)

GetUserByExternalID provides a mock function with given fields: ctx, externalID

func (*MockQuerier) GetUserByID 

func (_m *MockQuerier) GetUserByID(ctx context.Context, id uuid.UUID) (*User, error)

GetUserByID provides a mock function with given fields: ctx, id

func (*MockQuerier) GetUserRoles 

func (_m *MockQuerier) GetUserRoles(ctx context.Context, userID uuid.UUID) ([]*UserRole, error)

GetUserRoles provides a mock function with given fields: ctx, userID

func (*MockQuerier) GetUserRolesForUsers 

func (_m *MockQuerier) GetUserRolesForUsers(ctx context.Context, userIds []uuid.UUID) ([]*GetUserRolesForUsersRow, error)

GetUserRolesForUsers provides a mock function with given fields: ctx, userIds

func (*MockQuerier) GetUserTeams 

func (_m *MockQuerier) GetUserTeams(ctx context.Context, userID uuid.UUID) ([]*GetUserTeamsRow, error)

GetUserTeams provides a mock function with given fields: ctx, userID

func (*MockQuerier) GetUserTeamsCount 

func (_m *MockQuerier) GetUserTeamsCount(ctx context.Context, userID uuid.UUID) (int64, error)

GetUserTeamsCount provides a mock function with given fields: ctx, userID

func (*MockQuerier) GetUserTeamsPaginated 

func (_m *MockQuerier) GetUserTeamsPaginated(ctx context.Context, arg GetUserTeamsPaginatedParams) ([]*GetUserTeamsPaginatedRow, error)

GetUserTeamsPaginated provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetUsers 

func (_m *MockQuerier) GetUsers(ctx context.Context, arg GetUsersParams) ([]*User, error)

GetUsers provides a mock function with given fields: ctx, arg

func (*MockQuerier) GetUsersByIDs 

func (_m *MockQuerier) GetUsersByIDs(ctx context.Context, ids []uuid.UUID) ([]*User, error)

GetUsersByIDs provides a mock function with given fields: ctx, ids

func (*MockQuerier) GetUsersCount 

func (_m *MockQuerier) GetUsersCount(ctx context.Context) (int64, error)

GetUsersCount provides a mock function with given fields: ctx

func (*MockQuerier) GetUsersWithGloballyAssignedRole 

func (_m *MockQuerier) GetUsersWithGloballyAssignedRole(ctx context.Context, roleName RoleName) ([]*User, error)

GetUsersWithGloballyAssignedRole provides a mock function with given fields: ctx, roleName

func (*MockQuerier) InsertEnvironment 

func (_m *MockQuerier) InsertEnvironment(ctx context.Context, arg InsertEnvironmentParams) error

InsertEnvironment provides a mock function with given fields: ctx, arg

func (*MockQuerier) LastCostDate 

func (_m *MockQuerier) LastCostDate(ctx context.Context) (pgtype.Date, error)

LastCostDate provides a mock function with given fields: ctx

func (*MockQuerier) ListRepositoriesByAuthorization 

func (_m *MockQuerier) ListRepositoriesByAuthorization(ctx context.Context, arg ListRepositoriesByAuthorizationParams) ([]string, error)

ListRepositoriesByAuthorization provides a mock function with given fields: ctx, arg

func (*MockQuerier) MaxResourceUtilizationDate 

func (_m *MockQuerier) MaxResourceUtilizationDate(ctx context.Context) (pgtype.Timestamptz, error)

MaxResourceUtilizationDate provides a mock function with given fields: ctx

func (*MockQuerier) MonthlyCostForApp 

func (_m *MockQuerier) MonthlyCostForApp(ctx context.Context, arg MonthlyCostForAppParams) ([]*MonthlyCostForAppRow, error)

MonthlyCostForApp provides a mock function with given fields: ctx, arg

func (*MockQuerier) MonthlyCostForTeam 

func (_m *MockQuerier) MonthlyCostForTeam(ctx context.Context, teamSlug slug.Slug) ([]*CostMonthlyTeam, error)

MonthlyCostForTeam provides a mock function with given fields: ctx, teamSlug

func (*MockQuerier) RefreshCostMonthlyTeam 

func (_m *MockQuerier) RefreshCostMonthlyTeam(ctx context.Context) error

RefreshCostMonthlyTeam provides a mock function with given fields: ctx

func (*MockQuerier) RefreshResourceTeamRange 

func (_m *MockQuerier) RefreshResourceTeamRange(ctx context.Context) error

RefreshResourceTeamRange provides a mock function with given fields: ctx

func (*MockQuerier) RemoveAllServiceAccountRoles 

func (_m *MockQuerier) RemoveAllServiceAccountRoles(ctx context.Context, serviceAccountID uuid.UUID) error

RemoveAllServiceAccountRoles provides a mock function with given fields: ctx, serviceAccountID

func (*MockQuerier) RemoveApiKeysFromServiceAccount 

func (_m *MockQuerier) RemoveApiKeysFromServiceAccount(ctx context.Context, serviceAccountID uuid.UUID) error

RemoveApiKeysFromServiceAccount provides a mock function with given fields: ctx, serviceAccountID

func (*MockQuerier) RemoveReconcilerOptOut 

func (_m *MockQuerier) RemoveReconcilerOptOut(ctx context.Context, arg RemoveReconcilerOptOutParams) error

RemoveReconcilerOptOut provides a mock function with given fields: ctx, arg

func (*MockQuerier) RemoveRepositoryAuthorization 

func (_m *MockQuerier) RemoveRepositoryAuthorization(ctx context.Context, arg RemoveRepositoryAuthorizationParams) error

RemoveRepositoryAuthorization provides a mock function with given fields: ctx, arg

func (*MockQuerier) RemoveUserFromTeam 

func (_m *MockQuerier) RemoveUserFromTeam(ctx context.Context, arg RemoveUserFromTeamParams) error

RemoveUserFromTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) ResetReconcilerConfig 

func (_m *MockQuerier) ResetReconcilerConfig(ctx context.Context, reconcilerName string) error

ResetReconcilerConfig provides a mock function with given fields: ctx, reconcilerName

func (*MockQuerier) ResourceUtilizationForApp 

func (_m *MockQuerier) ResourceUtilizationForApp(ctx context.Context, arg ResourceUtilizationForAppParams) ([]*ResourceUtilizationMetric, error)

ResourceUtilizationForApp provides a mock function with given fields: ctx, arg

func (*MockQuerier) ResourceUtilizationForTeam 

func (_m *MockQuerier) ResourceUtilizationForTeam(ctx context.Context, arg ResourceUtilizationForTeamParams) ([]*ResourceUtilizationForTeamRow, error)

ResourceUtilizationForTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) ResourceUtilizationOverageForTeam 

func (_m *MockQuerier) ResourceUtilizationOverageForTeam(ctx context.Context, arg ResourceUtilizationOverageForTeamParams) ([]*ResourceUtilizationOverageForTeamRow, error)

ResourceUtilizationOverageForTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) ResourceUtilizationRangeForApp 

func (_m *MockQuerier) ResourceUtilizationRangeForApp(ctx context.Context, arg ResourceUtilizationRangeForAppParams) (*ResourceUtilizationRangeForAppRow, error)

ResourceUtilizationRangeForApp provides a mock function with given fields: ctx, arg

func (*MockQuerier) ResourceUtilizationRangeForTeam 

func (_m *MockQuerier) ResourceUtilizationRangeForTeam(ctx context.Context, teamSlug slug.Slug) (*ResourceUtilizationRangeForTeamRow, error)

ResourceUtilizationRangeForTeam provides a mock function with given fields: ctx, teamSlug

func (*MockQuerier) ResourceUtilizationUpsert 

func (_m *MockQuerier) ResourceUtilizationUpsert(ctx context.Context, arg []ResourceUtilizationUpsertParams) *ResourceUtilizationUpsertBatchResults

ResourceUtilizationUpsert provides a mock function with given fields: ctx, arg

func (*MockQuerier) RevokeGlobalUserRole 

func (_m *MockQuerier) RevokeGlobalUserRole(ctx context.Context, arg RevokeGlobalUserRoleParams) error

RevokeGlobalUserRole provides a mock function with given fields: ctx, arg

func (*MockQuerier) SetLastSuccessfulSyncForTeam 

func (_m *MockQuerier) SetLastSuccessfulSyncForTeam(ctx context.Context, argSlug slug.Slug) error

SetLastSuccessfulSyncForTeam provides a mock function with given fields: ctx, argSlug

func (*MockQuerier) SetReconcilerErrorForTeam 

func (_m *MockQuerier) SetReconcilerErrorForTeam(ctx context.Context, arg SetReconcilerErrorForTeamParams) error

SetReconcilerErrorForTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) SetSessionExpires 

func (_m *MockQuerier) SetSessionExpires(ctx context.Context, arg SetSessionExpiresParams) (*Session, error)

SetSessionExpires provides a mock function with given fields: ctx, arg

func (*MockQuerier) SpecificResourceUtilizationForApp 

func (_m *MockQuerier) SpecificResourceUtilizationForApp(ctx context.Context, arg SpecificResourceUtilizationForAppParams) (*SpecificResourceUtilizationForAppRow, error)

SpecificResourceUtilizationForApp provides a mock function with given fields: ctx, arg

func (*MockQuerier) SpecificResourceUtilizationForTeam 

func (_m *MockQuerier) SpecificResourceUtilizationForTeam(ctx context.Context, arg SpecificResourceUtilizationForTeamParams) ([]*SpecificResourceUtilizationForTeamRow, error)

SpecificResourceUtilizationForTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) TeamExists 

func (_m *MockQuerier) TeamExists(ctx context.Context, argSlug slug.Slug) (bool, error)

TeamExists provides a mock function with given fields: ctx, argSlug

func (*MockQuerier) UpdateTeam 

func (_m *MockQuerier) UpdateTeam(ctx context.Context, arg UpdateTeamParams) (*Team, error)

UpdateTeam provides a mock function with given fields: ctx, arg

func (*MockQuerier) UpdateTeamExternalReferences 

func (_m *MockQuerier) UpdateTeamExternalReferences(ctx context.Context, arg UpdateTeamExternalReferencesParams) (*Team, error)

UpdateTeamExternalReferences provides a mock function with given fields: ctx, arg

func (*MockQuerier) UpdateUser 

func (_m *MockQuerier) UpdateUser(ctx context.Context, arg UpdateUserParams) (*User, error)

UpdateUser provides a mock function with given fields: ctx, arg

func (*MockQuerier) UpsertReconciler 

func (_m *MockQuerier) UpsertReconciler(ctx context.Context, arg UpsertReconcilerParams) (*Reconciler, error)

UpsertReconciler provides a mock function with given fields: ctx, arg

func (*MockQuerier) UpsertReconcilerConfig 

func (_m *MockQuerier) UpsertReconcilerConfig(ctx context.Context, arg UpsertReconcilerConfigParams) error

UpsertReconcilerConfig provides a mock function with given fields: ctx, arg

func (*MockQuerier) UpsertReconcilerState 

func (_m *MockQuerier) UpsertReconcilerState(ctx context.Context, arg UpsertReconcilerStateParams) (*ReconcilerState, error)

UpsertReconcilerState provides a mock function with given fields: ctx, arg

func (*MockQuerier) UpsertTeamEnvironment 

func (_m *MockQuerier) UpsertTeamEnvironment(ctx context.Context, arg UpsertTeamEnvironmentParams) (*TeamEnvironment, error)

UpsertTeamEnvironment provides a mock function with given fields: ctx, arg

func (*MockQuerier) VulnerabilityMetricsDateRangeForTeam 

func (_m *MockQuerier) VulnerabilityMetricsDateRangeForTeam(ctx context.Context, teamSlug slug.Slug) (*VulnerabilityMetricsDateRangeForTeamRow, error)

VulnerabilityMetricsDateRangeForTeam provides a mock function with given fields: ctx, teamSlug

func (*MockQuerier) VulnerabilityMetricsMaxDate 

func (_m *MockQuerier) VulnerabilityMetricsMaxDate(ctx context.Context, arg VulnerabilityMetricsMaxDateParams) (pgtype.Date, error)

VulnerabilityMetricsMaxDate provides a mock function with given fields: ctx, arg

func (*MockQuerier) VulnerabilityMetricsUpsert 

func (_m *MockQuerier) VulnerabilityMetricsUpsert(ctx context.Context, arg []VulnerabilityMetricsUpsertParams) *VulnerabilityMetricsUpsertBatchResults

VulnerabilityMetricsUpsert provides a mock function with given fields: ctx, arg

type MockQuerier_AddReconcilerOptOut_Call 

type MockQuerier_AddReconcilerOptOut_Call struct {
	*mock.Call
}

MockQuerier_AddReconcilerOptOut_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddReconcilerOptOut'

func (*MockQuerier_AddReconcilerOptOut_Call) Return 

func (_c *MockQuerier_AddReconcilerOptOut_Call) Return(_a0 error) *MockQuerier_AddReconcilerOptOut_Call

func (*MockQuerier_AddReconcilerOptOut_Call) Run 

func (_c *MockQuerier_AddReconcilerOptOut_Call) Run(run func(ctx context.Context, arg AddReconcilerOptOutParams)) *MockQuerier_AddReconcilerOptOut_Call

func (*MockQuerier_AddReconcilerOptOut_Call) RunAndReturn 

func (_c *MockQuerier_AddReconcilerOptOut_Call) RunAndReturn(run func(context.Context, AddReconcilerOptOutParams) error) *MockQuerier_AddReconcilerOptOut_Call

type MockQuerier_AssignGlobalRoleToServiceAccount_Call 

type MockQuerier_AssignGlobalRoleToServiceAccount_Call struct {
	*mock.Call
}

MockQuerier_AssignGlobalRoleToServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignGlobalRoleToServiceAccount'

func (*MockQuerier_AssignGlobalRoleToServiceAccount_Call) Return 

func (_c *MockQuerier_AssignGlobalRoleToServiceAccount_Call) Return(_a0 error) *MockQuerier_AssignGlobalRoleToServiceAccount_Call

func (*MockQuerier_AssignGlobalRoleToServiceAccount_Call) Run 

func (_c *MockQuerier_AssignGlobalRoleToServiceAccount_Call) Run(run func(ctx context.Context, arg AssignGlobalRoleToServiceAccountParams)) *MockQuerier_AssignGlobalRoleToServiceAccount_Call

func (*MockQuerier_AssignGlobalRoleToServiceAccount_Call) RunAndReturn 

func (_c *MockQuerier_AssignGlobalRoleToServiceAccount_Call) RunAndReturn(run func(context.Context, AssignGlobalRoleToServiceAccountParams) error) *MockQuerier_AssignGlobalRoleToServiceAccount_Call

type MockQuerier_AssignGlobalRoleToUser_Call 

type MockQuerier_AssignGlobalRoleToUser_Call struct {
	*mock.Call
}

MockQuerier_AssignGlobalRoleToUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignGlobalRoleToUser'

func (*MockQuerier_AssignGlobalRoleToUser_Call) Return 

func (_c *MockQuerier_AssignGlobalRoleToUser_Call) Return(_a0 error) *MockQuerier_AssignGlobalRoleToUser_Call

func (*MockQuerier_AssignGlobalRoleToUser_Call) Run 

func (_c *MockQuerier_AssignGlobalRoleToUser_Call) Run(run func(ctx context.Context, arg AssignGlobalRoleToUserParams)) *MockQuerier_AssignGlobalRoleToUser_Call

func (*MockQuerier_AssignGlobalRoleToUser_Call) RunAndReturn 

func (_c *MockQuerier_AssignGlobalRoleToUser_Call) RunAndReturn(run func(context.Context, AssignGlobalRoleToUserParams) error) *MockQuerier_AssignGlobalRoleToUser_Call

type MockQuerier_AssignTeamRoleToServiceAccount_Call 

type MockQuerier_AssignTeamRoleToServiceAccount_Call struct {
	*mock.Call
}

MockQuerier_AssignTeamRoleToServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignTeamRoleToServiceAccount'

func (*MockQuerier_AssignTeamRoleToServiceAccount_Call) Return 

func (_c *MockQuerier_AssignTeamRoleToServiceAccount_Call) Return(_a0 error) *MockQuerier_AssignTeamRoleToServiceAccount_Call

func (*MockQuerier_AssignTeamRoleToServiceAccount_Call) Run 

func (_c *MockQuerier_AssignTeamRoleToServiceAccount_Call) Run(run func(ctx context.Context, arg AssignTeamRoleToServiceAccountParams)) *MockQuerier_AssignTeamRoleToServiceAccount_Call

func (*MockQuerier_AssignTeamRoleToServiceAccount_Call) RunAndReturn 

func (_c *MockQuerier_AssignTeamRoleToServiceAccount_Call) RunAndReturn(run func(context.Context, AssignTeamRoleToServiceAccountParams) error) *MockQuerier_AssignTeamRoleToServiceAccount_Call

type MockQuerier_AssignTeamRoleToUser_Call 

type MockQuerier_AssignTeamRoleToUser_Call struct {
	*mock.Call
}

MockQuerier_AssignTeamRoleToUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignTeamRoleToUser'

func (*MockQuerier_AssignTeamRoleToUser_Call) Return 

func (_c *MockQuerier_AssignTeamRoleToUser_Call) Return(_a0 error) *MockQuerier_AssignTeamRoleToUser_Call

func (*MockQuerier_AssignTeamRoleToUser_Call) Run 

func (_c *MockQuerier_AssignTeamRoleToUser_Call) Run(run func(ctx context.Context, arg AssignTeamRoleToUserParams)) *MockQuerier_AssignTeamRoleToUser_Call

func (*MockQuerier_AssignTeamRoleToUser_Call) RunAndReturn 

func (_c *MockQuerier_AssignTeamRoleToUser_Call) RunAndReturn(run func(context.Context, AssignTeamRoleToUserParams) error) *MockQuerier_AssignTeamRoleToUser_Call

type MockQuerier_AverageResourceUtilizationForTeam_Call 

type MockQuerier_AverageResourceUtilizationForTeam_Call struct {
	*mock.Call
}

MockQuerier_AverageResourceUtilizationForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AverageResourceUtilizationForTeam'

func (*MockQuerier_AverageResourceUtilizationForTeam_Call) Return 

func (_c *MockQuerier_AverageResourceUtilizationForTeam_Call) Return(_a0 *AverageResourceUtilizationForTeamRow, _a1 error) *MockQuerier_AverageResourceUtilizationForTeam_Call

func (*MockQuerier_AverageResourceUtilizationForTeam_Call) Run 

func (_c *MockQuerier_AverageResourceUtilizationForTeam_Call) Run(run func(ctx context.Context, arg AverageResourceUtilizationForTeamParams)) *MockQuerier_AverageResourceUtilizationForTeam_Call

func (*MockQuerier_AverageResourceUtilizationForTeam_Call) RunAndReturn 

func (_c *MockQuerier_AverageResourceUtilizationForTeam_Call) RunAndReturn(run func(context.Context, AverageResourceUtilizationForTeamParams) (*AverageResourceUtilizationForTeamRow, error)) *MockQuerier_AverageResourceUtilizationForTeam_Call

type MockQuerier_ClearReconcilerErrorsForTeam_Call 

type MockQuerier_ClearReconcilerErrorsForTeam_Call struct {
	*mock.Call
}

MockQuerier_ClearReconcilerErrorsForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearReconcilerErrorsForTeam'

func (*MockQuerier_ClearReconcilerErrorsForTeam_Call) Return 

func (_c *MockQuerier_ClearReconcilerErrorsForTeam_Call) Return(_a0 error) *MockQuerier_ClearReconcilerErrorsForTeam_Call

func (*MockQuerier_ClearReconcilerErrorsForTeam_Call) Run 

func (_c *MockQuerier_ClearReconcilerErrorsForTeam_Call) Run(run func(ctx context.Context, arg ClearReconcilerErrorsForTeamParams)) *MockQuerier_ClearReconcilerErrorsForTeam_Call

func (*MockQuerier_ClearReconcilerErrorsForTeam_Call) RunAndReturn 

func (_c *MockQuerier_ClearReconcilerErrorsForTeam_Call) RunAndReturn(run func(context.Context, ClearReconcilerErrorsForTeamParams) error) *MockQuerier_ClearReconcilerErrorsForTeam_Call

type MockQuerier_ConfigureReconciler_Call 

type MockQuerier_ConfigureReconciler_Call struct {
	*mock.Call
}

MockQuerier_ConfigureReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigureReconciler'

func (*MockQuerier_ConfigureReconciler_Call) Return 

func (_c *MockQuerier_ConfigureReconciler_Call) Return(_a0 error) *MockQuerier_ConfigureReconciler_Call

func (*MockQuerier_ConfigureReconciler_Call) Run 

func (_c *MockQuerier_ConfigureReconciler_Call) Run(run func(ctx context.Context, arg ConfigureReconcilerParams)) *MockQuerier_ConfigureReconciler_Call

func (*MockQuerier_ConfigureReconciler_Call) RunAndReturn 

func (_c *MockQuerier_ConfigureReconciler_Call) RunAndReturn(run func(context.Context, ConfigureReconcilerParams) error) *MockQuerier_ConfigureReconciler_Call

type MockQuerier_ConfirmTeamDeleteKey_Call 

type MockQuerier_ConfirmTeamDeleteKey_Call struct {
	*mock.Call
}

MockQuerier_ConfirmTeamDeleteKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfirmTeamDeleteKey'

func (*MockQuerier_ConfirmTeamDeleteKey_Call) Return 

func (_c *MockQuerier_ConfirmTeamDeleteKey_Call) Return(_a0 error) *MockQuerier_ConfirmTeamDeleteKey_Call

func (*MockQuerier_ConfirmTeamDeleteKey_Call) Run 

func (_c *MockQuerier_ConfirmTeamDeleteKey_Call) Run(run func(ctx context.Context, key uuid.UUID)) *MockQuerier_ConfirmTeamDeleteKey_Call

func (*MockQuerier_ConfirmTeamDeleteKey_Call) RunAndReturn 

func (_c *MockQuerier_ConfirmTeamDeleteKey_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockQuerier_ConfirmTeamDeleteKey_Call

type MockQuerier_CostForSqlInstance_Call 

type MockQuerier_CostForSqlInstance_Call struct {
	*mock.Call
}

MockQuerier_CostForSqlInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CostForSqlInstance'

func (*MockQuerier_CostForSqlInstance_Call) Return 

func (_c *MockQuerier_CostForSqlInstance_Call) Return(_a0 float32, _a1 error) *MockQuerier_CostForSqlInstance_Call

func (*MockQuerier_CostForSqlInstance_Call) Run 

func (_c *MockQuerier_CostForSqlInstance_Call) Run(run func(ctx context.Context, arg CostForSqlInstanceParams)) *MockQuerier_CostForSqlInstance_Call

func (*MockQuerier_CostForSqlInstance_Call) RunAndReturn 

func (_c *MockQuerier_CostForSqlInstance_Call) RunAndReturn(run func(context.Context, CostForSqlInstanceParams) (float32, error)) *MockQuerier_CostForSqlInstance_Call

type MockQuerier_CostUpsert_Call 

type MockQuerier_CostUpsert_Call struct {
	*mock.Call
}

MockQuerier_CostUpsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CostUpsert'

func (*MockQuerier_CostUpsert_Call) Return 

func (_c *MockQuerier_CostUpsert_Call) Return(_a0 *CostUpsertBatchResults) *MockQuerier_CostUpsert_Call

func (*MockQuerier_CostUpsert_Call) Run 

func (_c *MockQuerier_CostUpsert_Call) Run(run func(ctx context.Context, arg []CostUpsertParams)) *MockQuerier_CostUpsert_Call

func (*MockQuerier_CostUpsert_Call) RunAndReturn 

func (_c *MockQuerier_CostUpsert_Call) RunAndReturn(run func(context.Context, []CostUpsertParams) *CostUpsertBatchResults) *MockQuerier_CostUpsert_Call

type MockQuerier_CreateAPIKey_Call 

type MockQuerier_CreateAPIKey_Call struct {
	*mock.Call
}

MockQuerier_CreateAPIKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAPIKey'

func (*MockQuerier_CreateAPIKey_Call) Return 

func (_c *MockQuerier_CreateAPIKey_Call) Return(_a0 error) *MockQuerier_CreateAPIKey_Call

func (*MockQuerier_CreateAPIKey_Call) Run 

func (_c *MockQuerier_CreateAPIKey_Call) Run(run func(ctx context.Context, arg CreateAPIKeyParams)) *MockQuerier_CreateAPIKey_Call

func (*MockQuerier_CreateAPIKey_Call) RunAndReturn 

func (_c *MockQuerier_CreateAPIKey_Call) RunAndReturn(run func(context.Context, CreateAPIKeyParams) error) *MockQuerier_CreateAPIKey_Call

type MockQuerier_CreateAuditLog_Call 

type MockQuerier_CreateAuditLog_Call struct {
	*mock.Call
}

MockQuerier_CreateAuditLog_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAuditLog'

func (*MockQuerier_CreateAuditLog_Call) Return 

func (_c *MockQuerier_CreateAuditLog_Call) Return(_a0 error) *MockQuerier_CreateAuditLog_Call

func (*MockQuerier_CreateAuditLog_Call) Run 

func (_c *MockQuerier_CreateAuditLog_Call) Run(run func(ctx context.Context, arg CreateAuditLogParams)) *MockQuerier_CreateAuditLog_Call

func (*MockQuerier_CreateAuditLog_Call) RunAndReturn 

func (_c *MockQuerier_CreateAuditLog_Call) RunAndReturn(run func(context.Context, CreateAuditLogParams) error) *MockQuerier_CreateAuditLog_Call

type MockQuerier_CreateDependencytrackProject_Call 

type MockQuerier_CreateDependencytrackProject_Call struct {
	*mock.Call
}

MockQuerier_CreateDependencytrackProject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDependencytrackProject'

func (*MockQuerier_CreateDependencytrackProject_Call) Return 

func (_c *MockQuerier_CreateDependencytrackProject_Call) Return(_a0 error) *MockQuerier_CreateDependencytrackProject_Call

func (*MockQuerier_CreateDependencytrackProject_Call) Run 

func (_c *MockQuerier_CreateDependencytrackProject_Call) Run(run func(ctx context.Context, arg CreateDependencytrackProjectParams)) *MockQuerier_CreateDependencytrackProject_Call

func (*MockQuerier_CreateDependencytrackProject_Call) RunAndReturn 

func (_c *MockQuerier_CreateDependencytrackProject_Call) RunAndReturn(run func(context.Context, CreateDependencytrackProjectParams) error) *MockQuerier_CreateDependencytrackProject_Call

type MockQuerier_CreateRepositoryAuthorization_Call 

type MockQuerier_CreateRepositoryAuthorization_Call struct {
	*mock.Call
}

MockQuerier_CreateRepositoryAuthorization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRepositoryAuthorization'

func (*MockQuerier_CreateRepositoryAuthorization_Call) Return 

func (_c *MockQuerier_CreateRepositoryAuthorization_Call) Return(_a0 error) *MockQuerier_CreateRepositoryAuthorization_Call

func (*MockQuerier_CreateRepositoryAuthorization_Call) Run 

func (_c *MockQuerier_CreateRepositoryAuthorization_Call) Run(run func(ctx context.Context, arg CreateRepositoryAuthorizationParams)) *MockQuerier_CreateRepositoryAuthorization_Call

func (*MockQuerier_CreateRepositoryAuthorization_Call) RunAndReturn 

func (_c *MockQuerier_CreateRepositoryAuthorization_Call) RunAndReturn(run func(context.Context, CreateRepositoryAuthorizationParams) error) *MockQuerier_CreateRepositoryAuthorization_Call

type MockQuerier_CreateServiceAccount_Call 

type MockQuerier_CreateServiceAccount_Call struct {
	*mock.Call
}

MockQuerier_CreateServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateServiceAccount'

func (*MockQuerier_CreateServiceAccount_Call) Return 

func (_c *MockQuerier_CreateServiceAccount_Call) Return(_a0 *ServiceAccount, _a1 error) *MockQuerier_CreateServiceAccount_Call

func (*MockQuerier_CreateServiceAccount_Call) Run 

func (_c *MockQuerier_CreateServiceAccount_Call) Run(run func(ctx context.Context, name string)) *MockQuerier_CreateServiceAccount_Call

func (*MockQuerier_CreateServiceAccount_Call) RunAndReturn 

func (_c *MockQuerier_CreateServiceAccount_Call) RunAndReturn(run func(context.Context, string) (*ServiceAccount, error)) *MockQuerier_CreateServiceAccount_Call

type MockQuerier_CreateSession_Call 

type MockQuerier_CreateSession_Call struct {
	*mock.Call
}

MockQuerier_CreateSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSession'

func (*MockQuerier_CreateSession_Call) Return 

func (_c *MockQuerier_CreateSession_Call) Return(_a0 *Session, _a1 error) *MockQuerier_CreateSession_Call

func (*MockQuerier_CreateSession_Call) Run 

func (_c *MockQuerier_CreateSession_Call) Run(run func(ctx context.Context, arg CreateSessionParams)) *MockQuerier_CreateSession_Call

func (*MockQuerier_CreateSession_Call) RunAndReturn 

func (_c *MockQuerier_CreateSession_Call) RunAndReturn(run func(context.Context, CreateSessionParams) (*Session, error)) *MockQuerier_CreateSession_Call

type MockQuerier_CreateTeamDeleteKey_Call 

type MockQuerier_CreateTeamDeleteKey_Call struct {
	*mock.Call
}

MockQuerier_CreateTeamDeleteKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTeamDeleteKey'

func (*MockQuerier_CreateTeamDeleteKey_Call) Return 

func (_c *MockQuerier_CreateTeamDeleteKey_Call) Return(_a0 *TeamDeleteKey, _a1 error) *MockQuerier_CreateTeamDeleteKey_Call

func (*MockQuerier_CreateTeamDeleteKey_Call) Run 

func (_c *MockQuerier_CreateTeamDeleteKey_Call) Run(run func(ctx context.Context, arg CreateTeamDeleteKeyParams)) *MockQuerier_CreateTeamDeleteKey_Call

func (*MockQuerier_CreateTeamDeleteKey_Call) RunAndReturn 

func (_c *MockQuerier_CreateTeamDeleteKey_Call) RunAndReturn(run func(context.Context, CreateTeamDeleteKeyParams) (*TeamDeleteKey, error)) *MockQuerier_CreateTeamDeleteKey_Call

type MockQuerier_CreateTeam_Call 

type MockQuerier_CreateTeam_Call struct {
	*mock.Call
}

MockQuerier_CreateTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTeam'

func (*MockQuerier_CreateTeam_Call) Return 

func (_c *MockQuerier_CreateTeam_Call) Return(_a0 *Team, _a1 error) *MockQuerier_CreateTeam_Call

func (*MockQuerier_CreateTeam_Call) Run 

func (_c *MockQuerier_CreateTeam_Call) Run(run func(ctx context.Context, arg CreateTeamParams)) *MockQuerier_CreateTeam_Call

func (*MockQuerier_CreateTeam_Call) RunAndReturn 

func (_c *MockQuerier_CreateTeam_Call) RunAndReturn(run func(context.Context, CreateTeamParams) (*Team, error)) *MockQuerier_CreateTeam_Call

type MockQuerier_CreateUser_Call 

type MockQuerier_CreateUser_Call struct {
	*mock.Call
}

MockQuerier_CreateUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateUser'

func (*MockQuerier_CreateUser_Call) Return 

func (_c *MockQuerier_CreateUser_Call) Return(_a0 *User, _a1 error) *MockQuerier_CreateUser_Call

func (*MockQuerier_CreateUser_Call) Run 

func (_c *MockQuerier_CreateUser_Call) Run(run func(ctx context.Context, arg CreateUserParams)) *MockQuerier_CreateUser_Call

func (*MockQuerier_CreateUser_Call) RunAndReturn 

func (_c *MockQuerier_CreateUser_Call) RunAndReturn(run func(context.Context, CreateUserParams) (*User, error)) *MockQuerier_CreateUser_Call

type MockQuerier_CurrentSqlInstancesCostForTeam_Call 

type MockQuerier_CurrentSqlInstancesCostForTeam_Call struct {
	*mock.Call
}

MockQuerier_CurrentSqlInstancesCostForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurrentSqlInstancesCostForTeam'

func (*MockQuerier_CurrentSqlInstancesCostForTeam_Call) Return 

func (_c *MockQuerier_CurrentSqlInstancesCostForTeam_Call) Return(_a0 float32, _a1 error) *MockQuerier_CurrentSqlInstancesCostForTeam_Call

func (*MockQuerier_CurrentSqlInstancesCostForTeam_Call) Run 

func (_c *MockQuerier_CurrentSqlInstancesCostForTeam_Call) Run(run func(ctx context.Context, arg CurrentSqlInstancesCostForTeamParams)) *MockQuerier_CurrentSqlInstancesCostForTeam_Call

func (*MockQuerier_CurrentSqlInstancesCostForTeam_Call) RunAndReturn 

func (_c *MockQuerier_CurrentSqlInstancesCostForTeam_Call) RunAndReturn(run func(context.Context, CurrentSqlInstancesCostForTeamParams) (float32, error)) *MockQuerier_CurrentSqlInstancesCostForTeam_Call

type MockQuerier_DailyCostForApp_Call 

type MockQuerier_DailyCostForApp_Call struct {
	*mock.Call
}

MockQuerier_DailyCostForApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DailyCostForApp'

func (*MockQuerier_DailyCostForApp_Call) Return 

func (_c *MockQuerier_DailyCostForApp_Call) Return(_a0 []*Cost, _a1 error) *MockQuerier_DailyCostForApp_Call

func (*MockQuerier_DailyCostForApp_Call) Run 

func (_c *MockQuerier_DailyCostForApp_Call) Run(run func(ctx context.Context, arg DailyCostForAppParams)) *MockQuerier_DailyCostForApp_Call

func (*MockQuerier_DailyCostForApp_Call) RunAndReturn 

func (_c *MockQuerier_DailyCostForApp_Call) RunAndReturn(run func(context.Context, DailyCostForAppParams) ([]*Cost, error)) *MockQuerier_DailyCostForApp_Call

type MockQuerier_DailyCostForTeam_Call 

type MockQuerier_DailyCostForTeam_Call struct {
	*mock.Call
}

MockQuerier_DailyCostForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DailyCostForTeam'

func (*MockQuerier_DailyCostForTeam_Call) Return 

func (_c *MockQuerier_DailyCostForTeam_Call) Return(_a0 []*Cost, _a1 error) *MockQuerier_DailyCostForTeam_Call

func (*MockQuerier_DailyCostForTeam_Call) Run 

func (_c *MockQuerier_DailyCostForTeam_Call) Run(run func(ctx context.Context, arg DailyCostForTeamParams)) *MockQuerier_DailyCostForTeam_Call

func (*MockQuerier_DailyCostForTeam_Call) RunAndReturn 

func (_c *MockQuerier_DailyCostForTeam_Call) RunAndReturn(run func(context.Context, DailyCostForTeamParams) ([]*Cost, error)) *MockQuerier_DailyCostForTeam_Call

type MockQuerier_DailyEnvCostForTeam_Call 

type MockQuerier_DailyEnvCostForTeam_Call struct {
	*mock.Call
}

MockQuerier_DailyEnvCostForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DailyEnvCostForTeam'

func (*MockQuerier_DailyEnvCostForTeam_Call) Return 

func (_c *MockQuerier_DailyEnvCostForTeam_Call) Return(_a0 []*DailyEnvCostForTeamRow, _a1 error) *MockQuerier_DailyEnvCostForTeam_Call

func (*MockQuerier_DailyEnvCostForTeam_Call) Run 

func (_c *MockQuerier_DailyEnvCostForTeam_Call) Run(run func(ctx context.Context, arg DailyEnvCostForTeamParams)) *MockQuerier_DailyEnvCostForTeam_Call

func (*MockQuerier_DailyEnvCostForTeam_Call) RunAndReturn 

func (_c *MockQuerier_DailyEnvCostForTeam_Call) RunAndReturn(run func(context.Context, DailyEnvCostForTeamParams) ([]*DailyEnvCostForTeamRow, error)) *MockQuerier_DailyEnvCostForTeam_Call

type MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call 

type MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call struct {
	*mock.Call
}

MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DailyVulnerabilityForTeamAndEnvironment'

func (*MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call) Return 

func (_c *MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call) Return(_a0 []*DailyVulnerabilityForTeamAndEnvironmentRow, _a1 error) *MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call

func (*MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call) Run 

func (_c *MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call) Run(run func(ctx context.Context, arg DailyVulnerabilityForTeamAndEnvironmentParams)) *MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call

func (*MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call) RunAndReturn 

func (_c *MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call) RunAndReturn(run func(context.Context, DailyVulnerabilityForTeamAndEnvironmentParams) ([]*DailyVulnerabilityForTeamAndEnvironmentRow, error)) *MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call

type MockQuerier_DailyVulnerabilityForTeam_Call 

type MockQuerier_DailyVulnerabilityForTeam_Call struct {
	*mock.Call
}

MockQuerier_DailyVulnerabilityForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DailyVulnerabilityForTeam'

func (*MockQuerier_DailyVulnerabilityForTeam_Call) Return 

func (_c *MockQuerier_DailyVulnerabilityForTeam_Call) Return(_a0 []*DailyVulnerabilityForTeamRow, _a1 error) *MockQuerier_DailyVulnerabilityForTeam_Call

func (*MockQuerier_DailyVulnerabilityForTeam_Call) Run 

func (_c *MockQuerier_DailyVulnerabilityForTeam_Call) Run(run func(ctx context.Context, arg DailyVulnerabilityForTeamParams)) *MockQuerier_DailyVulnerabilityForTeam_Call

func (*MockQuerier_DailyVulnerabilityForTeam_Call) RunAndReturn 

func (_c *MockQuerier_DailyVulnerabilityForTeam_Call) RunAndReturn(run func(context.Context, DailyVulnerabilityForTeamParams) ([]*DailyVulnerabilityForTeamRow, error)) *MockQuerier_DailyVulnerabilityForTeam_Call

type MockQuerier_DeleteAllEnvironments_Call 

type MockQuerier_DeleteAllEnvironments_Call struct {
	*mock.Call
}

MockQuerier_DeleteAllEnvironments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllEnvironments'

func (*MockQuerier_DeleteAllEnvironments_Call) Return 

func (_c *MockQuerier_DeleteAllEnvironments_Call) Return(_a0 error) *MockQuerier_DeleteAllEnvironments_Call

func (*MockQuerier_DeleteAllEnvironments_Call) Run 

func (_c *MockQuerier_DeleteAllEnvironments_Call) Run(run func(ctx context.Context)) *MockQuerier_DeleteAllEnvironments_Call

func (*MockQuerier_DeleteAllEnvironments_Call) RunAndReturn 

func (_c *MockQuerier_DeleteAllEnvironments_Call) RunAndReturn(run func(context.Context) error) *MockQuerier_DeleteAllEnvironments_Call

type MockQuerier_DeleteReconcilerConfig_Call 

type MockQuerier_DeleteReconcilerConfig_Call struct {
	*mock.Call
}

MockQuerier_DeleteReconcilerConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteReconcilerConfig'

func (*MockQuerier_DeleteReconcilerConfig_Call) Return 

func (_c *MockQuerier_DeleteReconcilerConfig_Call) Return(_a0 error) *MockQuerier_DeleteReconcilerConfig_Call

func (*MockQuerier_DeleteReconcilerConfig_Call) Run 

func (_c *MockQuerier_DeleteReconcilerConfig_Call) Run(run func(ctx context.Context, arg DeleteReconcilerConfigParams)) *MockQuerier_DeleteReconcilerConfig_Call

func (*MockQuerier_DeleteReconcilerConfig_Call) RunAndReturn 

func (_c *MockQuerier_DeleteReconcilerConfig_Call) RunAndReturn(run func(context.Context, DeleteReconcilerConfigParams) error) *MockQuerier_DeleteReconcilerConfig_Call

type MockQuerier_DeleteReconcilerStateForTeam_Call 

type MockQuerier_DeleteReconcilerStateForTeam_Call struct {
	*mock.Call
}

MockQuerier_DeleteReconcilerStateForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteReconcilerStateForTeam'

func (*MockQuerier_DeleteReconcilerStateForTeam_Call) Return 

func (_c *MockQuerier_DeleteReconcilerStateForTeam_Call) Return(_a0 error) *MockQuerier_DeleteReconcilerStateForTeam_Call

func (*MockQuerier_DeleteReconcilerStateForTeam_Call) Run 

func (_c *MockQuerier_DeleteReconcilerStateForTeam_Call) Run(run func(ctx context.Context, arg DeleteReconcilerStateForTeamParams)) *MockQuerier_DeleteReconcilerStateForTeam_Call

func (*MockQuerier_DeleteReconcilerStateForTeam_Call) RunAndReturn 

func (_c *MockQuerier_DeleteReconcilerStateForTeam_Call) RunAndReturn(run func(context.Context, DeleteReconcilerStateForTeamParams) error) *MockQuerier_DeleteReconcilerStateForTeam_Call

type MockQuerier_DeleteServiceAccount_Call 

type MockQuerier_DeleteServiceAccount_Call struct {
	*mock.Call
}

MockQuerier_DeleteServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteServiceAccount'

func (*MockQuerier_DeleteServiceAccount_Call) Return 

func (_c *MockQuerier_DeleteServiceAccount_Call) Return(_a0 error) *MockQuerier_DeleteServiceAccount_Call

func (*MockQuerier_DeleteServiceAccount_Call) Run 

func (_c *MockQuerier_DeleteServiceAccount_Call) Run(run func(ctx context.Context, id uuid.UUID)) *MockQuerier_DeleteServiceAccount_Call

func (*MockQuerier_DeleteServiceAccount_Call) RunAndReturn 

func (_c *MockQuerier_DeleteServiceAccount_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockQuerier_DeleteServiceAccount_Call

type MockQuerier_DeleteSession_Call 

type MockQuerier_DeleteSession_Call struct {
	*mock.Call
}

MockQuerier_DeleteSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSession'

func (*MockQuerier_DeleteSession_Call) Return 

func (_c *MockQuerier_DeleteSession_Call) Return(_a0 error) *MockQuerier_DeleteSession_Call

func (*MockQuerier_DeleteSession_Call) Run 

func (_c *MockQuerier_DeleteSession_Call) Run(run func(ctx context.Context, id uuid.UUID)) *MockQuerier_DeleteSession_Call

func (*MockQuerier_DeleteSession_Call) RunAndReturn 

func (_c *MockQuerier_DeleteSession_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockQuerier_DeleteSession_Call

type MockQuerier_DeleteTeam_Call 

type MockQuerier_DeleteTeam_Call struct {
	*mock.Call
}

MockQuerier_DeleteTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTeam'

func (*MockQuerier_DeleteTeam_Call) Return 

func (_c *MockQuerier_DeleteTeam_Call) Return(_a0 error) *MockQuerier_DeleteTeam_Call

func (*MockQuerier_DeleteTeam_Call) Run 

func (_c *MockQuerier_DeleteTeam_Call) Run(run func(ctx context.Context, argSlug slug.Slug)) *MockQuerier_DeleteTeam_Call

func (*MockQuerier_DeleteTeam_Call) RunAndReturn 

func (_c *MockQuerier_DeleteTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) error) *MockQuerier_DeleteTeam_Call

type MockQuerier_DeleteUser_Call 

type MockQuerier_DeleteUser_Call struct {
	*mock.Call
}

MockQuerier_DeleteUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUser'

func (*MockQuerier_DeleteUser_Call) Return 

func (_c *MockQuerier_DeleteUser_Call) Return(_a0 error) *MockQuerier_DeleteUser_Call

func (*MockQuerier_DeleteUser_Call) Run 

func (_c *MockQuerier_DeleteUser_Call) Run(run func(ctx context.Context, id uuid.UUID)) *MockQuerier_DeleteUser_Call

func (*MockQuerier_DeleteUser_Call) RunAndReturn 

func (_c *MockQuerier_DeleteUser_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockQuerier_DeleteUser_Call

type MockQuerier_DisableReconciler_Call 

type MockQuerier_DisableReconciler_Call struct {
	*mock.Call
}

MockQuerier_DisableReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableReconciler'

func (*MockQuerier_DisableReconciler_Call) Return 

func (_c *MockQuerier_DisableReconciler_Call) Return(_a0 *Reconciler, _a1 error) *MockQuerier_DisableReconciler_Call

func (*MockQuerier_DisableReconciler_Call) Run 

func (_c *MockQuerier_DisableReconciler_Call) Run(run func(ctx context.Context, name string)) *MockQuerier_DisableReconciler_Call

func (*MockQuerier_DisableReconciler_Call) RunAndReturn 

func (_c *MockQuerier_DisableReconciler_Call) RunAndReturn(run func(context.Context, string) (*Reconciler, error)) *MockQuerier_DisableReconciler_Call

type MockQuerier_EnableReconciler_Call 

type MockQuerier_EnableReconciler_Call struct {
	*mock.Call
}

MockQuerier_EnableReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableReconciler'

func (*MockQuerier_EnableReconciler_Call) Return 

func (_c *MockQuerier_EnableReconciler_Call) Return(_a0 *Reconciler, _a1 error) *MockQuerier_EnableReconciler_Call

func (*MockQuerier_EnableReconciler_Call) Run 

func (_c *MockQuerier_EnableReconciler_Call) Run(run func(ctx context.Context, name string)) *MockQuerier_EnableReconciler_Call

func (*MockQuerier_EnableReconciler_Call) RunAndReturn 

func (_c *MockQuerier_EnableReconciler_Call) RunAndReturn(run func(context.Context, string) (*Reconciler, error)) *MockQuerier_EnableReconciler_Call

type MockQuerier_Expecter 

type MockQuerier_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockQuerier_Expecter) AddReconcilerOptOut 

func (_e *MockQuerier_Expecter) AddReconcilerOptOut(ctx interface{}, arg interface{}) *MockQuerier_AddReconcilerOptOut_Call

AddReconcilerOptOut is a helper method to define mock.On call

  • ctx context.Context
  • arg AddReconcilerOptOutParams

func (*MockQuerier_Expecter) AssignGlobalRoleToServiceAccount 

func (_e *MockQuerier_Expecter) AssignGlobalRoleToServiceAccount(ctx interface{}, arg interface{}) *MockQuerier_AssignGlobalRoleToServiceAccount_Call

AssignGlobalRoleToServiceAccount is a helper method to define mock.On call

  • ctx context.Context
  • arg AssignGlobalRoleToServiceAccountParams

func (*MockQuerier_Expecter) AssignGlobalRoleToUser 

func (_e *MockQuerier_Expecter) AssignGlobalRoleToUser(ctx interface{}, arg interface{}) *MockQuerier_AssignGlobalRoleToUser_Call

AssignGlobalRoleToUser is a helper method to define mock.On call

  • ctx context.Context
  • arg AssignGlobalRoleToUserParams

func (*MockQuerier_Expecter) AssignTeamRoleToServiceAccount 

func (_e *MockQuerier_Expecter) AssignTeamRoleToServiceAccount(ctx interface{}, arg interface{}) *MockQuerier_AssignTeamRoleToServiceAccount_Call

AssignTeamRoleToServiceAccount is a helper method to define mock.On call

  • ctx context.Context
  • arg AssignTeamRoleToServiceAccountParams

func (*MockQuerier_Expecter) AssignTeamRoleToUser 

func (_e *MockQuerier_Expecter) AssignTeamRoleToUser(ctx interface{}, arg interface{}) *MockQuerier_AssignTeamRoleToUser_Call

AssignTeamRoleToUser is a helper method to define mock.On call

  • ctx context.Context
  • arg AssignTeamRoleToUserParams

func (*MockQuerier_Expecter) AverageResourceUtilizationForTeam 

func (_e *MockQuerier_Expecter) AverageResourceUtilizationForTeam(ctx interface{}, arg interface{}) *MockQuerier_AverageResourceUtilizationForTeam_Call

AverageResourceUtilizationForTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg AverageResourceUtilizationForTeamParams

func (*MockQuerier_Expecter) ClearReconcilerErrorsForTeam 

func (_e *MockQuerier_Expecter) ClearReconcilerErrorsForTeam(ctx interface{}, arg interface{}) *MockQuerier_ClearReconcilerErrorsForTeam_Call

ClearReconcilerErrorsForTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg ClearReconcilerErrorsForTeamParams

func (*MockQuerier_Expecter) ConfigureReconciler 

func (_e *MockQuerier_Expecter) ConfigureReconciler(ctx interface{}, arg interface{}) *MockQuerier_ConfigureReconciler_Call

ConfigureReconciler is a helper method to define mock.On call

  • ctx context.Context
  • arg ConfigureReconcilerParams

func (*MockQuerier_Expecter) ConfirmTeamDeleteKey 

func (_e *MockQuerier_Expecter) ConfirmTeamDeleteKey(ctx interface{}, key interface{}) *MockQuerier_ConfirmTeamDeleteKey_Call

ConfirmTeamDeleteKey is a helper method to define mock.On call

  • ctx context.Context
  • key uuid.UUID

func (*MockQuerier_Expecter) CostForSqlInstance 

func (_e *MockQuerier_Expecter) CostForSqlInstance(ctx interface{}, arg interface{}) *MockQuerier_CostForSqlInstance_Call

CostForSqlInstance is a helper method to define mock.On call

  • ctx context.Context
  • arg CostForSqlInstanceParams

func (*MockQuerier_Expecter) CostUpsert 

func (_e *MockQuerier_Expecter) CostUpsert(ctx interface{}, arg interface{}) *MockQuerier_CostUpsert_Call

CostUpsert is a helper method to define mock.On call

  • ctx context.Context
  • arg []CostUpsertParams

func (*MockQuerier_Expecter) CreateAPIKey 

func (_e *MockQuerier_Expecter) CreateAPIKey(ctx interface{}, arg interface{}) *MockQuerier_CreateAPIKey_Call

CreateAPIKey is a helper method to define mock.On call

  • ctx context.Context
  • arg CreateAPIKeyParams

func (*MockQuerier_Expecter) CreateAuditLog 

func (_e *MockQuerier_Expecter) CreateAuditLog(ctx interface{}, arg interface{}) *MockQuerier_CreateAuditLog_Call

CreateAuditLog is a helper method to define mock.On call

  • ctx context.Context
  • arg CreateAuditLogParams

func (*MockQuerier_Expecter) CreateDependencytrackProject 

func (_e *MockQuerier_Expecter) CreateDependencytrackProject(ctx interface{}, arg interface{}) *MockQuerier_CreateDependencytrackProject_Call

CreateDependencytrackProject is a helper method to define mock.On call

  • ctx context.Context
  • arg CreateDependencytrackProjectParams

func (*MockQuerier_Expecter) CreateRepositoryAuthorization 

func (_e *MockQuerier_Expecter) CreateRepositoryAuthorization(ctx interface{}, arg interface{}) *MockQuerier_CreateRepositoryAuthorization_Call

CreateRepositoryAuthorization is a helper method to define mock.On call

  • ctx context.Context
  • arg CreateRepositoryAuthorizationParams

func (*MockQuerier_Expecter) CreateServiceAccount 

func (_e *MockQuerier_Expecter) CreateServiceAccount(ctx interface{}, name interface{}) *MockQuerier_CreateServiceAccount_Call

CreateServiceAccount is a helper method to define mock.On call

  • ctx context.Context
  • name string

func (*MockQuerier_Expecter) CreateSession 

func (_e *MockQuerier_Expecter) CreateSession(ctx interface{}, arg interface{}) *MockQuerier_CreateSession_Call

CreateSession is a helper method to define mock.On call

  • ctx context.Context
  • arg CreateSessionParams

func (*MockQuerier_Expecter) CreateTeam 

func (_e *MockQuerier_Expecter) CreateTeam(ctx interface{}, arg interface{}) *MockQuerier_CreateTeam_Call

CreateTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg CreateTeamParams

func (*MockQuerier_Expecter) CreateTeamDeleteKey 

func (_e *MockQuerier_Expecter) CreateTeamDeleteKey(ctx interface{}, arg interface{}) *MockQuerier_CreateTeamDeleteKey_Call

CreateTeamDeleteKey is a helper method to define mock.On call

  • ctx context.Context
  • arg CreateTeamDeleteKeyParams

func (*MockQuerier_Expecter) CreateUser 

func (_e *MockQuerier_Expecter) CreateUser(ctx interface{}, arg interface{}) *MockQuerier_CreateUser_Call

CreateUser is a helper method to define mock.On call

  • ctx context.Context
  • arg CreateUserParams

func (*MockQuerier_Expecter) CurrentSqlInstancesCostForTeam 

func (_e *MockQuerier_Expecter) CurrentSqlInstancesCostForTeam(ctx interface{}, arg interface{}) *MockQuerier_CurrentSqlInstancesCostForTeam_Call

CurrentSqlInstancesCostForTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg CurrentSqlInstancesCostForTeamParams

func (*MockQuerier_Expecter) DailyCostForApp 

func (_e *MockQuerier_Expecter) DailyCostForApp(ctx interface{}, arg interface{}) *MockQuerier_DailyCostForApp_Call

DailyCostForApp is a helper method to define mock.On call

  • ctx context.Context
  • arg DailyCostForAppParams

func (*MockQuerier_Expecter) DailyCostForTeam 

func (_e *MockQuerier_Expecter) DailyCostForTeam(ctx interface{}, arg interface{}) *MockQuerier_DailyCostForTeam_Call

DailyCostForTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg DailyCostForTeamParams

func (*MockQuerier_Expecter) DailyEnvCostForTeam 

func (_e *MockQuerier_Expecter) DailyEnvCostForTeam(ctx interface{}, arg interface{}) *MockQuerier_DailyEnvCostForTeam_Call

DailyEnvCostForTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg DailyEnvCostForTeamParams

func (*MockQuerier_Expecter) DailyVulnerabilityForTeam 

func (_e *MockQuerier_Expecter) DailyVulnerabilityForTeam(ctx interface{}, arg interface{}) *MockQuerier_DailyVulnerabilityForTeam_Call

DailyVulnerabilityForTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg DailyVulnerabilityForTeamParams

func (*MockQuerier_Expecter) DailyVulnerabilityForTeamAndEnvironment 

func (_e *MockQuerier_Expecter) DailyVulnerabilityForTeamAndEnvironment(ctx interface{}, arg interface{}) *MockQuerier_DailyVulnerabilityForTeamAndEnvironment_Call

DailyVulnerabilityForTeamAndEnvironment is a helper method to define mock.On call

  • ctx context.Context
  • arg DailyVulnerabilityForTeamAndEnvironmentParams

func (*MockQuerier_Expecter) DeleteAllEnvironments 

func (_e *MockQuerier_Expecter) DeleteAllEnvironments(ctx interface{}) *MockQuerier_DeleteAllEnvironments_Call

DeleteAllEnvironments is a helper method to define mock.On call

  • ctx context.Context

func (*MockQuerier_Expecter) DeleteReconcilerConfig 

func (_e *MockQuerier_Expecter) DeleteReconcilerConfig(ctx interface{}, arg interface{}) *MockQuerier_DeleteReconcilerConfig_Call

DeleteReconcilerConfig is a helper method to define mock.On call

  • ctx context.Context
  • arg DeleteReconcilerConfigParams

func (*MockQuerier_Expecter) DeleteReconcilerStateForTeam 

func (_e *MockQuerier_Expecter) DeleteReconcilerStateForTeam(ctx interface{}, arg interface{}) *MockQuerier_DeleteReconcilerStateForTeam_Call

DeleteReconcilerStateForTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg DeleteReconcilerStateForTeamParams

func (*MockQuerier_Expecter) DeleteServiceAccount 

func (_e *MockQuerier_Expecter) DeleteServiceAccount(ctx interface{}, id interface{}) *MockQuerier_DeleteServiceAccount_Call

DeleteServiceAccount is a helper method to define mock.On call

  • ctx context.Context
  • id uuid.UUID

func (*MockQuerier_Expecter) DeleteSession 

func (_e *MockQuerier_Expecter) DeleteSession(ctx interface{}, id interface{}) *MockQuerier_DeleteSession_Call

DeleteSession is a helper method to define mock.On call

  • ctx context.Context
  • id uuid.UUID

func (*MockQuerier_Expecter) DeleteTeam 

func (_e *MockQuerier_Expecter) DeleteTeam(ctx interface{}, argSlug interface{}) *MockQuerier_DeleteTeam_Call

DeleteTeam is a helper method to define mock.On call

  • ctx context.Context
  • argSlug slug.Slug

func (*MockQuerier_Expecter) DeleteUser 

func (_e *MockQuerier_Expecter) DeleteUser(ctx interface{}, id interface{}) *MockQuerier_DeleteUser_Call

DeleteUser is a helper method to define mock.On call

  • ctx context.Context
  • id uuid.UUID

func (*MockQuerier_Expecter) DisableReconciler 

func (_e *MockQuerier_Expecter) DisableReconciler(ctx interface{}, name interface{}) *MockQuerier_DisableReconciler_Call

DisableReconciler is a helper method to define mock.On call

  • ctx context.Context
  • name string

func (*MockQuerier_Expecter) EnableReconciler 

func (_e *MockQuerier_Expecter) EnableReconciler(ctx interface{}, name interface{}) *MockQuerier_EnableReconciler_Call

EnableReconciler is a helper method to define mock.On call

  • ctx context.Context
  • name string

func (*MockQuerier_Expecter) GetActiveTeamBySlug 

func (_e *MockQuerier_Expecter) GetActiveTeamBySlug(ctx interface{}, argSlug interface{}) *MockQuerier_GetActiveTeamBySlug_Call

GetActiveTeamBySlug is a helper method to define mock.On call

  • ctx context.Context
  • argSlug slug.Slug

func (*MockQuerier_Expecter) GetActiveTeams 

func (_e *MockQuerier_Expecter) GetActiveTeams(ctx interface{}) *MockQuerier_GetActiveTeams_Call

GetActiveTeams is a helper method to define mock.On call

  • ctx context.Context

func (*MockQuerier_Expecter) GetAllTeamMembers 

func (_e *MockQuerier_Expecter) GetAllTeamMembers(ctx interface{}, teamSlug interface{}) *MockQuerier_GetAllTeamMembers_Call

GetAllTeamMembers is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug *slug.Slug

func (*MockQuerier_Expecter) GetAllTeamSlugs 

func (_e *MockQuerier_Expecter) GetAllTeamSlugs(ctx interface{}) *MockQuerier_GetAllTeamSlugs_Call

GetAllTeamSlugs is a helper method to define mock.On call

  • ctx context.Context

func (*MockQuerier_Expecter) GetAllUserRoles 

func (_e *MockQuerier_Expecter) GetAllUserRoles(ctx interface{}) *MockQuerier_GetAllUserRoles_Call

GetAllUserRoles is a helper method to define mock.On call

  • ctx context.Context

func (*MockQuerier_Expecter) GetAuditLogsForCorrelationID 

func (_e *MockQuerier_Expecter) GetAuditLogsForCorrelationID(ctx interface{}, arg interface{}) *MockQuerier_GetAuditLogsForCorrelationID_Call

GetAuditLogsForCorrelationID is a helper method to define mock.On call

  • ctx context.Context
  • arg GetAuditLogsForCorrelationIDParams

func (*MockQuerier_Expecter) GetAuditLogsForCorrelationIDCount 

func (_e *MockQuerier_Expecter) GetAuditLogsForCorrelationIDCount(ctx interface{}, correlationID interface{}) *MockQuerier_GetAuditLogsForCorrelationIDCount_Call

GetAuditLogsForCorrelationIDCount is a helper method to define mock.On call

  • ctx context.Context
  • correlationID uuid.UUID

func (*MockQuerier_Expecter) GetAuditLogsForReconciler 

func (_e *MockQuerier_Expecter) GetAuditLogsForReconciler(ctx interface{}, arg interface{}) *MockQuerier_GetAuditLogsForReconciler_Call

GetAuditLogsForReconciler is a helper method to define mock.On call

  • ctx context.Context
  • arg GetAuditLogsForReconcilerParams

func (*MockQuerier_Expecter) GetAuditLogsForReconcilerCount 

func (_e *MockQuerier_Expecter) GetAuditLogsForReconcilerCount(ctx interface{}, targetIdentifier interface{}) *MockQuerier_GetAuditLogsForReconcilerCount_Call

GetAuditLogsForReconcilerCount is a helper method to define mock.On call

  • ctx context.Context
  • targetIdentifier string

func (*MockQuerier_Expecter) GetAuditLogsForTeam 

func (_e *MockQuerier_Expecter) GetAuditLogsForTeam(ctx interface{}, arg interface{}) *MockQuerier_GetAuditLogsForTeam_Call

GetAuditLogsForTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg GetAuditLogsForTeamParams

func (*MockQuerier_Expecter) GetAuditLogsForTeamCount 

func (_e *MockQuerier_Expecter) GetAuditLogsForTeamCount(ctx interface{}, targetIdentifier interface{}) *MockQuerier_GetAuditLogsForTeamCount_Call

GetAuditLogsForTeamCount is a helper method to define mock.On call

  • ctx context.Context
  • targetIdentifier string

func (*MockQuerier_Expecter) GetEnabledReconcilers 

func (_e *MockQuerier_Expecter) GetEnabledReconcilers(ctx interface{}) *MockQuerier_GetEnabledReconcilers_Call

GetEnabledReconcilers is a helper method to define mock.On call

  • ctx context.Context

func (*MockQuerier_Expecter) GetReconciler 

func (_e *MockQuerier_Expecter) GetReconciler(ctx interface{}, name interface{}) *MockQuerier_GetReconciler_Call

GetReconciler is a helper method to define mock.On call

  • ctx context.Context
  • name string

func (*MockQuerier_Expecter) GetReconcilerConfig 

func (_e *MockQuerier_Expecter) GetReconcilerConfig(ctx interface{}, arg interface{}) *MockQuerier_GetReconcilerConfig_Call

GetReconcilerConfig is a helper method to define mock.On call

  • ctx context.Context
  • arg GetReconcilerConfigParams

func (*MockQuerier_Expecter) GetReconcilerState 

func (_e *MockQuerier_Expecter) GetReconcilerState(ctx interface{}, reconcilerName interface{}) *MockQuerier_GetReconcilerState_Call

GetReconcilerState is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string

func (*MockQuerier_Expecter) GetReconcilerStateForTeam 

func (_e *MockQuerier_Expecter) GetReconcilerStateForTeam(ctx interface{}, arg interface{}) *MockQuerier_GetReconcilerStateForTeam_Call

GetReconcilerStateForTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg GetReconcilerStateForTeamParams

func (*MockQuerier_Expecter) GetReconcilers 

func (_e *MockQuerier_Expecter) GetReconcilers(ctx interface{}, arg interface{}) *MockQuerier_GetReconcilers_Call

GetReconcilers is a helper method to define mock.On call

  • ctx context.Context
  • arg GetReconcilersParams

func (*MockQuerier_Expecter) GetReconcilersCount 

func (_e *MockQuerier_Expecter) GetReconcilersCount(ctx interface{}) *MockQuerier_GetReconcilersCount_Call

GetReconcilersCount is a helper method to define mock.On call

  • ctx context.Context

func (*MockQuerier_Expecter) GetRepositoryAuthorizations 

func (_e *MockQuerier_Expecter) GetRepositoryAuthorizations(ctx interface{}, arg interface{}) *MockQuerier_GetRepositoryAuthorizations_Call

GetRepositoryAuthorizations is a helper method to define mock.On call

  • ctx context.Context
  • arg GetRepositoryAuthorizationsParams

func (*MockQuerier_Expecter) GetServiceAccountByApiKey 

func (_e *MockQuerier_Expecter) GetServiceAccountByApiKey(ctx interface{}, apiKey interface{}) *MockQuerier_GetServiceAccountByApiKey_Call

GetServiceAccountByApiKey is a helper method to define mock.On call

  • ctx context.Context
  • apiKey string

func (*MockQuerier_Expecter) GetServiceAccountByName 

func (_e *MockQuerier_Expecter) GetServiceAccountByName(ctx interface{}, name interface{}) *MockQuerier_GetServiceAccountByName_Call

GetServiceAccountByName is a helper method to define mock.On call

  • ctx context.Context
  • name string

func (*MockQuerier_Expecter) GetServiceAccountRoles 

func (_e *MockQuerier_Expecter) GetServiceAccountRoles(ctx interface{}, serviceAccountID interface{}) *MockQuerier_GetServiceAccountRoles_Call

GetServiceAccountRoles is a helper method to define mock.On call

  • ctx context.Context
  • serviceAccountID uuid.UUID

func (*MockQuerier_Expecter) GetServiceAccounts 

func (_e *MockQuerier_Expecter) GetServiceAccounts(ctx interface{}) *MockQuerier_GetServiceAccounts_Call

GetServiceAccounts is a helper method to define mock.On call

  • ctx context.Context

func (*MockQuerier_Expecter) GetServiceAccountsByIDs 

func (_e *MockQuerier_Expecter) GetServiceAccountsByIDs(ctx interface{}, ids interface{}) *MockQuerier_GetServiceAccountsByIDs_Call

GetServiceAccountsByIDs is a helper method to define mock.On call

  • ctx context.Context
  • ids []uuid.UUID

func (*MockQuerier_Expecter) GetSessionByID 

func (_e *MockQuerier_Expecter) GetSessionByID(ctx interface{}, id interface{}) *MockQuerier_GetSessionByID_Call

GetSessionByID is a helper method to define mock.On call

  • ctx context.Context
  • id uuid.UUID

func (*MockQuerier_Expecter) GetTeamBySlug 

func (_e *MockQuerier_Expecter) GetTeamBySlug(ctx interface{}, argSlug interface{}) *MockQuerier_GetTeamBySlug_Call

GetTeamBySlug is a helper method to define mock.On call

  • ctx context.Context
  • argSlug slug.Slug

func (*MockQuerier_Expecter) GetTeamBySlugs 

func (_e *MockQuerier_Expecter) GetTeamBySlugs(ctx interface{}, slugs interface{}) *MockQuerier_GetTeamBySlugs_Call

GetTeamBySlugs is a helper method to define mock.On call

  • ctx context.Context
  • slugs []slug.Slug

func (*MockQuerier_Expecter) GetTeamDeleteKey 

func (_e *MockQuerier_Expecter) GetTeamDeleteKey(ctx interface{}, key interface{}) *MockQuerier_GetTeamDeleteKey_Call

GetTeamDeleteKey is a helper method to define mock.On call

  • ctx context.Context
  • key uuid.UUID

func (*MockQuerier_Expecter) GetTeamEnvironments 

func (_e *MockQuerier_Expecter) GetTeamEnvironments(ctx interface{}, arg interface{}) *MockQuerier_GetTeamEnvironments_Call

GetTeamEnvironments is a helper method to define mock.On call

  • ctx context.Context
  • arg GetTeamEnvironmentsParams

func (*MockQuerier_Expecter) GetTeamEnvironmentsBySlugsAndEnvNames 

func (_e *MockQuerier_Expecter) GetTeamEnvironmentsBySlugsAndEnvNames(ctx interface{}, arg interface{}) *MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call

GetTeamEnvironmentsBySlugsAndEnvNames is a helper method to define mock.On call

  • ctx context.Context
  • arg GetTeamEnvironmentsBySlugsAndEnvNamesParams

func (*MockQuerier_Expecter) GetTeamEnvironmentsCount 

func (_e *MockQuerier_Expecter) GetTeamEnvironmentsCount(ctx interface{}, teamSlug interface{}) *MockQuerier_GetTeamEnvironmentsCount_Call

GetTeamEnvironmentsCount is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

func (*MockQuerier_Expecter) GetTeamMember 

func (_e *MockQuerier_Expecter) GetTeamMember(ctx interface{}, arg interface{}) *MockQuerier_GetTeamMember_Call

GetTeamMember is a helper method to define mock.On call

  • ctx context.Context
  • arg GetTeamMemberParams

func (*MockQuerier_Expecter) GetTeamMemberOptOuts 

func (_e *MockQuerier_Expecter) GetTeamMemberOptOuts(ctx interface{}, arg interface{}) *MockQuerier_GetTeamMemberOptOuts_Call

GetTeamMemberOptOuts is a helper method to define mock.On call

  • ctx context.Context
  • arg GetTeamMemberOptOutsParams

func (*MockQuerier_Expecter) GetTeamMembers 

func (_e *MockQuerier_Expecter) GetTeamMembers(ctx interface{}, arg interface{}) *MockQuerier_GetTeamMembers_Call

GetTeamMembers is a helper method to define mock.On call

  • ctx context.Context
  • arg GetTeamMembersParams

func (*MockQuerier_Expecter) GetTeamMembersCount 

func (_e *MockQuerier_Expecter) GetTeamMembersCount(ctx interface{}, teamSlug interface{}) *MockQuerier_GetTeamMembersCount_Call

GetTeamMembersCount is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug *slug.Slug

func (*MockQuerier_Expecter) GetTeamMembersForReconciler 

func (_e *MockQuerier_Expecter) GetTeamMembersForReconciler(ctx interface{}, arg interface{}) *MockQuerier_GetTeamMembersForReconciler_Call

GetTeamMembersForReconciler is a helper method to define mock.On call

  • ctx context.Context
  • arg GetTeamMembersForReconcilerParams

func (*MockQuerier_Expecter) GetTeamReconcilerErrors 

func (_e *MockQuerier_Expecter) GetTeamReconcilerErrors(ctx interface{}, teamSlug interface{}) *MockQuerier_GetTeamReconcilerErrors_Call

GetTeamReconcilerErrors is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

func (*MockQuerier_Expecter) GetTeams 

func (_e *MockQuerier_Expecter) GetTeams(ctx interface{}, arg interface{}) *MockQuerier_GetTeams_Call

GetTeams is a helper method to define mock.On call

  • ctx context.Context
  • arg GetTeamsParams

func (*MockQuerier_Expecter) GetTeamsCount 

func (_e *MockQuerier_Expecter) GetTeamsCount(ctx interface{}) *MockQuerier_GetTeamsCount_Call

GetTeamsCount is a helper method to define mock.On call

  • ctx context.Context

func (*MockQuerier_Expecter) GetUserByEmail 

func (_e *MockQuerier_Expecter) GetUserByEmail(ctx interface{}, email interface{}) *MockQuerier_GetUserByEmail_Call

GetUserByEmail is a helper method to define mock.On call

  • ctx context.Context
  • email string

func (*MockQuerier_Expecter) GetUserByExternalID 

func (_e *MockQuerier_Expecter) GetUserByExternalID(ctx interface{}, externalID interface{}) *MockQuerier_GetUserByExternalID_Call

GetUserByExternalID is a helper method to define mock.On call

  • ctx context.Context
  • externalID string

func (*MockQuerier_Expecter) GetUserByID 

func (_e *MockQuerier_Expecter) GetUserByID(ctx interface{}, id interface{}) *MockQuerier_GetUserByID_Call

GetUserByID is a helper method to define mock.On call

  • ctx context.Context
  • id uuid.UUID

func (*MockQuerier_Expecter) GetUserRoles 

func (_e *MockQuerier_Expecter) GetUserRoles(ctx interface{}, userID interface{}) *MockQuerier_GetUserRoles_Call

GetUserRoles is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID

func (*MockQuerier_Expecter) GetUserRolesForUsers 

func (_e *MockQuerier_Expecter) GetUserRolesForUsers(ctx interface{}, userIds interface{}) *MockQuerier_GetUserRolesForUsers_Call

GetUserRolesForUsers is a helper method to define mock.On call

  • ctx context.Context
  • userIds []uuid.UUID

func (*MockQuerier_Expecter) GetUserTeams 

func (_e *MockQuerier_Expecter) GetUserTeams(ctx interface{}, userID interface{}) *MockQuerier_GetUserTeams_Call

GetUserTeams is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID

func (*MockQuerier_Expecter) GetUserTeamsCount 

func (_e *MockQuerier_Expecter) GetUserTeamsCount(ctx interface{}, userID interface{}) *MockQuerier_GetUserTeamsCount_Call

GetUserTeamsCount is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID

func (*MockQuerier_Expecter) GetUserTeamsPaginated 

func (_e *MockQuerier_Expecter) GetUserTeamsPaginated(ctx interface{}, arg interface{}) *MockQuerier_GetUserTeamsPaginated_Call

GetUserTeamsPaginated is a helper method to define mock.On call

  • ctx context.Context
  • arg GetUserTeamsPaginatedParams

func (*MockQuerier_Expecter) GetUsers 

func (_e *MockQuerier_Expecter) GetUsers(ctx interface{}, arg interface{}) *MockQuerier_GetUsers_Call

GetUsers is a helper method to define mock.On call

  • ctx context.Context
  • arg GetUsersParams

func (*MockQuerier_Expecter) GetUsersByIDs 

func (_e *MockQuerier_Expecter) GetUsersByIDs(ctx interface{}, ids interface{}) *MockQuerier_GetUsersByIDs_Call

GetUsersByIDs is a helper method to define mock.On call

  • ctx context.Context
  • ids []uuid.UUID

func (*MockQuerier_Expecter) GetUsersCount 

func (_e *MockQuerier_Expecter) GetUsersCount(ctx interface{}) *MockQuerier_GetUsersCount_Call

GetUsersCount is a helper method to define mock.On call

  • ctx context.Context

func (*MockQuerier_Expecter) GetUsersWithGloballyAssignedRole 

func (_e *MockQuerier_Expecter) GetUsersWithGloballyAssignedRole(ctx interface{}, roleName interface{}) *MockQuerier_GetUsersWithGloballyAssignedRole_Call

GetUsersWithGloballyAssignedRole is a helper method to define mock.On call

  • ctx context.Context
  • roleName RoleName

func (*MockQuerier_Expecter) InsertEnvironment 

func (_e *MockQuerier_Expecter) InsertEnvironment(ctx interface{}, arg interface{}) *MockQuerier_InsertEnvironment_Call

InsertEnvironment is a helper method to define mock.On call

  • ctx context.Context
  • arg InsertEnvironmentParams

func (*MockQuerier_Expecter) LastCostDate 

func (_e *MockQuerier_Expecter) LastCostDate(ctx interface{}) *MockQuerier_LastCostDate_Call

LastCostDate is a helper method to define mock.On call

  • ctx context.Context

func (*MockQuerier_Expecter) ListRepositoriesByAuthorization 

func (_e *MockQuerier_Expecter) ListRepositoriesByAuthorization(ctx interface{}, arg interface{}) *MockQuerier_ListRepositoriesByAuthorization_Call

ListRepositoriesByAuthorization is a helper method to define mock.On call

  • ctx context.Context
  • arg ListRepositoriesByAuthorizationParams

func (*MockQuerier_Expecter) MaxResourceUtilizationDate 

func (_e *MockQuerier_Expecter) MaxResourceUtilizationDate(ctx interface{}) *MockQuerier_MaxResourceUtilizationDate_Call

MaxResourceUtilizationDate is a helper method to define mock.On call

  • ctx context.Context

func (*MockQuerier_Expecter) MonthlyCostForApp 

func (_e *MockQuerier_Expecter) MonthlyCostForApp(ctx interface{}, arg interface{}) *MockQuerier_MonthlyCostForApp_Call

MonthlyCostForApp is a helper method to define mock.On call

  • ctx context.Context
  • arg MonthlyCostForAppParams

func (*MockQuerier_Expecter) MonthlyCostForTeam 

func (_e *MockQuerier_Expecter) MonthlyCostForTeam(ctx interface{}, teamSlug interface{}) *MockQuerier_MonthlyCostForTeam_Call

MonthlyCostForTeam is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

func (*MockQuerier_Expecter) RefreshCostMonthlyTeam 

func (_e *MockQuerier_Expecter) RefreshCostMonthlyTeam(ctx interface{}) *MockQuerier_RefreshCostMonthlyTeam_Call

RefreshCostMonthlyTeam is a helper method to define mock.On call

  • ctx context.Context

func (*MockQuerier_Expecter) RefreshResourceTeamRange 

func (_e *MockQuerier_Expecter) RefreshResourceTeamRange(ctx interface{}) *MockQuerier_RefreshResourceTeamRange_Call

RefreshResourceTeamRange is a helper method to define mock.On call

  • ctx context.Context

func (*MockQuerier_Expecter) RemoveAllServiceAccountRoles 

func (_e *MockQuerier_Expecter) RemoveAllServiceAccountRoles(ctx interface{}, serviceAccountID interface{}) *MockQuerier_RemoveAllServiceAccountRoles_Call

RemoveAllServiceAccountRoles is a helper method to define mock.On call

  • ctx context.Context
  • serviceAccountID uuid.UUID

func (*MockQuerier_Expecter) RemoveApiKeysFromServiceAccount 

func (_e *MockQuerier_Expecter) RemoveApiKeysFromServiceAccount(ctx interface{}, serviceAccountID interface{}) *MockQuerier_RemoveApiKeysFromServiceAccount_Call

RemoveApiKeysFromServiceAccount is a helper method to define mock.On call

  • ctx context.Context
  • serviceAccountID uuid.UUID

func (*MockQuerier_Expecter) RemoveReconcilerOptOut 

func (_e *MockQuerier_Expecter) RemoveReconcilerOptOut(ctx interface{}, arg interface{}) *MockQuerier_RemoveReconcilerOptOut_Call

RemoveReconcilerOptOut is a helper method to define mock.On call

  • ctx context.Context
  • arg RemoveReconcilerOptOutParams

func (*MockQuerier_Expecter) RemoveRepositoryAuthorization 

func (_e *MockQuerier_Expecter) RemoveRepositoryAuthorization(ctx interface{}, arg interface{}) *MockQuerier_RemoveRepositoryAuthorization_Call

RemoveRepositoryAuthorization is a helper method to define mock.On call

  • ctx context.Context
  • arg RemoveRepositoryAuthorizationParams

func (*MockQuerier_Expecter) RemoveUserFromTeam 

func (_e *MockQuerier_Expecter) RemoveUserFromTeam(ctx interface{}, arg interface{}) *MockQuerier_RemoveUserFromTeam_Call

RemoveUserFromTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg RemoveUserFromTeamParams

func (*MockQuerier_Expecter) ResetReconcilerConfig 

func (_e *MockQuerier_Expecter) ResetReconcilerConfig(ctx interface{}, reconcilerName interface{}) *MockQuerier_ResetReconcilerConfig_Call

ResetReconcilerConfig is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string

func (*MockQuerier_Expecter) ResourceUtilizationForApp 

func (_e *MockQuerier_Expecter) ResourceUtilizationForApp(ctx interface{}, arg interface{}) *MockQuerier_ResourceUtilizationForApp_Call

ResourceUtilizationForApp is a helper method to define mock.On call

  • ctx context.Context
  • arg ResourceUtilizationForAppParams

func (*MockQuerier_Expecter) ResourceUtilizationForTeam 

func (_e *MockQuerier_Expecter) ResourceUtilizationForTeam(ctx interface{}, arg interface{}) *MockQuerier_ResourceUtilizationForTeam_Call

ResourceUtilizationForTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg ResourceUtilizationForTeamParams

func (*MockQuerier_Expecter) ResourceUtilizationOverageForTeam 

func (_e *MockQuerier_Expecter) ResourceUtilizationOverageForTeam(ctx interface{}, arg interface{}) *MockQuerier_ResourceUtilizationOverageForTeam_Call

ResourceUtilizationOverageForTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg ResourceUtilizationOverageForTeamParams

func (*MockQuerier_Expecter) ResourceUtilizationRangeForApp 

func (_e *MockQuerier_Expecter) ResourceUtilizationRangeForApp(ctx interface{}, arg interface{}) *MockQuerier_ResourceUtilizationRangeForApp_Call

ResourceUtilizationRangeForApp is a helper method to define mock.On call

  • ctx context.Context
  • arg ResourceUtilizationRangeForAppParams

func (*MockQuerier_Expecter) ResourceUtilizationRangeForTeam 

func (_e *MockQuerier_Expecter) ResourceUtilizationRangeForTeam(ctx interface{}, teamSlug interface{}) *MockQuerier_ResourceUtilizationRangeForTeam_Call

ResourceUtilizationRangeForTeam is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

func (*MockQuerier_Expecter) ResourceUtilizationUpsert 

func (_e *MockQuerier_Expecter) ResourceUtilizationUpsert(ctx interface{}, arg interface{}) *MockQuerier_ResourceUtilizationUpsert_Call

ResourceUtilizationUpsert is a helper method to define mock.On call

  • ctx context.Context
  • arg []ResourceUtilizationUpsertParams

func (*MockQuerier_Expecter) RevokeGlobalUserRole 

func (_e *MockQuerier_Expecter) RevokeGlobalUserRole(ctx interface{}, arg interface{}) *MockQuerier_RevokeGlobalUserRole_Call

RevokeGlobalUserRole is a helper method to define mock.On call

  • ctx context.Context
  • arg RevokeGlobalUserRoleParams

func (*MockQuerier_Expecter) SetLastSuccessfulSyncForTeam 

func (_e *MockQuerier_Expecter) SetLastSuccessfulSyncForTeam(ctx interface{}, argSlug interface{}) *MockQuerier_SetLastSuccessfulSyncForTeam_Call

SetLastSuccessfulSyncForTeam is a helper method to define mock.On call

  • ctx context.Context
  • argSlug slug.Slug

func (*MockQuerier_Expecter) SetReconcilerErrorForTeam 

func (_e *MockQuerier_Expecter) SetReconcilerErrorForTeam(ctx interface{}, arg interface{}) *MockQuerier_SetReconcilerErrorForTeam_Call

SetReconcilerErrorForTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg SetReconcilerErrorForTeamParams

func (*MockQuerier_Expecter) SetSessionExpires 

func (_e *MockQuerier_Expecter) SetSessionExpires(ctx interface{}, arg interface{}) *MockQuerier_SetSessionExpires_Call

SetSessionExpires is a helper method to define mock.On call

  • ctx context.Context
  • arg SetSessionExpiresParams

func (*MockQuerier_Expecter) SpecificResourceUtilizationForApp 

func (_e *MockQuerier_Expecter) SpecificResourceUtilizationForApp(ctx interface{}, arg interface{}) *MockQuerier_SpecificResourceUtilizationForApp_Call

SpecificResourceUtilizationForApp is a helper method to define mock.On call

  • ctx context.Context
  • arg SpecificResourceUtilizationForAppParams

func (*MockQuerier_Expecter) SpecificResourceUtilizationForTeam 

func (_e *MockQuerier_Expecter) SpecificResourceUtilizationForTeam(ctx interface{}, arg interface{}) *MockQuerier_SpecificResourceUtilizationForTeam_Call

SpecificResourceUtilizationForTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg SpecificResourceUtilizationForTeamParams

func (*MockQuerier_Expecter) TeamExists 

func (_e *MockQuerier_Expecter) TeamExists(ctx interface{}, argSlug interface{}) *MockQuerier_TeamExists_Call

TeamExists is a helper method to define mock.On call

  • ctx context.Context
  • argSlug slug.Slug

func (*MockQuerier_Expecter) UpdateTeam 

func (_e *MockQuerier_Expecter) UpdateTeam(ctx interface{}, arg interface{}) *MockQuerier_UpdateTeam_Call

UpdateTeam is a helper method to define mock.On call

  • ctx context.Context
  • arg UpdateTeamParams

func (*MockQuerier_Expecter) UpdateTeamExternalReferences 

func (_e *MockQuerier_Expecter) UpdateTeamExternalReferences(ctx interface{}, arg interface{}) *MockQuerier_UpdateTeamExternalReferences_Call

UpdateTeamExternalReferences is a helper method to define mock.On call

  • ctx context.Context
  • arg UpdateTeamExternalReferencesParams

func (*MockQuerier_Expecter) UpdateUser 

func (_e *MockQuerier_Expecter) UpdateUser(ctx interface{}, arg interface{}) *MockQuerier_UpdateUser_Call

UpdateUser is a helper method to define mock.On call

  • ctx context.Context
  • arg UpdateUserParams

func (*MockQuerier_Expecter) UpsertReconciler 

func (_e *MockQuerier_Expecter) UpsertReconciler(ctx interface{}, arg interface{}) *MockQuerier_UpsertReconciler_Call

UpsertReconciler is a helper method to define mock.On call

  • ctx context.Context
  • arg UpsertReconcilerParams

func (*MockQuerier_Expecter) UpsertReconcilerConfig 

func (_e *MockQuerier_Expecter) UpsertReconcilerConfig(ctx interface{}, arg interface{}) *MockQuerier_UpsertReconcilerConfig_Call

UpsertReconcilerConfig is a helper method to define mock.On call

  • ctx context.Context
  • arg UpsertReconcilerConfigParams

func (*MockQuerier_Expecter) UpsertReconcilerState 

func (_e *MockQuerier_Expecter) UpsertReconcilerState(ctx interface{}, arg interface{}) *MockQuerier_UpsertReconcilerState_Call

UpsertReconcilerState is a helper method to define mock.On call

  • ctx context.Context
  • arg UpsertReconcilerStateParams

func (*MockQuerier_Expecter) UpsertTeamEnvironment 

func (_e *MockQuerier_Expecter) UpsertTeamEnvironment(ctx interface{}, arg interface{}) *MockQuerier_UpsertTeamEnvironment_Call

UpsertTeamEnvironment is a helper method to define mock.On call

  • ctx context.Context
  • arg UpsertTeamEnvironmentParams

func (*MockQuerier_Expecter) VulnerabilityMetricsDateRangeForTeam 

func (_e *MockQuerier_Expecter) VulnerabilityMetricsDateRangeForTeam(ctx interface{}, teamSlug interface{}) *MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call

VulnerabilityMetricsDateRangeForTeam is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

func (*MockQuerier_Expecter) VulnerabilityMetricsMaxDate 

func (_e *MockQuerier_Expecter) VulnerabilityMetricsMaxDate(ctx interface{}, arg interface{}) *MockQuerier_VulnerabilityMetricsMaxDate_Call

VulnerabilityMetricsMaxDate is a helper method to define mock.On call

  • ctx context.Context
  • arg VulnerabilityMetricsMaxDateParams

func (*MockQuerier_Expecter) VulnerabilityMetricsUpsert 

func (_e *MockQuerier_Expecter) VulnerabilityMetricsUpsert(ctx interface{}, arg interface{}) *MockQuerier_VulnerabilityMetricsUpsert_Call

VulnerabilityMetricsUpsert is a helper method to define mock.On call

  • ctx context.Context
  • arg []VulnerabilityMetricsUpsertParams

type MockQuerier_GetActiveTeamBySlug_Call 

type MockQuerier_GetActiveTeamBySlug_Call struct {
	*mock.Call
}

MockQuerier_GetActiveTeamBySlug_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActiveTeamBySlug'

func (*MockQuerier_GetActiveTeamBySlug_Call) Return 

func (_c *MockQuerier_GetActiveTeamBySlug_Call) Return(_a0 *Team, _a1 error) *MockQuerier_GetActiveTeamBySlug_Call

func (*MockQuerier_GetActiveTeamBySlug_Call) Run 

func (_c *MockQuerier_GetActiveTeamBySlug_Call) Run(run func(ctx context.Context, argSlug slug.Slug)) *MockQuerier_GetActiveTeamBySlug_Call

func (*MockQuerier_GetActiveTeamBySlug_Call) RunAndReturn 

func (_c *MockQuerier_GetActiveTeamBySlug_Call) RunAndReturn(run func(context.Context, slug.Slug) (*Team, error)) *MockQuerier_GetActiveTeamBySlug_Call

type MockQuerier_GetActiveTeams_Call 

type MockQuerier_GetActiveTeams_Call struct {
	*mock.Call
}

MockQuerier_GetActiveTeams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActiveTeams'

func (*MockQuerier_GetActiveTeams_Call) Return 

func (_c *MockQuerier_GetActiveTeams_Call) Return(_a0 []*Team, _a1 error) *MockQuerier_GetActiveTeams_Call

func (*MockQuerier_GetActiveTeams_Call) Run 

func (_c *MockQuerier_GetActiveTeams_Call) Run(run func(ctx context.Context)) *MockQuerier_GetActiveTeams_Call

func (*MockQuerier_GetActiveTeams_Call) RunAndReturn 

func (_c *MockQuerier_GetActiveTeams_Call) RunAndReturn(run func(context.Context) ([]*Team, error)) *MockQuerier_GetActiveTeams_Call

type MockQuerier_GetAllTeamMembers_Call 

type MockQuerier_GetAllTeamMembers_Call struct {
	*mock.Call
}

MockQuerier_GetAllTeamMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllTeamMembers'

func (*MockQuerier_GetAllTeamMembers_Call) Return 

func (_c *MockQuerier_GetAllTeamMembers_Call) Return(_a0 []*User, _a1 error) *MockQuerier_GetAllTeamMembers_Call

func (*MockQuerier_GetAllTeamMembers_Call) Run 

func (_c *MockQuerier_GetAllTeamMembers_Call) Run(run func(ctx context.Context, teamSlug *slug.Slug)) *MockQuerier_GetAllTeamMembers_Call

func (*MockQuerier_GetAllTeamMembers_Call) RunAndReturn 

func (_c *MockQuerier_GetAllTeamMembers_Call) RunAndReturn(run func(context.Context, *slug.Slug) ([]*User, error)) *MockQuerier_GetAllTeamMembers_Call

type MockQuerier_GetAllTeamSlugs_Call 

type MockQuerier_GetAllTeamSlugs_Call struct {
	*mock.Call
}

MockQuerier_GetAllTeamSlugs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllTeamSlugs'

func (*MockQuerier_GetAllTeamSlugs_Call) Return 

func (_c *MockQuerier_GetAllTeamSlugs_Call) Return(_a0 []slug.Slug, _a1 error) *MockQuerier_GetAllTeamSlugs_Call

func (*MockQuerier_GetAllTeamSlugs_Call) Run 

func (_c *MockQuerier_GetAllTeamSlugs_Call) Run(run func(ctx context.Context)) *MockQuerier_GetAllTeamSlugs_Call

func (*MockQuerier_GetAllTeamSlugs_Call) RunAndReturn 

func (_c *MockQuerier_GetAllTeamSlugs_Call) RunAndReturn(run func(context.Context) ([]slug.Slug, error)) *MockQuerier_GetAllTeamSlugs_Call

type MockQuerier_GetAllUserRoles_Call 

type MockQuerier_GetAllUserRoles_Call struct {
	*mock.Call
}

MockQuerier_GetAllUserRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllUserRoles'

func (*MockQuerier_GetAllUserRoles_Call) Return 

func (_c *MockQuerier_GetAllUserRoles_Call) Return(_a0 []*UserRole, _a1 error) *MockQuerier_GetAllUserRoles_Call

func (*MockQuerier_GetAllUserRoles_Call) Run 

func (_c *MockQuerier_GetAllUserRoles_Call) Run(run func(ctx context.Context)) *MockQuerier_GetAllUserRoles_Call

func (*MockQuerier_GetAllUserRoles_Call) RunAndReturn 

func (_c *MockQuerier_GetAllUserRoles_Call) RunAndReturn(run func(context.Context) ([]*UserRole, error)) *MockQuerier_GetAllUserRoles_Call

type MockQuerier_GetAuditLogsForCorrelationIDCount_Call 

type MockQuerier_GetAuditLogsForCorrelationIDCount_Call struct {
	*mock.Call
}

MockQuerier_GetAuditLogsForCorrelationIDCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditLogsForCorrelationIDCount'

func (*MockQuerier_GetAuditLogsForCorrelationIDCount_Call) Return 

func (_c *MockQuerier_GetAuditLogsForCorrelationIDCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetAuditLogsForCorrelationIDCount_Call

func (*MockQuerier_GetAuditLogsForCorrelationIDCount_Call) Run 

func (_c *MockQuerier_GetAuditLogsForCorrelationIDCount_Call) Run(run func(ctx context.Context, correlationID uuid.UUID)) *MockQuerier_GetAuditLogsForCorrelationIDCount_Call

func (*MockQuerier_GetAuditLogsForCorrelationIDCount_Call) RunAndReturn 

func (_c *MockQuerier_GetAuditLogsForCorrelationIDCount_Call) RunAndReturn(run func(context.Context, uuid.UUID) (int64, error)) *MockQuerier_GetAuditLogsForCorrelationIDCount_Call

type MockQuerier_GetAuditLogsForCorrelationID_Call 

type MockQuerier_GetAuditLogsForCorrelationID_Call struct {
	*mock.Call
}

MockQuerier_GetAuditLogsForCorrelationID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditLogsForCorrelationID'

func (*MockQuerier_GetAuditLogsForCorrelationID_Call) Return 

func (_c *MockQuerier_GetAuditLogsForCorrelationID_Call) Return(_a0 []*AuditLog, _a1 error) *MockQuerier_GetAuditLogsForCorrelationID_Call

func (*MockQuerier_GetAuditLogsForCorrelationID_Call) Run 

func (_c *MockQuerier_GetAuditLogsForCorrelationID_Call) Run(run func(ctx context.Context, arg GetAuditLogsForCorrelationIDParams)) *MockQuerier_GetAuditLogsForCorrelationID_Call

func (*MockQuerier_GetAuditLogsForCorrelationID_Call) RunAndReturn 

func (_c *MockQuerier_GetAuditLogsForCorrelationID_Call) RunAndReturn(run func(context.Context, GetAuditLogsForCorrelationIDParams) ([]*AuditLog, error)) *MockQuerier_GetAuditLogsForCorrelationID_Call

type MockQuerier_GetAuditLogsForReconcilerCount_Call 

type MockQuerier_GetAuditLogsForReconcilerCount_Call struct {
	*mock.Call
}

MockQuerier_GetAuditLogsForReconcilerCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditLogsForReconcilerCount'

func (*MockQuerier_GetAuditLogsForReconcilerCount_Call) Return 

func (_c *MockQuerier_GetAuditLogsForReconcilerCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetAuditLogsForReconcilerCount_Call

func (*MockQuerier_GetAuditLogsForReconcilerCount_Call) Run 

func (_c *MockQuerier_GetAuditLogsForReconcilerCount_Call) Run(run func(ctx context.Context, targetIdentifier string)) *MockQuerier_GetAuditLogsForReconcilerCount_Call

func (*MockQuerier_GetAuditLogsForReconcilerCount_Call) RunAndReturn 

func (_c *MockQuerier_GetAuditLogsForReconcilerCount_Call) RunAndReturn(run func(context.Context, string) (int64, error)) *MockQuerier_GetAuditLogsForReconcilerCount_Call

type MockQuerier_GetAuditLogsForReconciler_Call 

type MockQuerier_GetAuditLogsForReconciler_Call struct {
	*mock.Call
}

MockQuerier_GetAuditLogsForReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditLogsForReconciler'

func (*MockQuerier_GetAuditLogsForReconciler_Call) Return 

func (_c *MockQuerier_GetAuditLogsForReconciler_Call) Return(_a0 []*AuditLog, _a1 error) *MockQuerier_GetAuditLogsForReconciler_Call

func (*MockQuerier_GetAuditLogsForReconciler_Call) Run 

func (_c *MockQuerier_GetAuditLogsForReconciler_Call) Run(run func(ctx context.Context, arg GetAuditLogsForReconcilerParams)) *MockQuerier_GetAuditLogsForReconciler_Call

func (*MockQuerier_GetAuditLogsForReconciler_Call) RunAndReturn 

func (_c *MockQuerier_GetAuditLogsForReconciler_Call) RunAndReturn(run func(context.Context, GetAuditLogsForReconcilerParams) ([]*AuditLog, error)) *MockQuerier_GetAuditLogsForReconciler_Call

type MockQuerier_GetAuditLogsForTeamCount_Call 

type MockQuerier_GetAuditLogsForTeamCount_Call struct {
	*mock.Call
}

MockQuerier_GetAuditLogsForTeamCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditLogsForTeamCount'

func (*MockQuerier_GetAuditLogsForTeamCount_Call) Return 

func (_c *MockQuerier_GetAuditLogsForTeamCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetAuditLogsForTeamCount_Call

func (*MockQuerier_GetAuditLogsForTeamCount_Call) Run 

func (_c *MockQuerier_GetAuditLogsForTeamCount_Call) Run(run func(ctx context.Context, targetIdentifier string)) *MockQuerier_GetAuditLogsForTeamCount_Call

func (*MockQuerier_GetAuditLogsForTeamCount_Call) RunAndReturn 

func (_c *MockQuerier_GetAuditLogsForTeamCount_Call) RunAndReturn(run func(context.Context, string) (int64, error)) *MockQuerier_GetAuditLogsForTeamCount_Call

type MockQuerier_GetAuditLogsForTeam_Call 

type MockQuerier_GetAuditLogsForTeam_Call struct {
	*mock.Call
}

MockQuerier_GetAuditLogsForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditLogsForTeam'

func (*MockQuerier_GetAuditLogsForTeam_Call) Return 

func (_c *MockQuerier_GetAuditLogsForTeam_Call) Return(_a0 []*AuditLog, _a1 error) *MockQuerier_GetAuditLogsForTeam_Call

func (*MockQuerier_GetAuditLogsForTeam_Call) Run 

func (_c *MockQuerier_GetAuditLogsForTeam_Call) Run(run func(ctx context.Context, arg GetAuditLogsForTeamParams)) *MockQuerier_GetAuditLogsForTeam_Call

func (*MockQuerier_GetAuditLogsForTeam_Call) RunAndReturn 

func (_c *MockQuerier_GetAuditLogsForTeam_Call) RunAndReturn(run func(context.Context, GetAuditLogsForTeamParams) ([]*AuditLog, error)) *MockQuerier_GetAuditLogsForTeam_Call

type MockQuerier_GetEnabledReconcilers_Call 

type MockQuerier_GetEnabledReconcilers_Call struct {
	*mock.Call
}

MockQuerier_GetEnabledReconcilers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEnabledReconcilers'

func (*MockQuerier_GetEnabledReconcilers_Call) Return 

func (_c *MockQuerier_GetEnabledReconcilers_Call) Return(_a0 []*Reconciler, _a1 error) *MockQuerier_GetEnabledReconcilers_Call

func (*MockQuerier_GetEnabledReconcilers_Call) Run 

func (_c *MockQuerier_GetEnabledReconcilers_Call) Run(run func(ctx context.Context)) *MockQuerier_GetEnabledReconcilers_Call

func (*MockQuerier_GetEnabledReconcilers_Call) RunAndReturn 

func (_c *MockQuerier_GetEnabledReconcilers_Call) RunAndReturn(run func(context.Context) ([]*Reconciler, error)) *MockQuerier_GetEnabledReconcilers_Call

type MockQuerier_GetReconcilerConfig_Call 

type MockQuerier_GetReconcilerConfig_Call struct {
	*mock.Call
}

MockQuerier_GetReconcilerConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconcilerConfig'

func (*MockQuerier_GetReconcilerConfig_Call) Return 

func (_c *MockQuerier_GetReconcilerConfig_Call) Return(_a0 []*GetReconcilerConfigRow, _a1 error) *MockQuerier_GetReconcilerConfig_Call

func (*MockQuerier_GetReconcilerConfig_Call) Run 

func (_c *MockQuerier_GetReconcilerConfig_Call) Run(run func(ctx context.Context, arg GetReconcilerConfigParams)) *MockQuerier_GetReconcilerConfig_Call

func (*MockQuerier_GetReconcilerConfig_Call) RunAndReturn 

func (_c *MockQuerier_GetReconcilerConfig_Call) RunAndReturn(run func(context.Context, GetReconcilerConfigParams) ([]*GetReconcilerConfigRow, error)) *MockQuerier_GetReconcilerConfig_Call

type MockQuerier_GetReconcilerStateForTeam_Call 

type MockQuerier_GetReconcilerStateForTeam_Call struct {
	*mock.Call
}

MockQuerier_GetReconcilerStateForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconcilerStateForTeam'

func (*MockQuerier_GetReconcilerStateForTeam_Call) Return 

func (_c *MockQuerier_GetReconcilerStateForTeam_Call) Return(_a0 *ReconcilerState, _a1 error) *MockQuerier_GetReconcilerStateForTeam_Call

func (*MockQuerier_GetReconcilerStateForTeam_Call) Run 

func (_c *MockQuerier_GetReconcilerStateForTeam_Call) Run(run func(ctx context.Context, arg GetReconcilerStateForTeamParams)) *MockQuerier_GetReconcilerStateForTeam_Call

func (*MockQuerier_GetReconcilerStateForTeam_Call) RunAndReturn 

func (_c *MockQuerier_GetReconcilerStateForTeam_Call) RunAndReturn(run func(context.Context, GetReconcilerStateForTeamParams) (*ReconcilerState, error)) *MockQuerier_GetReconcilerStateForTeam_Call

type MockQuerier_GetReconcilerState_Call 

type MockQuerier_GetReconcilerState_Call struct {
	*mock.Call
}

MockQuerier_GetReconcilerState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconcilerState'

func (*MockQuerier_GetReconcilerState_Call) Return 

func (_c *MockQuerier_GetReconcilerState_Call) Return(_a0 []*GetReconcilerStateRow, _a1 error) *MockQuerier_GetReconcilerState_Call

func (*MockQuerier_GetReconcilerState_Call) Run 

func (_c *MockQuerier_GetReconcilerState_Call) Run(run func(ctx context.Context, reconcilerName string)) *MockQuerier_GetReconcilerState_Call

func (*MockQuerier_GetReconcilerState_Call) RunAndReturn 

func (_c *MockQuerier_GetReconcilerState_Call) RunAndReturn(run func(context.Context, string) ([]*GetReconcilerStateRow, error)) *MockQuerier_GetReconcilerState_Call

type MockQuerier_GetReconciler_Call 

type MockQuerier_GetReconciler_Call struct {
	*mock.Call
}

MockQuerier_GetReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconciler'

func (*MockQuerier_GetReconciler_Call) Return 

func (_c *MockQuerier_GetReconciler_Call) Return(_a0 *Reconciler, _a1 error) *MockQuerier_GetReconciler_Call

func (*MockQuerier_GetReconciler_Call) Run 

func (_c *MockQuerier_GetReconciler_Call) Run(run func(ctx context.Context, name string)) *MockQuerier_GetReconciler_Call

func (*MockQuerier_GetReconciler_Call) RunAndReturn 

func (_c *MockQuerier_GetReconciler_Call) RunAndReturn(run func(context.Context, string) (*Reconciler, error)) *MockQuerier_GetReconciler_Call

type MockQuerier_GetReconcilersCount_Call 

type MockQuerier_GetReconcilersCount_Call struct {
	*mock.Call
}

MockQuerier_GetReconcilersCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconcilersCount'

func (*MockQuerier_GetReconcilersCount_Call) Return 

func (_c *MockQuerier_GetReconcilersCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetReconcilersCount_Call

func (*MockQuerier_GetReconcilersCount_Call) Run 

func (_c *MockQuerier_GetReconcilersCount_Call) Run(run func(ctx context.Context)) *MockQuerier_GetReconcilersCount_Call

func (*MockQuerier_GetReconcilersCount_Call) RunAndReturn 

func (_c *MockQuerier_GetReconcilersCount_Call) RunAndReturn(run func(context.Context) (int64, error)) *MockQuerier_GetReconcilersCount_Call

type MockQuerier_GetReconcilers_Call 

type MockQuerier_GetReconcilers_Call struct {
	*mock.Call
}

MockQuerier_GetReconcilers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconcilers'

func (*MockQuerier_GetReconcilers_Call) Return 

func (_c *MockQuerier_GetReconcilers_Call) Return(_a0 []*Reconciler, _a1 error) *MockQuerier_GetReconcilers_Call

func (*MockQuerier_GetReconcilers_Call) Run 

func (_c *MockQuerier_GetReconcilers_Call) Run(run func(ctx context.Context, arg GetReconcilersParams)) *MockQuerier_GetReconcilers_Call

func (*MockQuerier_GetReconcilers_Call) RunAndReturn 

func (_c *MockQuerier_GetReconcilers_Call) RunAndReturn(run func(context.Context, GetReconcilersParams) ([]*Reconciler, error)) *MockQuerier_GetReconcilers_Call

type MockQuerier_GetRepositoryAuthorizations_Call 

type MockQuerier_GetRepositoryAuthorizations_Call struct {
	*mock.Call
}

MockQuerier_GetRepositoryAuthorizations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRepositoryAuthorizations'

func (*MockQuerier_GetRepositoryAuthorizations_Call) Return 

func (_c *MockQuerier_GetRepositoryAuthorizations_Call) Return(_a0 []RepositoryAuthorizationEnum, _a1 error) *MockQuerier_GetRepositoryAuthorizations_Call

func (*MockQuerier_GetRepositoryAuthorizations_Call) Run 

func (_c *MockQuerier_GetRepositoryAuthorizations_Call) Run(run func(ctx context.Context, arg GetRepositoryAuthorizationsParams)) *MockQuerier_GetRepositoryAuthorizations_Call

func (*MockQuerier_GetRepositoryAuthorizations_Call) RunAndReturn 

func (_c *MockQuerier_GetRepositoryAuthorizations_Call) RunAndReturn(run func(context.Context, GetRepositoryAuthorizationsParams) ([]RepositoryAuthorizationEnum, error)) *MockQuerier_GetRepositoryAuthorizations_Call

type MockQuerier_GetServiceAccountByApiKey_Call 

type MockQuerier_GetServiceAccountByApiKey_Call struct {
	*mock.Call
}

MockQuerier_GetServiceAccountByApiKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccountByApiKey'

func (*MockQuerier_GetServiceAccountByApiKey_Call) Return 

func (_c *MockQuerier_GetServiceAccountByApiKey_Call) Return(_a0 *ServiceAccount, _a1 error) *MockQuerier_GetServiceAccountByApiKey_Call

func (*MockQuerier_GetServiceAccountByApiKey_Call) Run 

func (_c *MockQuerier_GetServiceAccountByApiKey_Call) Run(run func(ctx context.Context, apiKey string)) *MockQuerier_GetServiceAccountByApiKey_Call

func (*MockQuerier_GetServiceAccountByApiKey_Call) RunAndReturn 

func (_c *MockQuerier_GetServiceAccountByApiKey_Call) RunAndReturn(run func(context.Context, string) (*ServiceAccount, error)) *MockQuerier_GetServiceAccountByApiKey_Call

type MockQuerier_GetServiceAccountByName_Call 

type MockQuerier_GetServiceAccountByName_Call struct {
	*mock.Call
}

MockQuerier_GetServiceAccountByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccountByName'

func (*MockQuerier_GetServiceAccountByName_Call) Return 

func (_c *MockQuerier_GetServiceAccountByName_Call) Return(_a0 *ServiceAccount, _a1 error) *MockQuerier_GetServiceAccountByName_Call

func (*MockQuerier_GetServiceAccountByName_Call) Run 

func (_c *MockQuerier_GetServiceAccountByName_Call) Run(run func(ctx context.Context, name string)) *MockQuerier_GetServiceAccountByName_Call

func (*MockQuerier_GetServiceAccountByName_Call) RunAndReturn 

func (_c *MockQuerier_GetServiceAccountByName_Call) RunAndReturn(run func(context.Context, string) (*ServiceAccount, error)) *MockQuerier_GetServiceAccountByName_Call

type MockQuerier_GetServiceAccountRoles_Call 

type MockQuerier_GetServiceAccountRoles_Call struct {
	*mock.Call
}

MockQuerier_GetServiceAccountRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccountRoles'

func (*MockQuerier_GetServiceAccountRoles_Call) Return 

func (_c *MockQuerier_GetServiceAccountRoles_Call) Return(_a0 []*ServiceAccountRole, _a1 error) *MockQuerier_GetServiceAccountRoles_Call

func (*MockQuerier_GetServiceAccountRoles_Call) Run 

func (_c *MockQuerier_GetServiceAccountRoles_Call) Run(run func(ctx context.Context, serviceAccountID uuid.UUID)) *MockQuerier_GetServiceAccountRoles_Call

func (*MockQuerier_GetServiceAccountRoles_Call) RunAndReturn 

func (_c *MockQuerier_GetServiceAccountRoles_Call) RunAndReturn(run func(context.Context, uuid.UUID) ([]*ServiceAccountRole, error)) *MockQuerier_GetServiceAccountRoles_Call

type MockQuerier_GetServiceAccountsByIDs_Call 

type MockQuerier_GetServiceAccountsByIDs_Call struct {
	*mock.Call
}

MockQuerier_GetServiceAccountsByIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccountsByIDs'

func (*MockQuerier_GetServiceAccountsByIDs_Call) Return 

func (_c *MockQuerier_GetServiceAccountsByIDs_Call) Return(_a0 []*ServiceAccount, _a1 error) *MockQuerier_GetServiceAccountsByIDs_Call

func (*MockQuerier_GetServiceAccountsByIDs_Call) Run 

func (_c *MockQuerier_GetServiceAccountsByIDs_Call) Run(run func(ctx context.Context, ids []uuid.UUID)) *MockQuerier_GetServiceAccountsByIDs_Call

func (*MockQuerier_GetServiceAccountsByIDs_Call) RunAndReturn 

func (_c *MockQuerier_GetServiceAccountsByIDs_Call) RunAndReturn(run func(context.Context, []uuid.UUID) ([]*ServiceAccount, error)) *MockQuerier_GetServiceAccountsByIDs_Call

type MockQuerier_GetServiceAccounts_Call 

type MockQuerier_GetServiceAccounts_Call struct {
	*mock.Call
}

MockQuerier_GetServiceAccounts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccounts'

func (*MockQuerier_GetServiceAccounts_Call) Return 

func (_c *MockQuerier_GetServiceAccounts_Call) Return(_a0 []*ServiceAccount, _a1 error) *MockQuerier_GetServiceAccounts_Call

func (*MockQuerier_GetServiceAccounts_Call) Run 

func (_c *MockQuerier_GetServiceAccounts_Call) Run(run func(ctx context.Context)) *MockQuerier_GetServiceAccounts_Call

func (*MockQuerier_GetServiceAccounts_Call) RunAndReturn 

func (_c *MockQuerier_GetServiceAccounts_Call) RunAndReturn(run func(context.Context) ([]*ServiceAccount, error)) *MockQuerier_GetServiceAccounts_Call

type MockQuerier_GetSessionByID_Call 

type MockQuerier_GetSessionByID_Call struct {
	*mock.Call
}

MockQuerier_GetSessionByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSessionByID'

func (*MockQuerier_GetSessionByID_Call) Return 

func (_c *MockQuerier_GetSessionByID_Call) Return(_a0 *Session, _a1 error) *MockQuerier_GetSessionByID_Call

func (*MockQuerier_GetSessionByID_Call) Run 

func (_c *MockQuerier_GetSessionByID_Call) Run(run func(ctx context.Context, id uuid.UUID)) *MockQuerier_GetSessionByID_Call

func (*MockQuerier_GetSessionByID_Call) RunAndReturn 

func (_c *MockQuerier_GetSessionByID_Call) RunAndReturn(run func(context.Context, uuid.UUID) (*Session, error)) *MockQuerier_GetSessionByID_Call

type MockQuerier_GetTeamBySlug_Call 

type MockQuerier_GetTeamBySlug_Call struct {
	*mock.Call
}

MockQuerier_GetTeamBySlug_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamBySlug'

func (*MockQuerier_GetTeamBySlug_Call) Return 

func (_c *MockQuerier_GetTeamBySlug_Call) Return(_a0 *Team, _a1 error) *MockQuerier_GetTeamBySlug_Call

func (*MockQuerier_GetTeamBySlug_Call) Run 

func (_c *MockQuerier_GetTeamBySlug_Call) Run(run func(ctx context.Context, argSlug slug.Slug)) *MockQuerier_GetTeamBySlug_Call

func (*MockQuerier_GetTeamBySlug_Call) RunAndReturn 

func (_c *MockQuerier_GetTeamBySlug_Call) RunAndReturn(run func(context.Context, slug.Slug) (*Team, error)) *MockQuerier_GetTeamBySlug_Call

type MockQuerier_GetTeamBySlugs_Call 

type MockQuerier_GetTeamBySlugs_Call struct {
	*mock.Call
}

MockQuerier_GetTeamBySlugs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamBySlugs'

func (*MockQuerier_GetTeamBySlugs_Call) Return 

func (_c *MockQuerier_GetTeamBySlugs_Call) Return(_a0 []*Team, _a1 error) *MockQuerier_GetTeamBySlugs_Call

func (*MockQuerier_GetTeamBySlugs_Call) Run 

func (_c *MockQuerier_GetTeamBySlugs_Call) Run(run func(ctx context.Context, slugs []slug.Slug)) *MockQuerier_GetTeamBySlugs_Call

func (*MockQuerier_GetTeamBySlugs_Call) RunAndReturn 

func (_c *MockQuerier_GetTeamBySlugs_Call) RunAndReturn(run func(context.Context, []slug.Slug) ([]*Team, error)) *MockQuerier_GetTeamBySlugs_Call

type MockQuerier_GetTeamDeleteKey_Call 

type MockQuerier_GetTeamDeleteKey_Call struct {
	*mock.Call
}

MockQuerier_GetTeamDeleteKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamDeleteKey'

func (*MockQuerier_GetTeamDeleteKey_Call) Return 

func (_c *MockQuerier_GetTeamDeleteKey_Call) Return(_a0 *TeamDeleteKey, _a1 error) *MockQuerier_GetTeamDeleteKey_Call

func (*MockQuerier_GetTeamDeleteKey_Call) Run 

func (_c *MockQuerier_GetTeamDeleteKey_Call) Run(run func(ctx context.Context, key uuid.UUID)) *MockQuerier_GetTeamDeleteKey_Call

func (*MockQuerier_GetTeamDeleteKey_Call) RunAndReturn 

func (_c *MockQuerier_GetTeamDeleteKey_Call) RunAndReturn(run func(context.Context, uuid.UUID) (*TeamDeleteKey, error)) *MockQuerier_GetTeamDeleteKey_Call

type MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call 

type MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call struct {
	*mock.Call
}

MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamEnvironmentsBySlugsAndEnvNames'

func (*MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call) Return 

func (_c *MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call) Return(_a0 []*TeamAllEnvironment, _a1 error) *MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call

func (*MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call) Run 

func (_c *MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call) Run(run func(ctx context.Context, arg GetTeamEnvironmentsBySlugsAndEnvNamesParams)) *MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call

func (*MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call) RunAndReturn 

func (_c *MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call) RunAndReturn(run func(context.Context, GetTeamEnvironmentsBySlugsAndEnvNamesParams) ([]*TeamAllEnvironment, error)) *MockQuerier_GetTeamEnvironmentsBySlugsAndEnvNames_Call

type MockQuerier_GetTeamEnvironmentsCount_Call 

type MockQuerier_GetTeamEnvironmentsCount_Call struct {
	*mock.Call
}

MockQuerier_GetTeamEnvironmentsCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamEnvironmentsCount'

func (*MockQuerier_GetTeamEnvironmentsCount_Call) Return 

func (_c *MockQuerier_GetTeamEnvironmentsCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetTeamEnvironmentsCount_Call

func (*MockQuerier_GetTeamEnvironmentsCount_Call) Run 

func (_c *MockQuerier_GetTeamEnvironmentsCount_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockQuerier_GetTeamEnvironmentsCount_Call

func (*MockQuerier_GetTeamEnvironmentsCount_Call) RunAndReturn 

func (_c *MockQuerier_GetTeamEnvironmentsCount_Call) RunAndReturn(run func(context.Context, slug.Slug) (int64, error)) *MockQuerier_GetTeamEnvironmentsCount_Call

type MockQuerier_GetTeamEnvironments_Call 

type MockQuerier_GetTeamEnvironments_Call struct {
	*mock.Call
}

MockQuerier_GetTeamEnvironments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamEnvironments'

func (*MockQuerier_GetTeamEnvironments_Call) Return 

func (_c *MockQuerier_GetTeamEnvironments_Call) Return(_a0 []*TeamAllEnvironment, _a1 error) *MockQuerier_GetTeamEnvironments_Call

func (*MockQuerier_GetTeamEnvironments_Call) Run 

func (_c *MockQuerier_GetTeamEnvironments_Call) Run(run func(ctx context.Context, arg GetTeamEnvironmentsParams)) *MockQuerier_GetTeamEnvironments_Call

func (*MockQuerier_GetTeamEnvironments_Call) RunAndReturn 

func (_c *MockQuerier_GetTeamEnvironments_Call) RunAndReturn(run func(context.Context, GetTeamEnvironmentsParams) ([]*TeamAllEnvironment, error)) *MockQuerier_GetTeamEnvironments_Call

type MockQuerier_GetTeamMemberOptOuts_Call 

type MockQuerier_GetTeamMemberOptOuts_Call struct {
	*mock.Call
}

MockQuerier_GetTeamMemberOptOuts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamMemberOptOuts'

func (*MockQuerier_GetTeamMemberOptOuts_Call) Return 

func (_c *MockQuerier_GetTeamMemberOptOuts_Call) Return(_a0 []*GetTeamMemberOptOutsRow, _a1 error) *MockQuerier_GetTeamMemberOptOuts_Call

func (*MockQuerier_GetTeamMemberOptOuts_Call) Run 

func (_c *MockQuerier_GetTeamMemberOptOuts_Call) Run(run func(ctx context.Context, arg GetTeamMemberOptOutsParams)) *MockQuerier_GetTeamMemberOptOuts_Call

func (*MockQuerier_GetTeamMemberOptOuts_Call) RunAndReturn 

func (_c *MockQuerier_GetTeamMemberOptOuts_Call) RunAndReturn(run func(context.Context, GetTeamMemberOptOutsParams) ([]*GetTeamMemberOptOutsRow, error)) *MockQuerier_GetTeamMemberOptOuts_Call

type MockQuerier_GetTeamMember_Call 

type MockQuerier_GetTeamMember_Call struct {
	*mock.Call
}

MockQuerier_GetTeamMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamMember'

func (*MockQuerier_GetTeamMember_Call) Return 

func (_c *MockQuerier_GetTeamMember_Call) Return(_a0 *User, _a1 error) *MockQuerier_GetTeamMember_Call

func (*MockQuerier_GetTeamMember_Call) Run 

func (_c *MockQuerier_GetTeamMember_Call) Run(run func(ctx context.Context, arg GetTeamMemberParams)) *MockQuerier_GetTeamMember_Call

func (*MockQuerier_GetTeamMember_Call) RunAndReturn 

func (_c *MockQuerier_GetTeamMember_Call) RunAndReturn(run func(context.Context, GetTeamMemberParams) (*User, error)) *MockQuerier_GetTeamMember_Call

type MockQuerier_GetTeamMembersCount_Call 

type MockQuerier_GetTeamMembersCount_Call struct {
	*mock.Call
}

MockQuerier_GetTeamMembersCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamMembersCount'

func (*MockQuerier_GetTeamMembersCount_Call) Return 

func (_c *MockQuerier_GetTeamMembersCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetTeamMembersCount_Call

func (*MockQuerier_GetTeamMembersCount_Call) Run 

func (_c *MockQuerier_GetTeamMembersCount_Call) Run(run func(ctx context.Context, teamSlug *slug.Slug)) *MockQuerier_GetTeamMembersCount_Call

func (*MockQuerier_GetTeamMembersCount_Call) RunAndReturn 

func (_c *MockQuerier_GetTeamMembersCount_Call) RunAndReturn(run func(context.Context, *slug.Slug) (int64, error)) *MockQuerier_GetTeamMembersCount_Call

type MockQuerier_GetTeamMembersForReconciler_Call 

type MockQuerier_GetTeamMembersForReconciler_Call struct {
	*mock.Call
}

MockQuerier_GetTeamMembersForReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamMembersForReconciler'

func (*MockQuerier_GetTeamMembersForReconciler_Call) Return 

func (_c *MockQuerier_GetTeamMembersForReconciler_Call) Return(_a0 []*User, _a1 error) *MockQuerier_GetTeamMembersForReconciler_Call

func (*MockQuerier_GetTeamMembersForReconciler_Call) Run 

func (_c *MockQuerier_GetTeamMembersForReconciler_Call) Run(run func(ctx context.Context, arg GetTeamMembersForReconcilerParams)) *MockQuerier_GetTeamMembersForReconciler_Call

func (*MockQuerier_GetTeamMembersForReconciler_Call) RunAndReturn 

func (_c *MockQuerier_GetTeamMembersForReconciler_Call) RunAndReturn(run func(context.Context, GetTeamMembersForReconcilerParams) ([]*User, error)) *MockQuerier_GetTeamMembersForReconciler_Call

type MockQuerier_GetTeamMembers_Call 

type MockQuerier_GetTeamMembers_Call struct {
	*mock.Call
}

MockQuerier_GetTeamMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamMembers'

func (*MockQuerier_GetTeamMembers_Call) Return 

func (_c *MockQuerier_GetTeamMembers_Call) Return(_a0 []*User, _a1 error) *MockQuerier_GetTeamMembers_Call

func (*MockQuerier_GetTeamMembers_Call) Run 

func (_c *MockQuerier_GetTeamMembers_Call) Run(run func(ctx context.Context, arg GetTeamMembersParams)) *MockQuerier_GetTeamMembers_Call

func (*MockQuerier_GetTeamMembers_Call) RunAndReturn 

func (_c *MockQuerier_GetTeamMembers_Call) RunAndReturn(run func(context.Context, GetTeamMembersParams) ([]*User, error)) *MockQuerier_GetTeamMembers_Call

type MockQuerier_GetTeamReconcilerErrors_Call 

type MockQuerier_GetTeamReconcilerErrors_Call struct {
	*mock.Call
}

MockQuerier_GetTeamReconcilerErrors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamReconcilerErrors'

func (*MockQuerier_GetTeamReconcilerErrors_Call) Return 

func (_c *MockQuerier_GetTeamReconcilerErrors_Call) Return(_a0 []*ReconcilerError, _a1 error) *MockQuerier_GetTeamReconcilerErrors_Call

func (*MockQuerier_GetTeamReconcilerErrors_Call) Run 

func (_c *MockQuerier_GetTeamReconcilerErrors_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockQuerier_GetTeamReconcilerErrors_Call

func (*MockQuerier_GetTeamReconcilerErrors_Call) RunAndReturn 

func (_c *MockQuerier_GetTeamReconcilerErrors_Call) RunAndReturn(run func(context.Context, slug.Slug) ([]*ReconcilerError, error)) *MockQuerier_GetTeamReconcilerErrors_Call

type MockQuerier_GetTeamsCount_Call 

type MockQuerier_GetTeamsCount_Call struct {
	*mock.Call
}

MockQuerier_GetTeamsCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamsCount'

func (*MockQuerier_GetTeamsCount_Call) Return 

func (_c *MockQuerier_GetTeamsCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetTeamsCount_Call

func (*MockQuerier_GetTeamsCount_Call) Run 

func (_c *MockQuerier_GetTeamsCount_Call) Run(run func(ctx context.Context)) *MockQuerier_GetTeamsCount_Call

func (*MockQuerier_GetTeamsCount_Call) RunAndReturn 

func (_c *MockQuerier_GetTeamsCount_Call) RunAndReturn(run func(context.Context) (int64, error)) *MockQuerier_GetTeamsCount_Call

type MockQuerier_GetTeams_Call 

type MockQuerier_GetTeams_Call struct {
	*mock.Call
}

MockQuerier_GetTeams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeams'

func (*MockQuerier_GetTeams_Call) Return 

func (_c *MockQuerier_GetTeams_Call) Return(_a0 []*Team, _a1 error) *MockQuerier_GetTeams_Call

func (*MockQuerier_GetTeams_Call) Run 

func (_c *MockQuerier_GetTeams_Call) Run(run func(ctx context.Context, arg GetTeamsParams)) *MockQuerier_GetTeams_Call

func (*MockQuerier_GetTeams_Call) RunAndReturn 

func (_c *MockQuerier_GetTeams_Call) RunAndReturn(run func(context.Context, GetTeamsParams) ([]*Team, error)) *MockQuerier_GetTeams_Call

type MockQuerier_GetUserByEmail_Call 

type MockQuerier_GetUserByEmail_Call struct {
	*mock.Call
}

MockQuerier_GetUserByEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByEmail'

func (*MockQuerier_GetUserByEmail_Call) Return 

func (_c *MockQuerier_GetUserByEmail_Call) Return(_a0 *User, _a1 error) *MockQuerier_GetUserByEmail_Call

func (*MockQuerier_GetUserByEmail_Call) Run 

func (_c *MockQuerier_GetUserByEmail_Call) Run(run func(ctx context.Context, email string)) *MockQuerier_GetUserByEmail_Call

func (*MockQuerier_GetUserByEmail_Call) RunAndReturn 

func (_c *MockQuerier_GetUserByEmail_Call) RunAndReturn(run func(context.Context, string) (*User, error)) *MockQuerier_GetUserByEmail_Call

type MockQuerier_GetUserByExternalID_Call 

type MockQuerier_GetUserByExternalID_Call struct {
	*mock.Call
}

MockQuerier_GetUserByExternalID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByExternalID'

func (*MockQuerier_GetUserByExternalID_Call) Return 

func (_c *MockQuerier_GetUserByExternalID_Call) Return(_a0 *User, _a1 error) *MockQuerier_GetUserByExternalID_Call

func (*MockQuerier_GetUserByExternalID_Call) Run 

func (_c *MockQuerier_GetUserByExternalID_Call) Run(run func(ctx context.Context, externalID string)) *MockQuerier_GetUserByExternalID_Call

func (*MockQuerier_GetUserByExternalID_Call) RunAndReturn 

func (_c *MockQuerier_GetUserByExternalID_Call) RunAndReturn(run func(context.Context, string) (*User, error)) *MockQuerier_GetUserByExternalID_Call

type MockQuerier_GetUserByID_Call 

type MockQuerier_GetUserByID_Call struct {
	*mock.Call
}

MockQuerier_GetUserByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByID'

func (*MockQuerier_GetUserByID_Call) Return 

func (_c *MockQuerier_GetUserByID_Call) Return(_a0 *User, _a1 error) *MockQuerier_GetUserByID_Call

func (*MockQuerier_GetUserByID_Call) Run 

func (_c *MockQuerier_GetUserByID_Call) Run(run func(ctx context.Context, id uuid.UUID)) *MockQuerier_GetUserByID_Call

func (*MockQuerier_GetUserByID_Call) RunAndReturn 

func (_c *MockQuerier_GetUserByID_Call) RunAndReturn(run func(context.Context, uuid.UUID) (*User, error)) *MockQuerier_GetUserByID_Call

type MockQuerier_GetUserRolesForUsers_Call 

type MockQuerier_GetUserRolesForUsers_Call struct {
	*mock.Call
}

MockQuerier_GetUserRolesForUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserRolesForUsers'

func (*MockQuerier_GetUserRolesForUsers_Call) Return 

func (_c *MockQuerier_GetUserRolesForUsers_Call) Return(_a0 []*GetUserRolesForUsersRow, _a1 error) *MockQuerier_GetUserRolesForUsers_Call

func (*MockQuerier_GetUserRolesForUsers_Call) Run 

func (_c *MockQuerier_GetUserRolesForUsers_Call) Run(run func(ctx context.Context, userIds []uuid.UUID)) *MockQuerier_GetUserRolesForUsers_Call

func (*MockQuerier_GetUserRolesForUsers_Call) RunAndReturn 

func (_c *MockQuerier_GetUserRolesForUsers_Call) RunAndReturn(run func(context.Context, []uuid.UUID) ([]*GetUserRolesForUsersRow, error)) *MockQuerier_GetUserRolesForUsers_Call

type MockQuerier_GetUserRoles_Call 

type MockQuerier_GetUserRoles_Call struct {
	*mock.Call
}

MockQuerier_GetUserRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserRoles'

func (*MockQuerier_GetUserRoles_Call) Return 

func (_c *MockQuerier_GetUserRoles_Call) Return(_a0 []*UserRole, _a1 error) *MockQuerier_GetUserRoles_Call

func (*MockQuerier_GetUserRoles_Call) Run 

func (_c *MockQuerier_GetUserRoles_Call) Run(run func(ctx context.Context, userID uuid.UUID)) *MockQuerier_GetUserRoles_Call

func (*MockQuerier_GetUserRoles_Call) RunAndReturn 

func (_c *MockQuerier_GetUserRoles_Call) RunAndReturn(run func(context.Context, uuid.UUID) ([]*UserRole, error)) *MockQuerier_GetUserRoles_Call

type MockQuerier_GetUserTeamsCount_Call 

type MockQuerier_GetUserTeamsCount_Call struct {
	*mock.Call
}

MockQuerier_GetUserTeamsCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserTeamsCount'

func (*MockQuerier_GetUserTeamsCount_Call) Return 

func (_c *MockQuerier_GetUserTeamsCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetUserTeamsCount_Call

func (*MockQuerier_GetUserTeamsCount_Call) Run 

func (_c *MockQuerier_GetUserTeamsCount_Call) Run(run func(ctx context.Context, userID uuid.UUID)) *MockQuerier_GetUserTeamsCount_Call

func (*MockQuerier_GetUserTeamsCount_Call) RunAndReturn 

func (_c *MockQuerier_GetUserTeamsCount_Call) RunAndReturn(run func(context.Context, uuid.UUID) (int64, error)) *MockQuerier_GetUserTeamsCount_Call

type MockQuerier_GetUserTeamsPaginated_Call 

type MockQuerier_GetUserTeamsPaginated_Call struct {
	*mock.Call
}

MockQuerier_GetUserTeamsPaginated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserTeamsPaginated'

func (*MockQuerier_GetUserTeamsPaginated_Call) Return 

func (_c *MockQuerier_GetUserTeamsPaginated_Call) Return(_a0 []*GetUserTeamsPaginatedRow, _a1 error) *MockQuerier_GetUserTeamsPaginated_Call

func (*MockQuerier_GetUserTeamsPaginated_Call) Run 

func (_c *MockQuerier_GetUserTeamsPaginated_Call) Run(run func(ctx context.Context, arg GetUserTeamsPaginatedParams)) *MockQuerier_GetUserTeamsPaginated_Call

func (*MockQuerier_GetUserTeamsPaginated_Call) RunAndReturn 

func (_c *MockQuerier_GetUserTeamsPaginated_Call) RunAndReturn(run func(context.Context, GetUserTeamsPaginatedParams) ([]*GetUserTeamsPaginatedRow, error)) *MockQuerier_GetUserTeamsPaginated_Call

type MockQuerier_GetUserTeams_Call 

type MockQuerier_GetUserTeams_Call struct {
	*mock.Call
}

MockQuerier_GetUserTeams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserTeams'

func (*MockQuerier_GetUserTeams_Call) Return 

func (_c *MockQuerier_GetUserTeams_Call) Return(_a0 []*GetUserTeamsRow, _a1 error) *MockQuerier_GetUserTeams_Call

func (*MockQuerier_GetUserTeams_Call) Run 

func (_c *MockQuerier_GetUserTeams_Call) Run(run func(ctx context.Context, userID uuid.UUID)) *MockQuerier_GetUserTeams_Call

func (*MockQuerier_GetUserTeams_Call) RunAndReturn 

func (_c *MockQuerier_GetUserTeams_Call) RunAndReturn(run func(context.Context, uuid.UUID) ([]*GetUserTeamsRow, error)) *MockQuerier_GetUserTeams_Call

type MockQuerier_GetUsersByIDs_Call 

type MockQuerier_GetUsersByIDs_Call struct {
	*mock.Call
}

MockQuerier_GetUsersByIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsersByIDs'

func (*MockQuerier_GetUsersByIDs_Call) Return 

func (_c *MockQuerier_GetUsersByIDs_Call) Return(_a0 []*User, _a1 error) *MockQuerier_GetUsersByIDs_Call

func (*MockQuerier_GetUsersByIDs_Call) Run 

func (_c *MockQuerier_GetUsersByIDs_Call) Run(run func(ctx context.Context, ids []uuid.UUID)) *MockQuerier_GetUsersByIDs_Call

func (*MockQuerier_GetUsersByIDs_Call) RunAndReturn 

func (_c *MockQuerier_GetUsersByIDs_Call) RunAndReturn(run func(context.Context, []uuid.UUID) ([]*User, error)) *MockQuerier_GetUsersByIDs_Call

type MockQuerier_GetUsersCount_Call 

type MockQuerier_GetUsersCount_Call struct {
	*mock.Call
}

MockQuerier_GetUsersCount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsersCount'

func (*MockQuerier_GetUsersCount_Call) Return 

func (_c *MockQuerier_GetUsersCount_Call) Return(_a0 int64, _a1 error) *MockQuerier_GetUsersCount_Call

func (*MockQuerier_GetUsersCount_Call) Run 

func (_c *MockQuerier_GetUsersCount_Call) Run(run func(ctx context.Context)) *MockQuerier_GetUsersCount_Call

func (*MockQuerier_GetUsersCount_Call) RunAndReturn 

func (_c *MockQuerier_GetUsersCount_Call) RunAndReturn(run func(context.Context) (int64, error)) *MockQuerier_GetUsersCount_Call

type MockQuerier_GetUsersWithGloballyAssignedRole_Call 

type MockQuerier_GetUsersWithGloballyAssignedRole_Call struct {
	*mock.Call
}

MockQuerier_GetUsersWithGloballyAssignedRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsersWithGloballyAssignedRole'

func (*MockQuerier_GetUsersWithGloballyAssignedRole_Call) Return 

func (_c *MockQuerier_GetUsersWithGloballyAssignedRole_Call) Return(_a0 []*User, _a1 error) *MockQuerier_GetUsersWithGloballyAssignedRole_Call

func (*MockQuerier_GetUsersWithGloballyAssignedRole_Call) Run 

func (_c *MockQuerier_GetUsersWithGloballyAssignedRole_Call) Run(run func(ctx context.Context, roleName RoleName)) *MockQuerier_GetUsersWithGloballyAssignedRole_Call

func (*MockQuerier_GetUsersWithGloballyAssignedRole_Call) RunAndReturn 

func (_c *MockQuerier_GetUsersWithGloballyAssignedRole_Call) RunAndReturn(run func(context.Context, RoleName) ([]*User, error)) *MockQuerier_GetUsersWithGloballyAssignedRole_Call

type MockQuerier_GetUsers_Call 

type MockQuerier_GetUsers_Call struct {
	*mock.Call
}

MockQuerier_GetUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsers'

func (*MockQuerier_GetUsers_Call) Return 

func (_c *MockQuerier_GetUsers_Call) Return(_a0 []*User, _a1 error) *MockQuerier_GetUsers_Call

func (*MockQuerier_GetUsers_Call) Run 

func (_c *MockQuerier_GetUsers_Call) Run(run func(ctx context.Context, arg GetUsersParams)) *MockQuerier_GetUsers_Call

func (*MockQuerier_GetUsers_Call) RunAndReturn 

func (_c *MockQuerier_GetUsers_Call) RunAndReturn(run func(context.Context, GetUsersParams) ([]*User, error)) *MockQuerier_GetUsers_Call

type MockQuerier_InsertEnvironment_Call 

type MockQuerier_InsertEnvironment_Call struct {
	*mock.Call
}

MockQuerier_InsertEnvironment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertEnvironment'

func (*MockQuerier_InsertEnvironment_Call) Return 

func (_c *MockQuerier_InsertEnvironment_Call) Return(_a0 error) *MockQuerier_InsertEnvironment_Call

func (*MockQuerier_InsertEnvironment_Call) Run 

func (_c *MockQuerier_InsertEnvironment_Call) Run(run func(ctx context.Context, arg InsertEnvironmentParams)) *MockQuerier_InsertEnvironment_Call

func (*MockQuerier_InsertEnvironment_Call) RunAndReturn 

func (_c *MockQuerier_InsertEnvironment_Call) RunAndReturn(run func(context.Context, InsertEnvironmentParams) error) *MockQuerier_InsertEnvironment_Call

type MockQuerier_LastCostDate_Call 

type MockQuerier_LastCostDate_Call struct {
	*mock.Call
}

MockQuerier_LastCostDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastCostDate'

func (*MockQuerier_LastCostDate_Call) Return 

func (_c *MockQuerier_LastCostDate_Call) Return(_a0 pgtype.Date, _a1 error) *MockQuerier_LastCostDate_Call

func (*MockQuerier_LastCostDate_Call) Run 

func (_c *MockQuerier_LastCostDate_Call) Run(run func(ctx context.Context)) *MockQuerier_LastCostDate_Call

func (*MockQuerier_LastCostDate_Call) RunAndReturn 

func (_c *MockQuerier_LastCostDate_Call) RunAndReturn(run func(context.Context) (pgtype.Date, error)) *MockQuerier_LastCostDate_Call

type MockQuerier_ListRepositoriesByAuthorization_Call 

type MockQuerier_ListRepositoriesByAuthorization_Call struct {
	*mock.Call
}

MockQuerier_ListRepositoriesByAuthorization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRepositoriesByAuthorization'

func (*MockQuerier_ListRepositoriesByAuthorization_Call) Return 

func (_c *MockQuerier_ListRepositoriesByAuthorization_Call) Return(_a0 []string, _a1 error) *MockQuerier_ListRepositoriesByAuthorization_Call

func (*MockQuerier_ListRepositoriesByAuthorization_Call) Run 

func (_c *MockQuerier_ListRepositoriesByAuthorization_Call) Run(run func(ctx context.Context, arg ListRepositoriesByAuthorizationParams)) *MockQuerier_ListRepositoriesByAuthorization_Call

func (*MockQuerier_ListRepositoriesByAuthorization_Call) RunAndReturn 

func (_c *MockQuerier_ListRepositoriesByAuthorization_Call) RunAndReturn(run func(context.Context, ListRepositoriesByAuthorizationParams) ([]string, error)) *MockQuerier_ListRepositoriesByAuthorization_Call

type MockQuerier_MaxResourceUtilizationDate_Call 

type MockQuerier_MaxResourceUtilizationDate_Call struct {
	*mock.Call
}

MockQuerier_MaxResourceUtilizationDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MaxResourceUtilizationDate'

func (*MockQuerier_MaxResourceUtilizationDate_Call) Return 

func (_c *MockQuerier_MaxResourceUtilizationDate_Call) Return(_a0 pgtype.Timestamptz, _a1 error) *MockQuerier_MaxResourceUtilizationDate_Call

func (*MockQuerier_MaxResourceUtilizationDate_Call) Run 

func (_c *MockQuerier_MaxResourceUtilizationDate_Call) Run(run func(ctx context.Context)) *MockQuerier_MaxResourceUtilizationDate_Call

func (*MockQuerier_MaxResourceUtilizationDate_Call) RunAndReturn 

func (_c *MockQuerier_MaxResourceUtilizationDate_Call) RunAndReturn(run func(context.Context) (pgtype.Timestamptz, error)) *MockQuerier_MaxResourceUtilizationDate_Call

type MockQuerier_MonthlyCostForApp_Call 

type MockQuerier_MonthlyCostForApp_Call struct {
	*mock.Call
}

MockQuerier_MonthlyCostForApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MonthlyCostForApp'

func (*MockQuerier_MonthlyCostForApp_Call) Return 

func (_c *MockQuerier_MonthlyCostForApp_Call) Return(_a0 []*MonthlyCostForAppRow, _a1 error) *MockQuerier_MonthlyCostForApp_Call

func (*MockQuerier_MonthlyCostForApp_Call) Run 

func (_c *MockQuerier_MonthlyCostForApp_Call) Run(run func(ctx context.Context, arg MonthlyCostForAppParams)) *MockQuerier_MonthlyCostForApp_Call

func (*MockQuerier_MonthlyCostForApp_Call) RunAndReturn 

func (_c *MockQuerier_MonthlyCostForApp_Call) RunAndReturn(run func(context.Context, MonthlyCostForAppParams) ([]*MonthlyCostForAppRow, error)) *MockQuerier_MonthlyCostForApp_Call

type MockQuerier_MonthlyCostForTeam_Call 

type MockQuerier_MonthlyCostForTeam_Call struct {
	*mock.Call
}

MockQuerier_MonthlyCostForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MonthlyCostForTeam'

func (*MockQuerier_MonthlyCostForTeam_Call) Return 

func (_c *MockQuerier_MonthlyCostForTeam_Call) Return(_a0 []*CostMonthlyTeam, _a1 error) *MockQuerier_MonthlyCostForTeam_Call

func (*MockQuerier_MonthlyCostForTeam_Call) Run 

func (_c *MockQuerier_MonthlyCostForTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockQuerier_MonthlyCostForTeam_Call

func (*MockQuerier_MonthlyCostForTeam_Call) RunAndReturn 

func (_c *MockQuerier_MonthlyCostForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) ([]*CostMonthlyTeam, error)) *MockQuerier_MonthlyCostForTeam_Call

type MockQuerier_RefreshCostMonthlyTeam_Call 

type MockQuerier_RefreshCostMonthlyTeam_Call struct {
	*mock.Call
}

MockQuerier_RefreshCostMonthlyTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshCostMonthlyTeam'

func (*MockQuerier_RefreshCostMonthlyTeam_Call) Return 

func (_c *MockQuerier_RefreshCostMonthlyTeam_Call) Return(_a0 error) *MockQuerier_RefreshCostMonthlyTeam_Call

func (*MockQuerier_RefreshCostMonthlyTeam_Call) Run 

func (_c *MockQuerier_RefreshCostMonthlyTeam_Call) Run(run func(ctx context.Context)) *MockQuerier_RefreshCostMonthlyTeam_Call

func (*MockQuerier_RefreshCostMonthlyTeam_Call) RunAndReturn 

func (_c *MockQuerier_RefreshCostMonthlyTeam_Call) RunAndReturn(run func(context.Context) error) *MockQuerier_RefreshCostMonthlyTeam_Call

type MockQuerier_RefreshResourceTeamRange_Call 

type MockQuerier_RefreshResourceTeamRange_Call struct {
	*mock.Call
}

MockQuerier_RefreshResourceTeamRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshResourceTeamRange'

func (*MockQuerier_RefreshResourceTeamRange_Call) Return 

func (_c *MockQuerier_RefreshResourceTeamRange_Call) Return(_a0 error) *MockQuerier_RefreshResourceTeamRange_Call

func (*MockQuerier_RefreshResourceTeamRange_Call) Run 

func (_c *MockQuerier_RefreshResourceTeamRange_Call) Run(run func(ctx context.Context)) *MockQuerier_RefreshResourceTeamRange_Call

func (*MockQuerier_RefreshResourceTeamRange_Call) RunAndReturn 

func (_c *MockQuerier_RefreshResourceTeamRange_Call) RunAndReturn(run func(context.Context) error) *MockQuerier_RefreshResourceTeamRange_Call

type MockQuerier_RemoveAllServiceAccountRoles_Call 

type MockQuerier_RemoveAllServiceAccountRoles_Call struct {
	*mock.Call
}

MockQuerier_RemoveAllServiceAccountRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllServiceAccountRoles'

func (*MockQuerier_RemoveAllServiceAccountRoles_Call) Return 

func (_c *MockQuerier_RemoveAllServiceAccountRoles_Call) Return(_a0 error) *MockQuerier_RemoveAllServiceAccountRoles_Call

func (*MockQuerier_RemoveAllServiceAccountRoles_Call) Run 

func (_c *MockQuerier_RemoveAllServiceAccountRoles_Call) Run(run func(ctx context.Context, serviceAccountID uuid.UUID)) *MockQuerier_RemoveAllServiceAccountRoles_Call

func (*MockQuerier_RemoveAllServiceAccountRoles_Call) RunAndReturn 

func (_c *MockQuerier_RemoveAllServiceAccountRoles_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockQuerier_RemoveAllServiceAccountRoles_Call

type MockQuerier_RemoveApiKeysFromServiceAccount_Call 

type MockQuerier_RemoveApiKeysFromServiceAccount_Call struct {
	*mock.Call
}

MockQuerier_RemoveApiKeysFromServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveApiKeysFromServiceAccount'

func (*MockQuerier_RemoveApiKeysFromServiceAccount_Call) Return 

func (_c *MockQuerier_RemoveApiKeysFromServiceAccount_Call) Return(_a0 error) *MockQuerier_RemoveApiKeysFromServiceAccount_Call

func (*MockQuerier_RemoveApiKeysFromServiceAccount_Call) Run 

func (_c *MockQuerier_RemoveApiKeysFromServiceAccount_Call) Run(run func(ctx context.Context, serviceAccountID uuid.UUID)) *MockQuerier_RemoveApiKeysFromServiceAccount_Call

func (*MockQuerier_RemoveApiKeysFromServiceAccount_Call) RunAndReturn 

func (_c *MockQuerier_RemoveApiKeysFromServiceAccount_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockQuerier_RemoveApiKeysFromServiceAccount_Call

type MockQuerier_RemoveReconcilerOptOut_Call 

type MockQuerier_RemoveReconcilerOptOut_Call struct {
	*mock.Call
}

MockQuerier_RemoveReconcilerOptOut_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveReconcilerOptOut'

func (*MockQuerier_RemoveReconcilerOptOut_Call) Return 

func (_c *MockQuerier_RemoveReconcilerOptOut_Call) Return(_a0 error) *MockQuerier_RemoveReconcilerOptOut_Call

func (*MockQuerier_RemoveReconcilerOptOut_Call) Run 

func (_c *MockQuerier_RemoveReconcilerOptOut_Call) Run(run func(ctx context.Context, arg RemoveReconcilerOptOutParams)) *MockQuerier_RemoveReconcilerOptOut_Call

func (*MockQuerier_RemoveReconcilerOptOut_Call) RunAndReturn 

func (_c *MockQuerier_RemoveReconcilerOptOut_Call) RunAndReturn(run func(context.Context, RemoveReconcilerOptOutParams) error) *MockQuerier_RemoveReconcilerOptOut_Call

type MockQuerier_RemoveRepositoryAuthorization_Call 

type MockQuerier_RemoveRepositoryAuthorization_Call struct {
	*mock.Call
}

MockQuerier_RemoveRepositoryAuthorization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRepositoryAuthorization'

func (*MockQuerier_RemoveRepositoryAuthorization_Call) Return 

func (_c *MockQuerier_RemoveRepositoryAuthorization_Call) Return(_a0 error) *MockQuerier_RemoveRepositoryAuthorization_Call

func (*MockQuerier_RemoveRepositoryAuthorization_Call) Run 

func (_c *MockQuerier_RemoveRepositoryAuthorization_Call) Run(run func(ctx context.Context, arg RemoveRepositoryAuthorizationParams)) *MockQuerier_RemoveRepositoryAuthorization_Call

func (*MockQuerier_RemoveRepositoryAuthorization_Call) RunAndReturn 

func (_c *MockQuerier_RemoveRepositoryAuthorization_Call) RunAndReturn(run func(context.Context, RemoveRepositoryAuthorizationParams) error) *MockQuerier_RemoveRepositoryAuthorization_Call

type MockQuerier_RemoveUserFromTeam_Call 

type MockQuerier_RemoveUserFromTeam_Call struct {
	*mock.Call
}

MockQuerier_RemoveUserFromTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveUserFromTeam'

func (*MockQuerier_RemoveUserFromTeam_Call) Return 

func (_c *MockQuerier_RemoveUserFromTeam_Call) Return(_a0 error) *MockQuerier_RemoveUserFromTeam_Call

func (*MockQuerier_RemoveUserFromTeam_Call) Run 

func (_c *MockQuerier_RemoveUserFromTeam_Call) Run(run func(ctx context.Context, arg RemoveUserFromTeamParams)) *MockQuerier_RemoveUserFromTeam_Call

func (*MockQuerier_RemoveUserFromTeam_Call) RunAndReturn 

func (_c *MockQuerier_RemoveUserFromTeam_Call) RunAndReturn(run func(context.Context, RemoveUserFromTeamParams) error) *MockQuerier_RemoveUserFromTeam_Call

type MockQuerier_ResetReconcilerConfig_Call 

type MockQuerier_ResetReconcilerConfig_Call struct {
	*mock.Call
}

MockQuerier_ResetReconcilerConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetReconcilerConfig'

func (*MockQuerier_ResetReconcilerConfig_Call) Return 

func (_c *MockQuerier_ResetReconcilerConfig_Call) Return(_a0 error) *MockQuerier_ResetReconcilerConfig_Call

func (*MockQuerier_ResetReconcilerConfig_Call) Run 

func (_c *MockQuerier_ResetReconcilerConfig_Call) Run(run func(ctx context.Context, reconcilerName string)) *MockQuerier_ResetReconcilerConfig_Call

func (*MockQuerier_ResetReconcilerConfig_Call) RunAndReturn 

func (_c *MockQuerier_ResetReconcilerConfig_Call) RunAndReturn(run func(context.Context, string) error) *MockQuerier_ResetReconcilerConfig_Call

type MockQuerier_ResourceUtilizationForApp_Call 

type MockQuerier_ResourceUtilizationForApp_Call struct {
	*mock.Call
}

MockQuerier_ResourceUtilizationForApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationForApp'

func (*MockQuerier_ResourceUtilizationForApp_Call) Return 

func (_c *MockQuerier_ResourceUtilizationForApp_Call) Return(_a0 []*ResourceUtilizationMetric, _a1 error) *MockQuerier_ResourceUtilizationForApp_Call

func (*MockQuerier_ResourceUtilizationForApp_Call) Run 

func (_c *MockQuerier_ResourceUtilizationForApp_Call) Run(run func(ctx context.Context, arg ResourceUtilizationForAppParams)) *MockQuerier_ResourceUtilizationForApp_Call

func (*MockQuerier_ResourceUtilizationForApp_Call) RunAndReturn 

func (_c *MockQuerier_ResourceUtilizationForApp_Call) RunAndReturn(run func(context.Context, ResourceUtilizationForAppParams) ([]*ResourceUtilizationMetric, error)) *MockQuerier_ResourceUtilizationForApp_Call

type MockQuerier_ResourceUtilizationForTeam_Call 

type MockQuerier_ResourceUtilizationForTeam_Call struct {
	*mock.Call
}

MockQuerier_ResourceUtilizationForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationForTeam'

func (*MockQuerier_ResourceUtilizationForTeam_Call) Return 

func (_c *MockQuerier_ResourceUtilizationForTeam_Call) Return(_a0 []*ResourceUtilizationForTeamRow, _a1 error) *MockQuerier_ResourceUtilizationForTeam_Call

func (*MockQuerier_ResourceUtilizationForTeam_Call) Run 

func (_c *MockQuerier_ResourceUtilizationForTeam_Call) Run(run func(ctx context.Context, arg ResourceUtilizationForTeamParams)) *MockQuerier_ResourceUtilizationForTeam_Call

func (*MockQuerier_ResourceUtilizationForTeam_Call) RunAndReturn 

func (_c *MockQuerier_ResourceUtilizationForTeam_Call) RunAndReturn(run func(context.Context, ResourceUtilizationForTeamParams) ([]*ResourceUtilizationForTeamRow, error)) *MockQuerier_ResourceUtilizationForTeam_Call

type MockQuerier_ResourceUtilizationOverageForTeam_Call 

type MockQuerier_ResourceUtilizationOverageForTeam_Call struct {
	*mock.Call
}

MockQuerier_ResourceUtilizationOverageForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationOverageForTeam'

func (*MockQuerier_ResourceUtilizationOverageForTeam_Call) Return 

func (_c *MockQuerier_ResourceUtilizationOverageForTeam_Call) Return(_a0 []*ResourceUtilizationOverageForTeamRow, _a1 error) *MockQuerier_ResourceUtilizationOverageForTeam_Call

func (*MockQuerier_ResourceUtilizationOverageForTeam_Call) Run 

func (_c *MockQuerier_ResourceUtilizationOverageForTeam_Call) Run(run func(ctx context.Context, arg ResourceUtilizationOverageForTeamParams)) *MockQuerier_ResourceUtilizationOverageForTeam_Call

func (*MockQuerier_ResourceUtilizationOverageForTeam_Call) RunAndReturn 

func (_c *MockQuerier_ResourceUtilizationOverageForTeam_Call) RunAndReturn(run func(context.Context, ResourceUtilizationOverageForTeamParams) ([]*ResourceUtilizationOverageForTeamRow, error)) *MockQuerier_ResourceUtilizationOverageForTeam_Call

type MockQuerier_ResourceUtilizationRangeForApp_Call 

type MockQuerier_ResourceUtilizationRangeForApp_Call struct {
	*mock.Call
}

MockQuerier_ResourceUtilizationRangeForApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationRangeForApp'

func (*MockQuerier_ResourceUtilizationRangeForApp_Call) Return 

func (_c *MockQuerier_ResourceUtilizationRangeForApp_Call) Return(_a0 *ResourceUtilizationRangeForAppRow, _a1 error) *MockQuerier_ResourceUtilizationRangeForApp_Call

func (*MockQuerier_ResourceUtilizationRangeForApp_Call) Run 

func (_c *MockQuerier_ResourceUtilizationRangeForApp_Call) Run(run func(ctx context.Context, arg ResourceUtilizationRangeForAppParams)) *MockQuerier_ResourceUtilizationRangeForApp_Call

func (*MockQuerier_ResourceUtilizationRangeForApp_Call) RunAndReturn 

func (_c *MockQuerier_ResourceUtilizationRangeForApp_Call) RunAndReturn(run func(context.Context, ResourceUtilizationRangeForAppParams) (*ResourceUtilizationRangeForAppRow, error)) *MockQuerier_ResourceUtilizationRangeForApp_Call

type MockQuerier_ResourceUtilizationRangeForTeam_Call 

type MockQuerier_ResourceUtilizationRangeForTeam_Call struct {
	*mock.Call
}

MockQuerier_ResourceUtilizationRangeForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationRangeForTeam'

func (*MockQuerier_ResourceUtilizationRangeForTeam_Call) Return 

func (_c *MockQuerier_ResourceUtilizationRangeForTeam_Call) Return(_a0 *ResourceUtilizationRangeForTeamRow, _a1 error) *MockQuerier_ResourceUtilizationRangeForTeam_Call

func (*MockQuerier_ResourceUtilizationRangeForTeam_Call) Run 

func (_c *MockQuerier_ResourceUtilizationRangeForTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockQuerier_ResourceUtilizationRangeForTeam_Call

func (*MockQuerier_ResourceUtilizationRangeForTeam_Call) RunAndReturn 

func (_c *MockQuerier_ResourceUtilizationRangeForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) (*ResourceUtilizationRangeForTeamRow, error)) *MockQuerier_ResourceUtilizationRangeForTeam_Call

type MockQuerier_ResourceUtilizationUpsert_Call 

type MockQuerier_ResourceUtilizationUpsert_Call struct {
	*mock.Call
}

MockQuerier_ResourceUtilizationUpsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationUpsert'

func (*MockQuerier_ResourceUtilizationUpsert_Call) Return 

func (_c *MockQuerier_ResourceUtilizationUpsert_Call) Return(_a0 *ResourceUtilizationUpsertBatchResults) *MockQuerier_ResourceUtilizationUpsert_Call

func (*MockQuerier_ResourceUtilizationUpsert_Call) Run 

func (_c *MockQuerier_ResourceUtilizationUpsert_Call) Run(run func(ctx context.Context, arg []ResourceUtilizationUpsertParams)) *MockQuerier_ResourceUtilizationUpsert_Call

func (*MockQuerier_ResourceUtilizationUpsert_Call) RunAndReturn 

func (_c *MockQuerier_ResourceUtilizationUpsert_Call) RunAndReturn(run func(context.Context, []ResourceUtilizationUpsertParams) *ResourceUtilizationUpsertBatchResults) *MockQuerier_ResourceUtilizationUpsert_Call

type MockQuerier_RevokeGlobalUserRole_Call 

type MockQuerier_RevokeGlobalUserRole_Call struct {
	*mock.Call
}

MockQuerier_RevokeGlobalUserRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeGlobalUserRole'

func (*MockQuerier_RevokeGlobalUserRole_Call) Return 

func (_c *MockQuerier_RevokeGlobalUserRole_Call) Return(_a0 error) *MockQuerier_RevokeGlobalUserRole_Call

func (*MockQuerier_RevokeGlobalUserRole_Call) Run 

func (_c *MockQuerier_RevokeGlobalUserRole_Call) Run(run func(ctx context.Context, arg RevokeGlobalUserRoleParams)) *MockQuerier_RevokeGlobalUserRole_Call

func (*MockQuerier_RevokeGlobalUserRole_Call) RunAndReturn 

func (_c *MockQuerier_RevokeGlobalUserRole_Call) RunAndReturn(run func(context.Context, RevokeGlobalUserRoleParams) error) *MockQuerier_RevokeGlobalUserRole_Call

type MockQuerier_SetLastSuccessfulSyncForTeam_Call 

type MockQuerier_SetLastSuccessfulSyncForTeam_Call struct {
	*mock.Call
}

MockQuerier_SetLastSuccessfulSyncForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLastSuccessfulSyncForTeam'

func (*MockQuerier_SetLastSuccessfulSyncForTeam_Call) Return 

func (_c *MockQuerier_SetLastSuccessfulSyncForTeam_Call) Return(_a0 error) *MockQuerier_SetLastSuccessfulSyncForTeam_Call

func (*MockQuerier_SetLastSuccessfulSyncForTeam_Call) Run 

func (_c *MockQuerier_SetLastSuccessfulSyncForTeam_Call) Run(run func(ctx context.Context, argSlug slug.Slug)) *MockQuerier_SetLastSuccessfulSyncForTeam_Call

func (*MockQuerier_SetLastSuccessfulSyncForTeam_Call) RunAndReturn 

func (_c *MockQuerier_SetLastSuccessfulSyncForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) error) *MockQuerier_SetLastSuccessfulSyncForTeam_Call

type MockQuerier_SetReconcilerErrorForTeam_Call 

type MockQuerier_SetReconcilerErrorForTeam_Call struct {
	*mock.Call
}

MockQuerier_SetReconcilerErrorForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetReconcilerErrorForTeam'

func (*MockQuerier_SetReconcilerErrorForTeam_Call) Return 

func (_c *MockQuerier_SetReconcilerErrorForTeam_Call) Return(_a0 error) *MockQuerier_SetReconcilerErrorForTeam_Call

func (*MockQuerier_SetReconcilerErrorForTeam_Call) Run 

func (_c *MockQuerier_SetReconcilerErrorForTeam_Call) Run(run func(ctx context.Context, arg SetReconcilerErrorForTeamParams)) *MockQuerier_SetReconcilerErrorForTeam_Call

func (*MockQuerier_SetReconcilerErrorForTeam_Call) RunAndReturn 

func (_c *MockQuerier_SetReconcilerErrorForTeam_Call) RunAndReturn(run func(context.Context, SetReconcilerErrorForTeamParams) error) *MockQuerier_SetReconcilerErrorForTeam_Call

type MockQuerier_SetSessionExpires_Call 

type MockQuerier_SetSessionExpires_Call struct {
	*mock.Call
}

MockQuerier_SetSessionExpires_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSessionExpires'

func (*MockQuerier_SetSessionExpires_Call) Return 

func (_c *MockQuerier_SetSessionExpires_Call) Return(_a0 *Session, _a1 error) *MockQuerier_SetSessionExpires_Call

func (*MockQuerier_SetSessionExpires_Call) Run 

func (_c *MockQuerier_SetSessionExpires_Call) Run(run func(ctx context.Context, arg SetSessionExpiresParams)) *MockQuerier_SetSessionExpires_Call

func (*MockQuerier_SetSessionExpires_Call) RunAndReturn 

func (_c *MockQuerier_SetSessionExpires_Call) RunAndReturn(run func(context.Context, SetSessionExpiresParams) (*Session, error)) *MockQuerier_SetSessionExpires_Call

type MockQuerier_SpecificResourceUtilizationForApp_Call 

type MockQuerier_SpecificResourceUtilizationForApp_Call struct {
	*mock.Call
}

MockQuerier_SpecificResourceUtilizationForApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SpecificResourceUtilizationForApp'

func (*MockQuerier_SpecificResourceUtilizationForApp_Call) Return 

func (_c *MockQuerier_SpecificResourceUtilizationForApp_Call) Return(_a0 *SpecificResourceUtilizationForAppRow, _a1 error) *MockQuerier_SpecificResourceUtilizationForApp_Call

func (*MockQuerier_SpecificResourceUtilizationForApp_Call) Run 

func (_c *MockQuerier_SpecificResourceUtilizationForApp_Call) Run(run func(ctx context.Context, arg SpecificResourceUtilizationForAppParams)) *MockQuerier_SpecificResourceUtilizationForApp_Call

func (*MockQuerier_SpecificResourceUtilizationForApp_Call) RunAndReturn 

func (_c *MockQuerier_SpecificResourceUtilizationForApp_Call) RunAndReturn(run func(context.Context, SpecificResourceUtilizationForAppParams) (*SpecificResourceUtilizationForAppRow, error)) *MockQuerier_SpecificResourceUtilizationForApp_Call

type MockQuerier_SpecificResourceUtilizationForTeam_Call 

type MockQuerier_SpecificResourceUtilizationForTeam_Call struct {
	*mock.Call
}

MockQuerier_SpecificResourceUtilizationForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SpecificResourceUtilizationForTeam'

func (*MockQuerier_SpecificResourceUtilizationForTeam_Call) Return 

func (_c *MockQuerier_SpecificResourceUtilizationForTeam_Call) Return(_a0 []*SpecificResourceUtilizationForTeamRow, _a1 error) *MockQuerier_SpecificResourceUtilizationForTeam_Call

func (*MockQuerier_SpecificResourceUtilizationForTeam_Call) Run 

func (_c *MockQuerier_SpecificResourceUtilizationForTeam_Call) Run(run func(ctx context.Context, arg SpecificResourceUtilizationForTeamParams)) *MockQuerier_SpecificResourceUtilizationForTeam_Call

func (*MockQuerier_SpecificResourceUtilizationForTeam_Call) RunAndReturn 

func (_c *MockQuerier_SpecificResourceUtilizationForTeam_Call) RunAndReturn(run func(context.Context, SpecificResourceUtilizationForTeamParams) ([]*SpecificResourceUtilizationForTeamRow, error)) *MockQuerier_SpecificResourceUtilizationForTeam_Call

type MockQuerier_TeamExists_Call 

type MockQuerier_TeamExists_Call struct {
	*mock.Call
}

MockQuerier_TeamExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TeamExists'

func (*MockQuerier_TeamExists_Call) Return 

func (_c *MockQuerier_TeamExists_Call) Return(_a0 bool, _a1 error) *MockQuerier_TeamExists_Call

func (*MockQuerier_TeamExists_Call) Run 

func (_c *MockQuerier_TeamExists_Call) Run(run func(ctx context.Context, argSlug slug.Slug)) *MockQuerier_TeamExists_Call

func (*MockQuerier_TeamExists_Call) RunAndReturn 

func (_c *MockQuerier_TeamExists_Call) RunAndReturn(run func(context.Context, slug.Slug) (bool, error)) *MockQuerier_TeamExists_Call

type MockQuerier_UpdateTeamExternalReferences_Call 

type MockQuerier_UpdateTeamExternalReferences_Call struct {
	*mock.Call
}

MockQuerier_UpdateTeamExternalReferences_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTeamExternalReferences'

func (*MockQuerier_UpdateTeamExternalReferences_Call) Return 

func (_c *MockQuerier_UpdateTeamExternalReferences_Call) Return(_a0 *Team, _a1 error) *MockQuerier_UpdateTeamExternalReferences_Call

func (*MockQuerier_UpdateTeamExternalReferences_Call) Run 

func (_c *MockQuerier_UpdateTeamExternalReferences_Call) Run(run func(ctx context.Context, arg UpdateTeamExternalReferencesParams)) *MockQuerier_UpdateTeamExternalReferences_Call

func (*MockQuerier_UpdateTeamExternalReferences_Call) RunAndReturn 

func (_c *MockQuerier_UpdateTeamExternalReferences_Call) RunAndReturn(run func(context.Context, UpdateTeamExternalReferencesParams) (*Team, error)) *MockQuerier_UpdateTeamExternalReferences_Call

type MockQuerier_UpdateTeam_Call 

type MockQuerier_UpdateTeam_Call struct {
	*mock.Call
}

MockQuerier_UpdateTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTeam'

func (*MockQuerier_UpdateTeam_Call) Return 

func (_c *MockQuerier_UpdateTeam_Call) Return(_a0 *Team, _a1 error) *MockQuerier_UpdateTeam_Call

func (*MockQuerier_UpdateTeam_Call) Run 

func (_c *MockQuerier_UpdateTeam_Call) Run(run func(ctx context.Context, arg UpdateTeamParams)) *MockQuerier_UpdateTeam_Call

func (*MockQuerier_UpdateTeam_Call) RunAndReturn 

func (_c *MockQuerier_UpdateTeam_Call) RunAndReturn(run func(context.Context, UpdateTeamParams) (*Team, error)) *MockQuerier_UpdateTeam_Call

type MockQuerier_UpdateUser_Call 

type MockQuerier_UpdateUser_Call struct {
	*mock.Call
}

MockQuerier_UpdateUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUser'

func (*MockQuerier_UpdateUser_Call) Return 

func (_c *MockQuerier_UpdateUser_Call) Return(_a0 *User, _a1 error) *MockQuerier_UpdateUser_Call

func (*MockQuerier_UpdateUser_Call) Run 

func (_c *MockQuerier_UpdateUser_Call) Run(run func(ctx context.Context, arg UpdateUserParams)) *MockQuerier_UpdateUser_Call

func (*MockQuerier_UpdateUser_Call) RunAndReturn 

func (_c *MockQuerier_UpdateUser_Call) RunAndReturn(run func(context.Context, UpdateUserParams) (*User, error)) *MockQuerier_UpdateUser_Call

type MockQuerier_UpsertReconcilerConfig_Call 

type MockQuerier_UpsertReconcilerConfig_Call struct {
	*mock.Call
}

MockQuerier_UpsertReconcilerConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertReconcilerConfig'

func (*MockQuerier_UpsertReconcilerConfig_Call) Return 

func (_c *MockQuerier_UpsertReconcilerConfig_Call) Return(_a0 error) *MockQuerier_UpsertReconcilerConfig_Call

func (*MockQuerier_UpsertReconcilerConfig_Call) Run 

func (_c *MockQuerier_UpsertReconcilerConfig_Call) Run(run func(ctx context.Context, arg UpsertReconcilerConfigParams)) *MockQuerier_UpsertReconcilerConfig_Call

func (*MockQuerier_UpsertReconcilerConfig_Call) RunAndReturn 

func (_c *MockQuerier_UpsertReconcilerConfig_Call) RunAndReturn(run func(context.Context, UpsertReconcilerConfigParams) error) *MockQuerier_UpsertReconcilerConfig_Call

type MockQuerier_UpsertReconcilerState_Call 

type MockQuerier_UpsertReconcilerState_Call struct {
	*mock.Call
}

MockQuerier_UpsertReconcilerState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertReconcilerState'

func (*MockQuerier_UpsertReconcilerState_Call) Return 

func (_c *MockQuerier_UpsertReconcilerState_Call) Return(_a0 *ReconcilerState, _a1 error) *MockQuerier_UpsertReconcilerState_Call

func (*MockQuerier_UpsertReconcilerState_Call) Run 

func (_c *MockQuerier_UpsertReconcilerState_Call) Run(run func(ctx context.Context, arg UpsertReconcilerStateParams)) *MockQuerier_UpsertReconcilerState_Call

func (*MockQuerier_UpsertReconcilerState_Call) RunAndReturn 

func (_c *MockQuerier_UpsertReconcilerState_Call) RunAndReturn(run func(context.Context, UpsertReconcilerStateParams) (*ReconcilerState, error)) *MockQuerier_UpsertReconcilerState_Call

type MockQuerier_UpsertReconciler_Call 

type MockQuerier_UpsertReconciler_Call struct {
	*mock.Call
}

MockQuerier_UpsertReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertReconciler'

func (*MockQuerier_UpsertReconciler_Call) Return 

func (_c *MockQuerier_UpsertReconciler_Call) Return(_a0 *Reconciler, _a1 error) *MockQuerier_UpsertReconciler_Call

func (*MockQuerier_UpsertReconciler_Call) Run 

func (_c *MockQuerier_UpsertReconciler_Call) Run(run func(ctx context.Context, arg UpsertReconcilerParams)) *MockQuerier_UpsertReconciler_Call

func (*MockQuerier_UpsertReconciler_Call) RunAndReturn 

func (_c *MockQuerier_UpsertReconciler_Call) RunAndReturn(run func(context.Context, UpsertReconcilerParams) (*Reconciler, error)) *MockQuerier_UpsertReconciler_Call

type MockQuerier_UpsertTeamEnvironment_Call 

type MockQuerier_UpsertTeamEnvironment_Call struct {
	*mock.Call
}

MockQuerier_UpsertTeamEnvironment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertTeamEnvironment'

func (*MockQuerier_UpsertTeamEnvironment_Call) Return 

func (_c *MockQuerier_UpsertTeamEnvironment_Call) Return(_a0 *TeamEnvironment, _a1 error) *MockQuerier_UpsertTeamEnvironment_Call

func (*MockQuerier_UpsertTeamEnvironment_Call) Run 

func (_c *MockQuerier_UpsertTeamEnvironment_Call) Run(run func(ctx context.Context, arg UpsertTeamEnvironmentParams)) *MockQuerier_UpsertTeamEnvironment_Call

func (*MockQuerier_UpsertTeamEnvironment_Call) RunAndReturn 

func (_c *MockQuerier_UpsertTeamEnvironment_Call) RunAndReturn(run func(context.Context, UpsertTeamEnvironmentParams) (*TeamEnvironment, error)) *MockQuerier_UpsertTeamEnvironment_Call

type MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call 

type MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call struct {
	*mock.Call
}

MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VulnerabilityMetricsDateRangeForTeam'

func (*MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call) Return 

func (_c *MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call) Return(_a0 *VulnerabilityMetricsDateRangeForTeamRow, _a1 error) *MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call

func (*MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call) Run 

func (_c *MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call

func (*MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call) RunAndReturn 

func (_c *MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) (*VulnerabilityMetricsDateRangeForTeamRow, error)) *MockQuerier_VulnerabilityMetricsDateRangeForTeam_Call

type MockQuerier_VulnerabilityMetricsMaxDate_Call 

type MockQuerier_VulnerabilityMetricsMaxDate_Call struct {
	*mock.Call
}

MockQuerier_VulnerabilityMetricsMaxDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VulnerabilityMetricsMaxDate'

func (*MockQuerier_VulnerabilityMetricsMaxDate_Call) Return 

func (_c *MockQuerier_VulnerabilityMetricsMaxDate_Call) Return(_a0 pgtype.Date, _a1 error) *MockQuerier_VulnerabilityMetricsMaxDate_Call

func (*MockQuerier_VulnerabilityMetricsMaxDate_Call) Run 

func (_c *MockQuerier_VulnerabilityMetricsMaxDate_Call) Run(run func(ctx context.Context, arg VulnerabilityMetricsMaxDateParams)) *MockQuerier_VulnerabilityMetricsMaxDate_Call

func (*MockQuerier_VulnerabilityMetricsMaxDate_Call) RunAndReturn 

func (_c *MockQuerier_VulnerabilityMetricsMaxDate_Call) RunAndReturn(run func(context.Context, VulnerabilityMetricsMaxDateParams) (pgtype.Date, error)) *MockQuerier_VulnerabilityMetricsMaxDate_Call

type MockQuerier_VulnerabilityMetricsUpsert_Call 

type MockQuerier_VulnerabilityMetricsUpsert_Call struct {
	*mock.Call
}

MockQuerier_VulnerabilityMetricsUpsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VulnerabilityMetricsUpsert'

func (*MockQuerier_VulnerabilityMetricsUpsert_Call) Return 

func (_c *MockQuerier_VulnerabilityMetricsUpsert_Call) Return(_a0 *VulnerabilityMetricsUpsertBatchResults) *MockQuerier_VulnerabilityMetricsUpsert_Call

func (*MockQuerier_VulnerabilityMetricsUpsert_Call) Run 

func (_c *MockQuerier_VulnerabilityMetricsUpsert_Call) Run(run func(ctx context.Context, arg []VulnerabilityMetricsUpsertParams)) *MockQuerier_VulnerabilityMetricsUpsert_Call

func (*MockQuerier_VulnerabilityMetricsUpsert_Call) RunAndReturn 

func (_c *MockQuerier_VulnerabilityMetricsUpsert_Call) RunAndReturn(run func(context.Context, []VulnerabilityMetricsUpsertParams) *VulnerabilityMetricsUpsertBatchResults) *MockQuerier_VulnerabilityMetricsUpsert_Call

type MonthlyCostForAppParams 

type MonthlyCostForAppParams struct {
	TeamSlug    slug.Slug
	App         string
	Environment string
}

type MonthlyCostForAppRow 

type MonthlyCostForAppRow struct {
	TeamSlug         slug.Slug
	App              string
	Environment      *string
	Month            pgtype.Date
	LastRecordedDate pgtype.Date
	DailyCost        float32
}

type NullRepositoryAuthorizationEnum 

type NullRepositoryAuthorizationEnum struct {
	RepositoryAuthorizationEnum RepositoryAuthorizationEnum
	Valid                       bool // Valid is true if RepositoryAuthorizationEnum is not NULL
}

func (*NullRepositoryAuthorizationEnum) Scan 

func (ns *NullRepositoryAuthorizationEnum) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullRepositoryAuthorizationEnum) Value 

func (ns NullRepositoryAuthorizationEnum) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullResourceType 

type NullResourceType struct {
	ResourceType ResourceType
	Valid        bool // Valid is true if ResourceType is not NULL
}

func (*NullResourceType) Scan 

func (ns *NullResourceType) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullResourceType) Value 

func (ns NullResourceType) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type NullRoleName 

type NullRoleName struct {
	RoleName RoleName
	Valid    bool // Valid is true if RoleName is not NULL
}

func (*NullRoleName) Scan 

func (ns *NullRoleName) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullRoleName) Value 

func (ns NullRoleName) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type Querier 

type Querier interface {
	AddReconcilerOptOut(ctx context.Context, arg AddReconcilerOptOutParams) error
	AssignGlobalRoleToServiceAccount(ctx context.Context, arg AssignGlobalRoleToServiceAccountParams) error
	AssignGlobalRoleToUser(ctx context.Context, arg AssignGlobalRoleToUserParams) error
	AssignTeamRoleToServiceAccount(ctx context.Context, arg AssignTeamRoleToServiceAccountParams) error
	AssignTeamRoleToUser(ctx context.Context, arg AssignTeamRoleToUserParams) error
	// AverageResourceUtilizationForTeam will return the average resource utilization for a team for a week.
	AverageResourceUtilizationForTeam(ctx context.Context, arg AverageResourceUtilizationForTeamParams) (*AverageResourceUtilizationForTeamRow, error)
	ClearReconcilerErrorsForTeam(ctx context.Context, arg ClearReconcilerErrorsForTeamParams) error
	ConfigureReconciler(ctx context.Context, arg ConfigureReconcilerParams) error
	ConfirmTeamDeleteKey(ctx context.Context, key uuid.UUID) error
	CostForSqlInstance(ctx context.Context, arg CostForSqlInstanceParams) (float32, error)
	// CostUpsert will insert or update a cost record. If there is a conflict on the daily_cost_key constrant, the
	// daily_cost column will be updated.
	CostUpsert(ctx context.Context, arg []CostUpsertParams) *CostUpsertBatchResults
	CreateAPIKey(ctx context.Context, arg CreateAPIKeyParams) error
	CreateAuditLog(ctx context.Context, arg CreateAuditLogParams) error
	CreateDependencytrackProject(ctx context.Context, arg CreateDependencytrackProjectParams) error
	CreateRepositoryAuthorization(ctx context.Context, arg CreateRepositoryAuthorizationParams) error
	CreateServiceAccount(ctx context.Context, name string) (*ServiceAccount, error)
	CreateSession(ctx context.Context, arg CreateSessionParams) (*Session, error)
	CreateTeam(ctx context.Context, arg CreateTeamParams) (*Team, error)
	CreateTeamDeleteKey(ctx context.Context, arg CreateTeamDeleteKeyParams) (*TeamDeleteKey, error)
	CreateUser(ctx context.Context, arg CreateUserParams) (*User, error)
	CurrentSqlInstancesCostForTeam(ctx context.Context, arg CurrentSqlInstancesCostForTeamParams) (float32, error)
	// DailyCostForApp will fetch the daily cost for a specific team app in a specific environment, across all cost types
	// in a date range.
	DailyCostForApp(ctx context.Context, arg DailyCostForAppParams) ([]*Cost, error)
	// DailyCostForTeam will fetch the daily cost for a specific team across all apps and envs in a date range.
	DailyCostForTeam(ctx context.Context, arg DailyCostForTeamParams) ([]*Cost, error)
	// DailyEnvCostForTeam will fetch the daily cost for a specific team and environment across all apps in a date range.
	DailyEnvCostForTeam(ctx context.Context, arg DailyEnvCostForTeamParams) ([]*DailyEnvCostForTeamRow, error)
	// DailyVulnerabilityForTeam will return the metrics for the given team from first to last date.
	DailyVulnerabilityForTeam(ctx context.Context, arg DailyVulnerabilityForTeamParams) ([]*DailyVulnerabilityForTeamRow, error)
	// DailyVulnerabilityForTeamAndEnvironment will return the metrics for the given team and environment from first to last date.
	DailyVulnerabilityForTeamAndEnvironment(ctx context.Context, arg DailyVulnerabilityForTeamAndEnvironmentParams) ([]*DailyVulnerabilityForTeamAndEnvironmentRow, error)
	DeleteAllEnvironments(ctx context.Context) error
	DeleteReconcilerConfig(ctx context.Context, arg DeleteReconcilerConfigParams) error
	DeleteReconcilerStateForTeam(ctx context.Context, arg DeleteReconcilerStateForTeamParams) error
	DeleteServiceAccount(ctx context.Context, id uuid.UUID) error
	DeleteSession(ctx context.Context, id uuid.UUID) error
	DeleteTeam(ctx context.Context, argSlug slug.Slug) error
	DeleteUser(ctx context.Context, id uuid.UUID) error
	DisableReconciler(ctx context.Context, name string) (*Reconciler, error)
	EnableReconciler(ctx context.Context, name string) (*Reconciler, error)
	GetActiveTeamBySlug(ctx context.Context, argSlug slug.Slug) (*Team, error)
	GetActiveTeams(ctx context.Context) ([]*Team, error)
	GetAllTeamMembers(ctx context.Context, teamSlug *slug.Slug) ([]*User, error)
	GetAllTeamSlugs(ctx context.Context) ([]slug.Slug, error)
	GetAllUserRoles(ctx context.Context) ([]*UserRole, error)
	GetAuditLogsForCorrelationID(ctx context.Context, arg GetAuditLogsForCorrelationIDParams) ([]*AuditLog, error)
	GetAuditLogsForCorrelationIDCount(ctx context.Context, correlationID uuid.UUID) (int64, error)
	GetAuditLogsForReconciler(ctx context.Context, arg GetAuditLogsForReconcilerParams) ([]*AuditLog, error)
	GetAuditLogsForReconcilerCount(ctx context.Context, targetIdentifier string) (int64, error)
	GetAuditLogsForTeam(ctx context.Context, arg GetAuditLogsForTeamParams) ([]*AuditLog, error)
	GetAuditLogsForTeamCount(ctx context.Context, targetIdentifier string) (int64, error)
	GetEnabledReconcilers(ctx context.Context) ([]*Reconciler, error)
	GetReconciler(ctx context.Context, name string) (*Reconciler, error)
	GetReconcilerConfig(ctx context.Context, arg GetReconcilerConfigParams) ([]*GetReconcilerConfigRow, error)
	GetReconcilerState(ctx context.Context, reconcilerName string) ([]*GetReconcilerStateRow, error)
	GetReconcilerStateForTeam(ctx context.Context, arg GetReconcilerStateForTeamParams) (*ReconcilerState, error)
	GetReconcilers(ctx context.Context, arg GetReconcilersParams) ([]*Reconciler, error)
	GetReconcilersCount(ctx context.Context) (int64, error)
	GetRepositoryAuthorizations(ctx context.Context, arg GetRepositoryAuthorizationsParams) ([]RepositoryAuthorizationEnum, error)
	GetServiceAccountByApiKey(ctx context.Context, apiKey string) (*ServiceAccount, error)
	GetServiceAccountByName(ctx context.Context, name string) (*ServiceAccount, error)
	GetServiceAccountRoles(ctx context.Context, serviceAccountID uuid.UUID) ([]*ServiceAccountRole, error)
	GetServiceAccounts(ctx context.Context) ([]*ServiceAccount, error)
	GetServiceAccountsByIDs(ctx context.Context, ids []uuid.UUID) ([]*ServiceAccount, error)
	GetSessionByID(ctx context.Context, id uuid.UUID) (*Session, error)
	GetTeamBySlug(ctx context.Context, argSlug slug.Slug) (*Team, error)
	GetTeamBySlugs(ctx context.Context, slugs []slug.Slug) ([]*Team, error)
	GetTeamDeleteKey(ctx context.Context, key uuid.UUID) (*TeamDeleteKey, error)
	GetTeamEnvironments(ctx context.Context, arg GetTeamEnvironmentsParams) ([]*TeamAllEnvironment, error)
	// Input is two arrays of equal length, one for slugs and one for names
	GetTeamEnvironmentsBySlugsAndEnvNames(ctx context.Context, arg GetTeamEnvironmentsBySlugsAndEnvNamesParams) ([]*TeamAllEnvironment, error)
	GetTeamEnvironmentsCount(ctx context.Context, teamSlug slug.Slug) (int64, error)
	GetTeamMember(ctx context.Context, arg GetTeamMemberParams) (*User, error)
	GetTeamMemberOptOuts(ctx context.Context, arg GetTeamMemberOptOutsParams) ([]*GetTeamMemberOptOutsRow, error)
	GetTeamMembers(ctx context.Context, arg GetTeamMembersParams) ([]*User, error)
	GetTeamMembersCount(ctx context.Context, teamSlug *slug.Slug) (int64, error)
	GetTeamMembersForReconciler(ctx context.Context, arg GetTeamMembersForReconcilerParams) ([]*User, error)
	GetTeamReconcilerErrors(ctx context.Context, teamSlug slug.Slug) ([]*ReconcilerError, error)
	GetTeams(ctx context.Context, arg GetTeamsParams) ([]*Team, error)
	GetTeamsCount(ctx context.Context) (int64, error)
	GetUserByEmail(ctx context.Context, email string) (*User, error)
	GetUserByExternalID(ctx context.Context, externalID string) (*User, error)
	GetUserByID(ctx context.Context, id uuid.UUID) (*User, error)
	GetUserRoles(ctx context.Context, userID uuid.UUID) ([]*UserRole, error)
	GetUserRolesForUsers(ctx context.Context, userIds []uuid.UUID) ([]*GetUserRolesForUsersRow, error)
	GetUserTeams(ctx context.Context, userID uuid.UUID) ([]*GetUserTeamsRow, error)
	GetUserTeamsCount(ctx context.Context, userID uuid.UUID) (int64, error)
	GetUserTeamsPaginated(ctx context.Context, arg GetUserTeamsPaginatedParams) ([]*GetUserTeamsPaginatedRow, error)
	GetUsers(ctx context.Context, arg GetUsersParams) ([]*User, error)
	GetUsersByIDs(ctx context.Context, ids []uuid.UUID) ([]*User, error)
	GetUsersCount(ctx context.Context) (int64, error)
	GetUsersWithGloballyAssignedRole(ctx context.Context, roleName RoleName) ([]*User, error)
	InsertEnvironment(ctx context.Context, arg InsertEnvironmentParams) error
	// LastCostDate will return the last date that has a cost.
	LastCostDate(ctx context.Context) (pgtype.Date, error)
	ListRepositoriesByAuthorization(ctx context.Context, arg ListRepositoriesByAuthorizationParams) ([]string, error)
	// MaxResourceUtilizationDate will return the max date for resource utilization records.
	MaxResourceUtilizationDate(ctx context.Context) (pgtype.Timestamptz, error)
	MonthlyCostForApp(ctx context.Context, arg MonthlyCostForAppParams) ([]*MonthlyCostForAppRow, error)
	MonthlyCostForTeam(ctx context.Context, teamSlug slug.Slug) ([]*CostMonthlyTeam, error)
	RefreshCostMonthlyTeam(ctx context.Context) error
	// Refresh materialized view resource_team_range
	RefreshResourceTeamRange(ctx context.Context) error
	RemoveAllServiceAccountRoles(ctx context.Context, serviceAccountID uuid.UUID) error
	RemoveApiKeysFromServiceAccount(ctx context.Context, serviceAccountID uuid.UUID) error
	RemoveReconcilerOptOut(ctx context.Context, arg RemoveReconcilerOptOutParams) error
	RemoveRepositoryAuthorization(ctx context.Context, arg RemoveRepositoryAuthorizationParams) error
	RemoveUserFromTeam(ctx context.Context, arg RemoveUserFromTeamParams) error
	ResetReconcilerConfig(ctx context.Context, reconcilerName string) error
	// ResourceUtilizationForApp will return resource utilization records for a given app.
	ResourceUtilizationForApp(ctx context.Context, arg ResourceUtilizationForAppParams) ([]*ResourceUtilizationMetric, error)
	// ResourceUtilizationForTeam will return resource utilization records for a given team.
	ResourceUtilizationForTeam(ctx context.Context, arg ResourceUtilizationForTeamParams) ([]*ResourceUtilizationForTeamRow, error)
	// ResourceUtilizationOverageForTeam will return overage records for a given team, ordered by overage descending.
	ResourceUtilizationOverageForTeam(ctx context.Context, arg ResourceUtilizationOverageForTeamParams) ([]*ResourceUtilizationOverageForTeamRow, error)
	// ResourceUtilizationRangeForApp will return the min and max timestamps for a specific app.
	ResourceUtilizationRangeForApp(ctx context.Context, arg ResourceUtilizationRangeForAppParams) (*ResourceUtilizationRangeForAppRow, error)
	// ResourceUtilizationRangeForTeam will return the min and max timestamps for a specific team.
	ResourceUtilizationRangeForTeam(ctx context.Context, teamSlug slug.Slug) (*ResourceUtilizationRangeForTeamRow, error)
	// ResourceUtilizationUpsert will insert or update resource utilization records.
	ResourceUtilizationUpsert(ctx context.Context, arg []ResourceUtilizationUpsertParams) *ResourceUtilizationUpsertBatchResults
	RevokeGlobalUserRole(ctx context.Context, arg RevokeGlobalUserRoleParams) error
	SetLastSuccessfulSyncForTeam(ctx context.Context, argSlug slug.Slug) error
	SetReconcilerErrorForTeam(ctx context.Context, arg SetReconcilerErrorForTeamParams) error
	SetSessionExpires(ctx context.Context, arg SetSessionExpiresParams) (*Session, error)
	// SpecificResourceUtilizationForApp will return resource utilization for an app at a specific timestamp.
	SpecificResourceUtilizationForApp(ctx context.Context, arg SpecificResourceUtilizationForAppParams) (*SpecificResourceUtilizationForAppRow, error)
	// SpecificResourceUtilizationForTeam will return resource utilization for a team at a specific timestamp. Applications
	// with a usage greater than request will be ignored.
	SpecificResourceUtilizationForTeam(ctx context.Context, arg SpecificResourceUtilizationForTeamParams) ([]*SpecificResourceUtilizationForTeamRow, error)
	TeamExists(ctx context.Context, argSlug slug.Slug) (bool, error)
	UpdateTeam(ctx context.Context, arg UpdateTeamParams) (*Team, error)
	UpdateTeamExternalReferences(ctx context.Context, arg UpdateTeamExternalReferencesParams) (*Team, error)
	UpdateUser(ctx context.Context, arg UpdateUserParams) (*User, error)
	UpsertReconciler(ctx context.Context, arg UpsertReconcilerParams) (*Reconciler, error)
	UpsertReconcilerConfig(ctx context.Context, arg UpsertReconcilerConfigParams) error
	UpsertReconcilerState(ctx context.Context, arg UpsertReconcilerStateParams) (*ReconcilerState, error)
	UpsertTeamEnvironment(ctx context.Context, arg UpsertTeamEnvironmentParams) (*TeamEnvironment, error)
	// VulnerabilityMetricsDateRangeForTeam will return the first and last date that has a metrics.
	VulnerabilityMetricsDateRangeForTeam(ctx context.Context, teamSlug slug.Slug) (*VulnerabilityMetricsDateRangeForTeamRow, error)
	// VulnerabilityMetricsMaxDate will return the last date that has a metrics for the given project id.
	VulnerabilityMetricsMaxDate(ctx context.Context, arg VulnerabilityMetricsMaxDateParams) (pgtype.Date, error)
	VulnerabilityMetricsUpsert(ctx context.Context, arg []VulnerabilityMetricsUpsertParams) *VulnerabilityMetricsUpsertBatchResults
}

type Queries 

type Queries struct {
	// contains filtered or unexported fields
}

func New 

func New(db DBTX) *Queries

func (*Queries) AddReconcilerOptOut 

func (q *Queries) AddReconcilerOptOut(ctx context.Context, arg AddReconcilerOptOutParams) error

func (*Queries) AssignGlobalRoleToServiceAccount 

func (q *Queries) AssignGlobalRoleToServiceAccount(ctx context.Context, arg AssignGlobalRoleToServiceAccountParams) error

func (*Queries) AssignGlobalRoleToUser 

func (q *Queries) AssignGlobalRoleToUser(ctx context.Context, arg AssignGlobalRoleToUserParams) error

func (*Queries) AssignTeamRoleToServiceAccount 

func (q *Queries) AssignTeamRoleToServiceAccount(ctx context.Context, arg AssignTeamRoleToServiceAccountParams) error

func (*Queries) AssignTeamRoleToUser 

func (q *Queries) AssignTeamRoleToUser(ctx context.Context, arg AssignTeamRoleToUserParams) error

func (*Queries) AverageResourceUtilizationForTeam 

func (q *Queries) AverageResourceUtilizationForTeam(ctx context.Context, arg AverageResourceUtilizationForTeamParams) (*AverageResourceUtilizationForTeamRow, error)

AverageResourceUtilizationForTeam will return the average resource utilization for a team for a week.

func (*Queries) ClearReconcilerErrorsForTeam 

func (q *Queries) ClearReconcilerErrorsForTeam(ctx context.Context, arg ClearReconcilerErrorsForTeamParams) error

func (*Queries) ConfigureReconciler 

func (q *Queries) ConfigureReconciler(ctx context.Context, arg ConfigureReconcilerParams) error

func (*Queries) ConfirmTeamDeleteKey 

func (q *Queries) ConfirmTeamDeleteKey(ctx context.Context, key uuid.UUID) error

func (*Queries) CostForSqlInstance 

func (q *Queries) CostForSqlInstance(ctx context.Context, arg CostForSqlInstanceParams) (float32, error)

func (*Queries) CostUpsert 

func (q *Queries) CostUpsert(ctx context.Context, arg []CostUpsertParams) *CostUpsertBatchResults

CostUpsert will insert or update a cost record. If there is a conflict on the daily_cost_key constrant, the daily_cost column will be updated.

func (*Queries) CreateAPIKey 

func (q *Queries) CreateAPIKey(ctx context.Context, arg CreateAPIKeyParams) error

func (*Queries) CreateAuditLog 

func (q *Queries) CreateAuditLog(ctx context.Context, arg CreateAuditLogParams) error

func (*Queries) CreateDependencytrackProject 

func (q *Queries) CreateDependencytrackProject(ctx context.Context, arg CreateDependencytrackProjectParams) error

func (*Queries) CreateRepositoryAuthorization 

func (q *Queries) CreateRepositoryAuthorization(ctx context.Context, arg CreateRepositoryAuthorizationParams) error

func (*Queries) CreateServiceAccount 

func (q *Queries) CreateServiceAccount(ctx context.Context, name string) (*ServiceAccount, error)

func (*Queries) CreateSession 

func (q *Queries) CreateSession(ctx context.Context, arg CreateSessionParams) (*Session, error)

func (*Queries) CreateTeam 

func (q *Queries) CreateTeam(ctx context.Context, arg CreateTeamParams) (*Team, error)

func (*Queries) CreateTeamDeleteKey 

func (q *Queries) CreateTeamDeleteKey(ctx context.Context, arg CreateTeamDeleteKeyParams) (*TeamDeleteKey, error)

func (*Queries) CreateUser 

func (q *Queries) CreateUser(ctx context.Context, arg CreateUserParams) (*User, error)

func (*Queries) CurrentSqlInstancesCostForTeam 

func (q *Queries) CurrentSqlInstancesCostForTeam(ctx context.Context, arg CurrentSqlInstancesCostForTeamParams) (float32, error)

func (*Queries) DailyCostForApp 

func (q *Queries) DailyCostForApp(ctx context.Context, arg DailyCostForAppParams) ([]*Cost, error)

DailyCostForApp will fetch the daily cost for a specific team app in a specific environment, across all cost types in a date range.

func (*Queries) DailyCostForTeam 

func (q *Queries) DailyCostForTeam(ctx context.Context, arg DailyCostForTeamParams) ([]*Cost, error)

DailyCostForTeam will fetch the daily cost for a specific team across all apps and envs in a date range.

func (*Queries) DailyEnvCostForTeam 

func (q *Queries) DailyEnvCostForTeam(ctx context.Context, arg DailyEnvCostForTeamParams) ([]*DailyEnvCostForTeamRow, error)

DailyEnvCostForTeam will fetch the daily cost for a specific team and environment across all apps in a date range.

func (*Queries) DailyVulnerabilityForTeam 

func (q *Queries) DailyVulnerabilityForTeam(ctx context.Context, arg DailyVulnerabilityForTeamParams) ([]*DailyVulnerabilityForTeamRow, error)

DailyVulnerabilityForTeam will return the metrics for the given team from first to last date.

func (*Queries) DailyVulnerabilityForTeamAndEnvironment 

func (q *Queries) DailyVulnerabilityForTeamAndEnvironment(ctx context.Context, arg DailyVulnerabilityForTeamAndEnvironmentParams) ([]*DailyVulnerabilityForTeamAndEnvironmentRow, error)

DailyVulnerabilityForTeamAndEnvironment will return the metrics for the given team and environment from first to last date.

func (*Queries) DeleteAllEnvironments 

func (q *Queries) DeleteAllEnvironments(ctx context.Context) error

func (*Queries) DeleteReconcilerConfig 

func (q *Queries) DeleteReconcilerConfig(ctx context.Context, arg DeleteReconcilerConfigParams) error

func (*Queries) DeleteReconcilerStateForTeam 

func (q *Queries) DeleteReconcilerStateForTeam(ctx context.Context, arg DeleteReconcilerStateForTeamParams) error

func (*Queries) DeleteServiceAccount 

func (q *Queries) DeleteServiceAccount(ctx context.Context, id uuid.UUID) error

func (*Queries) DeleteSession 

func (q *Queries) DeleteSession(ctx context.Context, id uuid.UUID) error

func (*Queries) DeleteTeam 

func (q *Queries) DeleteTeam(ctx context.Context, argSlug slug.Slug) error

func (*Queries) DeleteUser 

func (q *Queries) DeleteUser(ctx context.Context, id uuid.UUID) error

func (*Queries) DisableReconciler 

func (q *Queries) DisableReconciler(ctx context.Context, name string) (*Reconciler, error)

func (*Queries) EnableReconciler 

func (q *Queries) EnableReconciler(ctx context.Context, name string) (*Reconciler, error)

func (*Queries) GetActiveTeamBySlug 

func (q *Queries) GetActiveTeamBySlug(ctx context.Context, argSlug slug.Slug) (*Team, error)

func (*Queries) GetActiveTeams 

func (q *Queries) GetActiveTeams(ctx context.Context) ([]*Team, error)

func (*Queries) GetAllTeamMembers 

func (q *Queries) GetAllTeamMembers(ctx context.Context, teamSlug *slug.Slug) ([]*User, error)

func (*Queries) GetAllTeamSlugs 

func (q *Queries) GetAllTeamSlugs(ctx context.Context) ([]slug.Slug, error)

func (*Queries) GetAllUserRoles 

func (q *Queries) GetAllUserRoles(ctx context.Context) ([]*UserRole, error)

func (*Queries) GetAuditLogsForCorrelationID 

func (q *Queries) GetAuditLogsForCorrelationID(ctx context.Context, arg GetAuditLogsForCorrelationIDParams) ([]*AuditLog, error)

func (*Queries) GetAuditLogsForCorrelationIDCount 

func (q *Queries) GetAuditLogsForCorrelationIDCount(ctx context.Context, correlationID uuid.UUID) (int64, error)

func (*Queries) GetAuditLogsForReconciler 

func (q *Queries) GetAuditLogsForReconciler(ctx context.Context, arg GetAuditLogsForReconcilerParams) ([]*AuditLog, error)

func (*Queries) GetAuditLogsForReconcilerCount 

func (q *Queries) GetAuditLogsForReconcilerCount(ctx context.Context, targetIdentifier string) (int64, error)

func (*Queries) GetAuditLogsForTeam 

func (q *Queries) GetAuditLogsForTeam(ctx context.Context, arg GetAuditLogsForTeamParams) ([]*AuditLog, error)

func (*Queries) GetAuditLogsForTeamCount 

func (q *Queries) GetAuditLogsForTeamCount(ctx context.Context, targetIdentifier string) (int64, error)

func (*Queries) GetEnabledReconcilers 

func (q *Queries) GetEnabledReconcilers(ctx context.Context) ([]*Reconciler, error)

func (*Queries) GetReconciler 

func (q *Queries) GetReconciler(ctx context.Context, name string) (*Reconciler, error)

func (*Queries) GetReconcilerConfig 

func (q *Queries) GetReconcilerConfig(ctx context.Context, arg GetReconcilerConfigParams) ([]*GetReconcilerConfigRow, error)

func (*Queries) GetReconcilerState 

func (q *Queries) GetReconcilerState(ctx context.Context, reconcilerName string) ([]*GetReconcilerStateRow, error)

func (*Queries) GetReconcilerStateForTeam 

func (q *Queries) GetReconcilerStateForTeam(ctx context.Context, arg GetReconcilerStateForTeamParams) (*ReconcilerState, error)

func (*Queries) GetReconcilers 

func (q *Queries) GetReconcilers(ctx context.Context, arg GetReconcilersParams) ([]*Reconciler, error)

func (*Queries) GetReconcilersCount 

func (q *Queries) GetReconcilersCount(ctx context.Context) (int64, error)

func (*Queries) GetRepositoryAuthorizations 

func (q *Queries) GetRepositoryAuthorizations(ctx context.Context, arg GetRepositoryAuthorizationsParams) ([]RepositoryAuthorizationEnum, error)

func (*Queries) GetServiceAccountByApiKey 

func (q *Queries) GetServiceAccountByApiKey(ctx context.Context, apiKey string) (*ServiceAccount, error)

func (*Queries) GetServiceAccountByName 

func (q *Queries) GetServiceAccountByName(ctx context.Context, name string) (*ServiceAccount, error)

func (*Queries) GetServiceAccountRoles 

func (q *Queries) GetServiceAccountRoles(ctx context.Context, serviceAccountID uuid.UUID) ([]*ServiceAccountRole, error)

func (*Queries) GetServiceAccounts 

func (q *Queries) GetServiceAccounts(ctx context.Context) ([]*ServiceAccount, error)

func (*Queries) GetServiceAccountsByIDs 

func (q *Queries) GetServiceAccountsByIDs(ctx context.Context, ids []uuid.UUID) ([]*ServiceAccount, error)

func (*Queries) GetSessionByID 

func (q *Queries) GetSessionByID(ctx context.Context, id uuid.UUID) (*Session, error)

func (*Queries) GetTeamBySlug 

func (q *Queries) GetTeamBySlug(ctx context.Context, argSlug slug.Slug) (*Team, error)

func (*Queries) GetTeamBySlugs 

func (q *Queries) GetTeamBySlugs(ctx context.Context, slugs []slug.Slug) ([]*Team, error)

func (*Queries) GetTeamDeleteKey 

func (q *Queries) GetTeamDeleteKey(ctx context.Context, key uuid.UUID) (*TeamDeleteKey, error)

func (*Queries) GetTeamEnvironments 

func (q *Queries) GetTeamEnvironments(ctx context.Context, arg GetTeamEnvironmentsParams) ([]*TeamAllEnvironment, error)

func (*Queries) GetTeamEnvironmentsBySlugsAndEnvNames 

func (q *Queries) GetTeamEnvironmentsBySlugsAndEnvNames(ctx context.Context, arg GetTeamEnvironmentsBySlugsAndEnvNamesParams) ([]*TeamAllEnvironment, error)

Input is two arrays of equal length, one for slugs and one for names

func (*Queries) GetTeamEnvironmentsCount 

func (q *Queries) GetTeamEnvironmentsCount(ctx context.Context, teamSlug slug.Slug) (int64, error)

func (*Queries) GetTeamMember 

func (q *Queries) GetTeamMember(ctx context.Context, arg GetTeamMemberParams) (*User, error)

func (*Queries) GetTeamMemberOptOuts 

func (q *Queries) GetTeamMemberOptOuts(ctx context.Context, arg GetTeamMemberOptOutsParams) ([]*GetTeamMemberOptOutsRow, error)

func (*Queries) GetTeamMembers 

func (q *Queries) GetTeamMembers(ctx context.Context, arg GetTeamMembersParams) ([]*User, error)

func (*Queries) GetTeamMembersCount 

func (q *Queries) GetTeamMembersCount(ctx context.Context, teamSlug *slug.Slug) (int64, error)

func (*Queries) GetTeamMembersForReconciler 

func (q *Queries) GetTeamMembersForReconciler(ctx context.Context, arg GetTeamMembersForReconcilerParams) ([]*User, error)

func (*Queries) GetTeamReconcilerErrors 

func (q *Queries) GetTeamReconcilerErrors(ctx context.Context, teamSlug slug.Slug) ([]*ReconcilerError, error)

func (*Queries) GetTeams 

func (q *Queries) GetTeams(ctx context.Context, arg GetTeamsParams) ([]*Team, error)

func (*Queries) GetTeamsCount 

func (q *Queries) GetTeamsCount(ctx context.Context) (int64, error)

func (*Queries) GetUserByEmail 

func (q *Queries) GetUserByEmail(ctx context.Context, email string) (*User, error)

func (*Queries) GetUserByExternalID 

func (q *Queries) GetUserByExternalID(ctx context.Context, externalID string) (*User, error)

func (*Queries) GetUserByID 

func (q *Queries) GetUserByID(ctx context.Context, id uuid.UUID) (*User, error)

func (*Queries) GetUserRoles 

func (q *Queries) GetUserRoles(ctx context.Context, userID uuid.UUID) ([]*UserRole, error)

func (*Queries) GetUserRolesForUsers 

func (q *Queries) GetUserRolesForUsers(ctx context.Context, userIds []uuid.UUID) ([]*GetUserRolesForUsersRow, error)

func (*Queries) GetUserTeams 

func (q *Queries) GetUserTeams(ctx context.Context, userID uuid.UUID) ([]*GetUserTeamsRow, error)

func (*Queries) GetUserTeamsCount 

func (q *Queries) GetUserTeamsCount(ctx context.Context, userID uuid.UUID) (int64, error)

func (*Queries) GetUserTeamsPaginated 

func (q *Queries) GetUserTeamsPaginated(ctx context.Context, arg GetUserTeamsPaginatedParams) ([]*GetUserTeamsPaginatedRow, error)

func (*Queries) GetUsers 

func (q *Queries) GetUsers(ctx context.Context, arg GetUsersParams) ([]*User, error)

func (*Queries) GetUsersByIDs 

func (q *Queries) GetUsersByIDs(ctx context.Context, ids []uuid.UUID) ([]*User, error)

func (*Queries) GetUsersCount 

func (q *Queries) GetUsersCount(ctx context.Context) (int64, error)

func (*Queries) GetUsersWithGloballyAssignedRole 

func (q *Queries) GetUsersWithGloballyAssignedRole(ctx context.Context, roleName RoleName) ([]*User, error)

func (*Queries) InsertEnvironment 

func (q *Queries) InsertEnvironment(ctx context.Context, arg InsertEnvironmentParams) error

func (*Queries) LastCostDate 

func (q *Queries) LastCostDate(ctx context.Context) (pgtype.Date, error)

LastCostDate will return the last date that has a cost.

func (*Queries) ListRepositoriesByAuthorization 

func (q *Queries) ListRepositoriesByAuthorization(ctx context.Context, arg ListRepositoriesByAuthorizationParams) ([]string, error)

func (*Queries) MaxResourceUtilizationDate 

func (q *Queries) MaxResourceUtilizationDate(ctx context.Context) (pgtype.Timestamptz, error)

MaxResourceUtilizationDate will return the max date for resource utilization records.

func (*Queries) MonthlyCostForApp 

func (q *Queries) MonthlyCostForApp(ctx context.Context, arg MonthlyCostForAppParams) ([]*MonthlyCostForAppRow, error)

func (*Queries) MonthlyCostForTeam 

func (q *Queries) MonthlyCostForTeam(ctx context.Context, teamSlug slug.Slug) ([]*CostMonthlyTeam, error)

func (*Queries) RefreshCostMonthlyTeam 

func (q *Queries) RefreshCostMonthlyTeam(ctx context.Context) error

func (*Queries) RefreshResourceTeamRange 

func (q *Queries) RefreshResourceTeamRange(ctx context.Context) error

Refresh materialized view resource_team_range

func (*Queries) RemoveAllServiceAccountRoles 

func (q *Queries) RemoveAllServiceAccountRoles(ctx context.Context, serviceAccountID uuid.UUID) error

func (*Queries) RemoveApiKeysFromServiceAccount 

func (q *Queries) RemoveApiKeysFromServiceAccount(ctx context.Context, serviceAccountID uuid.UUID) error

func (*Queries) RemoveReconcilerOptOut 

func (q *Queries) RemoveReconcilerOptOut(ctx context.Context, arg RemoveReconcilerOptOutParams) error

func (*Queries) RemoveRepositoryAuthorization 

func (q *Queries) RemoveRepositoryAuthorization(ctx context.Context, arg RemoveRepositoryAuthorizationParams) error

func (*Queries) RemoveUserFromTeam 

func (q *Queries) RemoveUserFromTeam(ctx context.Context, arg RemoveUserFromTeamParams) error

func (*Queries) ResetReconcilerConfig 

func (q *Queries) ResetReconcilerConfig(ctx context.Context, reconcilerName string) error

func (*Queries) ResourceUtilizationForApp 

func (q *Queries) ResourceUtilizationForApp(ctx context.Context, arg ResourceUtilizationForAppParams) ([]*ResourceUtilizationMetric, error)

ResourceUtilizationForApp will return resource utilization records for a given app.

func (*Queries) ResourceUtilizationForTeam 

func (q *Queries) ResourceUtilizationForTeam(ctx context.Context, arg ResourceUtilizationForTeamParams) ([]*ResourceUtilizationForTeamRow, error)

ResourceUtilizationForTeam will return resource utilization records for a given team.

func (*Queries) ResourceUtilizationOverageForTeam 

func (q *Queries) ResourceUtilizationOverageForTeam(ctx context.Context, arg ResourceUtilizationOverageForTeamParams) ([]*ResourceUtilizationOverageForTeamRow, error)

ResourceUtilizationOverageForTeam will return overage records for a given team, ordered by overage descending.

func (*Queries) ResourceUtilizationRangeForApp 

func (q *Queries) ResourceUtilizationRangeForApp(ctx context.Context, arg ResourceUtilizationRangeForAppParams) (*ResourceUtilizationRangeForAppRow, error)

ResourceUtilizationRangeForApp will return the min and max timestamps for a specific app.

func (*Queries) ResourceUtilizationRangeForTeam 

func (q *Queries) ResourceUtilizationRangeForTeam(ctx context.Context, teamSlug slug.Slug) (*ResourceUtilizationRangeForTeamRow, error)

ResourceUtilizationRangeForTeam will return the min and max timestamps for a specific team.

func (*Queries) ResourceUtilizationUpsert 

func (q *Queries) ResourceUtilizationUpsert(ctx context.Context, arg []ResourceUtilizationUpsertParams) *ResourceUtilizationUpsertBatchResults

ResourceUtilizationUpsert will insert or update resource utilization records.

func (*Queries) RevokeGlobalUserRole 

func (q *Queries) RevokeGlobalUserRole(ctx context.Context, arg RevokeGlobalUserRoleParams) error

func (*Queries) SetLastSuccessfulSyncForTeam 

func (q *Queries) SetLastSuccessfulSyncForTeam(ctx context.Context, argSlug slug.Slug) error

func (*Queries) SetReconcilerErrorForTeam 

func (q *Queries) SetReconcilerErrorForTeam(ctx context.Context, arg SetReconcilerErrorForTeamParams) error

func (*Queries) SetSessionExpires 

func (q *Queries) SetSessionExpires(ctx context.Context, arg SetSessionExpiresParams) (*Session, error)

func (*Queries) SpecificResourceUtilizationForApp 

func (q *Queries) SpecificResourceUtilizationForApp(ctx context.Context, arg SpecificResourceUtilizationForAppParams) (*SpecificResourceUtilizationForAppRow, error)

SpecificResourceUtilizationForApp will return resource utilization for an app at a specific timestamp.

func (*Queries) SpecificResourceUtilizationForTeam 

func (q *Queries) SpecificResourceUtilizationForTeam(ctx context.Context, arg SpecificResourceUtilizationForTeamParams) ([]*SpecificResourceUtilizationForTeamRow, error)

SpecificResourceUtilizationForTeam will return resource utilization for a team at a specific timestamp. Applications with a usage greater than request will be ignored.

func (*Queries) TeamExists 

func (q *Queries) TeamExists(ctx context.Context, argSlug slug.Slug) (bool, error)

func (*Queries) UpdateTeam 

func (q *Queries) UpdateTeam(ctx context.Context, arg UpdateTeamParams) (*Team, error)

func (*Queries) UpdateTeamExternalReferences 

func (q *Queries) UpdateTeamExternalReferences(ctx context.Context, arg UpdateTeamExternalReferencesParams) (*Team, error)

func (*Queries) UpdateUser 

func (q *Queries) UpdateUser(ctx context.Context, arg UpdateUserParams) (*User, error)

func (*Queries) UpsertReconciler 

func (q *Queries) UpsertReconciler(ctx context.Context, arg UpsertReconcilerParams) (*Reconciler, error)

func (*Queries) UpsertReconcilerConfig 

func (q *Queries) UpsertReconcilerConfig(ctx context.Context, arg UpsertReconcilerConfigParams) error

func (*Queries) UpsertReconcilerState 

func (q *Queries) UpsertReconcilerState(ctx context.Context, arg UpsertReconcilerStateParams) (*ReconcilerState, error)

func (*Queries) UpsertTeamEnvironment 

func (q *Queries) UpsertTeamEnvironment(ctx context.Context, arg UpsertTeamEnvironmentParams) (*TeamEnvironment, error)

func (*Queries) VulnerabilityMetricsDateRangeForTeam 

func (q *Queries) VulnerabilityMetricsDateRangeForTeam(ctx context.Context, teamSlug slug.Slug) (*VulnerabilityMetricsDateRangeForTeamRow, error)

VulnerabilityMetricsDateRangeForTeam will return the first and last date that has a metrics.

func (*Queries) VulnerabilityMetricsMaxDate 

func (q *Queries) VulnerabilityMetricsMaxDate(ctx context.Context, arg VulnerabilityMetricsMaxDateParams) (pgtype.Date, error)

VulnerabilityMetricsMaxDate will return the last date that has a metrics for the given project id.

func (*Queries) VulnerabilityMetricsUpsert 

func (q *Queries) VulnerabilityMetricsUpsert(ctx context.Context, arg []VulnerabilityMetricsUpsertParams) *VulnerabilityMetricsUpsertBatchResults

func (*Queries) WithTx 

func (q *Queries) WithTx(tx pgx.Tx) *Queries

type Reconciler 

type Reconciler struct {
	Name        string
	DisplayName string
	Description string
	Enabled     bool
	MemberAware bool
}

type ReconcilerError 

type ReconcilerError struct {
	ID            int64
	CorrelationID uuid.UUID
	Reconciler    string
	CreatedAt     pgtype.Timestamptz
	ErrorMessage  string
	TeamSlug      slug.Slug
}

type ReconcilerState 

type ReconcilerState struct {
	ID             uuid.UUID
	ReconcilerName string
	TeamSlug       slug.Slug
	Value          []byte
	CreatedAt      pgtype.Timestamptz
	UpdatedAt      pgtype.Timestamptz
}

type RemoveReconcilerOptOutParams 

type RemoveReconcilerOptOutParams struct {
	TeamSlug       slug.Slug
	UserID         uuid.UUID
	ReconcilerName string
}

type RemoveRepositoryAuthorizationParams 

type RemoveRepositoryAuthorizationParams struct {
	TeamSlug                slug.Slug
	GithubRepository        string
	RepositoryAuthorization RepositoryAuthorizationEnum
}

type RemoveUserFromTeamParams 

type RemoveUserFromTeamParams struct {
	UserID   uuid.UUID
	TeamSlug slug.Slug
}

type RepositoryAuthorizationEnum 

type RepositoryAuthorizationEnum string
const (
	RepositoryAuthorizationEnumDeploy RepositoryAuthorizationEnum = "deploy"
)

func AllRepositoryAuthorizationEnumValues 

func AllRepositoryAuthorizationEnumValues() []RepositoryAuthorizationEnum

func (*RepositoryAuthorizationEnum) Scan 

func (e *RepositoryAuthorizationEnum) Scan(src interface{}) error

func (RepositoryAuthorizationEnum) Valid 

func (e RepositoryAuthorizationEnum) Valid() bool

type ResourceType 

type ResourceType string
const (
	ResourceTypeCpu    ResourceType = "cpu"
	ResourceTypeMemory ResourceType = "memory"
)

func AllResourceTypeValues 

func AllResourceTypeValues() []ResourceType

func (*ResourceType) Scan 

func (e *ResourceType) Scan(src interface{}) error

func (ResourceType) Valid 

func (e ResourceType) Valid() bool

type ResourceUtilizationForAppParams 

type ResourceUtilizationForAppParams struct {
	Environment  string
	TeamSlug     slug.Slug
	App          string
	ResourceType ResourceType
	Start        pgtype.Timestamptz
	End          pgtype.Timestamptz
}

type ResourceUtilizationForTeamParams 

type ResourceUtilizationForTeamParams struct {
	Environment  string
	TeamSlug     slug.Slug
	ResourceType ResourceType
	Start        pgtype.Timestamptz
	End          pgtype.Timestamptz
}

type ResourceUtilizationForTeamRow 

type ResourceUtilizationForTeamRow struct {
	Usage     float64
	Request   float64
	Timestamp pgtype.Timestamptz
}

type ResourceUtilizationMetric 

type ResourceUtilizationMetric struct {
	ID           int32
	Timestamp    pgtype.Timestamptz
	Environment  string
	TeamSlug     slug.Slug
	App          string
	ResourceType ResourceType
	Usage        float64
	Request      float64
}

type ResourceUtilizationOverageForTeamParams 

type ResourceUtilizationOverageForTeamParams struct {
	TeamSlug     slug.Slug
	Timestamp    pgtype.Timestamptz
	ResourceType ResourceType
}

type ResourceUtilizationOverageForTeamRow 

type ResourceUtilizationOverageForTeamRow struct {
	Usage       float64
	Request     float64
	App         string
	Environment string
	Overage     float64
}

type ResourceUtilizationRangeForAppParams 

type ResourceUtilizationRangeForAppParams struct {
	Environment string
	TeamSlug    slug.Slug
	App         string
}

type ResourceUtilizationRangeForAppRow 

type ResourceUtilizationRangeForAppRow struct {
	From pgtype.Timestamptz
	To   pgtype.Timestamptz
}

type ResourceUtilizationRangeForTeamRow 

type ResourceUtilizationRangeForTeamRow struct {
	From pgtype.Timestamptz
	To   pgtype.Timestamptz
}

type ResourceUtilizationUpsertBatchResults 

type ResourceUtilizationUpsertBatchResults struct {
	// contains filtered or unexported fields
}

func (*ResourceUtilizationUpsertBatchResults) Close 

func (b *ResourceUtilizationUpsertBatchResults) Close() error

func (*ResourceUtilizationUpsertBatchResults) Exec 

func (b *ResourceUtilizationUpsertBatchResults) Exec(f func(int, error))

type ResourceUtilizationUpsertParams 

type ResourceUtilizationUpsertParams struct {
	Timestamp    pgtype.Timestamptz
	Environment  string
	TeamSlug     slug.Slug
	App          string
	ResourceType ResourceType
	Usage        float64
	Request      float64
}

type RevokeGlobalUserRoleParams 

type RevokeGlobalUserRoleParams struct {
	UserID   uuid.UUID
	RoleName RoleName
}

type RoleName 

type RoleName string
const (
	RoleNameAdmin                 RoleName = "Admin"
	RoleNameDeploykeyviewer       RoleName = "Deploy key viewer"
	RoleNameServiceaccountcreator RoleName = "Service account creator"
	RoleNameServiceaccountowner   RoleName = "Service account owner"
	RoleNameSynchronizer          RoleName = "Synchronizer"
	RoleNameTeamcreator           RoleName = "Team creator"
	RoleNameTeammember            RoleName = "Team member"
	RoleNameTeamowner             RoleName = "Team owner"
	RoleNameTeamviewer            RoleName = "Team viewer"
	RoleNameUseradmin             RoleName = "User admin"
	RoleNameUserviewer            RoleName = "User viewer"
)

func AllRoleNameValues 

func AllRoleNameValues() []RoleName

func (*RoleName) Scan 

func (e *RoleName) Scan(src interface{}) error

func (RoleName) Valid 

func (e RoleName) Valid() bool

type ServiceAccount 

type ServiceAccount struct {
	ID   uuid.UUID
	Name string
}

type ServiceAccountRole 

type ServiceAccountRole struct {
	ID                     int32
	RoleName               RoleName
	ServiceAccountID       uuid.UUID
	TargetTeamSlug         *slug.Slug
	TargetServiceAccountID *uuid.UUID
}

type Session 

type Session struct {
	ID      uuid.UUID
	UserID  uuid.UUID
	Expires pgtype.Timestamptz
}

type SetReconcilerErrorForTeamParams 

type SetReconcilerErrorForTeamParams struct {
	CorrelationID uuid.UUID
	TeamSlug      slug.Slug
	Reconciler    string
	ErrorMessage  string
}

type SetSessionExpiresParams 

type SetSessionExpiresParams struct {
	Expires pgtype.Timestamptz
	ID      uuid.UUID
}

type SpecificResourceUtilizationForAppParams 

type SpecificResourceUtilizationForAppParams struct {
	Environment  string
	TeamSlug     slug.Slug
	App          string
	ResourceType ResourceType
	Timestamp    pgtype.Timestamptz
}

type SpecificResourceUtilizationForAppRow 

type SpecificResourceUtilizationForAppRow struct {
	Usage     float64
	Request   float64
	Timestamp pgtype.Timestamptz
}

type SpecificResourceUtilizationForTeamParams 

type SpecificResourceUtilizationForTeamParams struct {
	TeamSlug     slug.Slug
	ResourceType ResourceType
	Timestamp    pgtype.Timestamptz
}

type SpecificResourceUtilizationForTeamRow 

type SpecificResourceUtilizationForTeamRow struct {
	Usage         float64
	Request       float64
	Timestamp     pgtype.Timestamptz
	UsableForCost bool
}

type Team 

type Team struct {
	Slug               slug.Slug
	Purpose            string
	LastSuccessfulSync pgtype.Timestamp
	SlackChannel       string
	GoogleGroupEmail   *string
	AzureGroupID       *uuid.UUID
	GithubTeamSlug     *string
	GarRepository      *string
}

type TeamAllEnvironment 

type TeamAllEnvironment struct {
	TeamSlug           slug.Slug
	Environment        string
	Gcp                bool
	GcpProjectID       *string
	ID                 uuid.UUID
	SlackAlertsChannel string
}

type TeamDeleteKey 

type TeamDeleteKey struct {
	Key         uuid.UUID
	TeamSlug    slug.Slug
	CreatedAt   pgtype.Timestamptz
	CreatedBy   uuid.UUID
	ConfirmedAt pgtype.Timestamptz
}

type TeamEnvironment 

type TeamEnvironment struct {
	ID                 uuid.UUID
	TeamSlug           slug.Slug
	Environment        string
	SlackAlertsChannel *string
	GcpProjectID       *string
}

type UpdateTeamExternalReferencesParams 

type UpdateTeamExternalReferencesParams struct {
	GoogleGroupEmail *string
	AzureGroupID     *uuid.UUID
	GithubTeamSlug   *string
	GarRepository    *string
	Slug             slug.Slug
}

type UpdateTeamParams 

type UpdateTeamParams struct {
	Purpose      *string
	SlackChannel *string
	Slug         slug.Slug
}

type UpdateUserParams 

type UpdateUserParams struct {
	Name       string
	Email      string
	ExternalID string
	ID         uuid.UUID
}

type UpsertReconcilerConfigParams 

type UpsertReconcilerConfigParams struct {
	Reconciler  string
	Key         string
	DisplayName string
	Description string
	Secret      bool
}

type UpsertReconcilerParams 

type UpsertReconcilerParams struct {
	Name         string
	DisplayName  string
	Description  string
	MemberAware  bool
	EnabledIfNew bool
}

type UpsertReconcilerStateParams 

type UpsertReconcilerStateParams struct {
	ReconcilerName string
	TeamSlug       slug.Slug
	Value          []byte
}

type UpsertTeamEnvironmentParams 

type UpsertTeamEnvironmentParams struct {
	TeamSlug           slug.Slug
	Environment        string
	SlackAlertsChannel *string
	GcpProjectID       *string
}

type User 

type User struct {
	ID         uuid.UUID
	Email      string
	Name       string
	ExternalID string
}

type UserRole 

type UserRole struct {
	ID                     int32
	RoleName               RoleName
	UserID                 uuid.UUID
	TargetTeamSlug         *slug.Slug
	TargetServiceAccountID *uuid.UUID
}

type VulnerabilityMetricsDateRangeForTeamRow 

type VulnerabilityMetricsDateRangeForTeamRow struct {
	FromDate pgtype.Date
	ToDate   pgtype.Date
}

type VulnerabilityMetricsMaxDateParams 

type VulnerabilityMetricsMaxDateParams struct {
	Environment string
	App         string
	TeamSlug    slug.Slug
}

type VulnerabilityMetricsUpsertBatchResults 

type VulnerabilityMetricsUpsertBatchResults struct {
	// contains filtered or unexported fields
}

func (*VulnerabilityMetricsUpsertBatchResults) Close 

func (b *VulnerabilityMetricsUpsertBatchResults) Close() error

func (*VulnerabilityMetricsUpsertBatchResults) Exec 

func (b *VulnerabilityMetricsUpsertBatchResults) Exec(f func(int, error))

type VulnerabilityMetricsUpsertParams 

type VulnerabilityMetricsUpsertParams struct {
	Date                     pgtype.Date
	DependencytrackProjectID uuid.UUID
	Critical                 int32
	High                     int32
	Medium                   int32
	Low                      int32
	Unassigned               int32
	RiskScore                float64
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.