From e0850b279e9c203119ba03d32c40c0309ee977a2 Mon Sep 17 00:00:00 2001 From: Michelangelo Mori Date: Thu, 27 Jun 2024 12:18:20 +0200 Subject: [PATCH 01/13] Added ListEvaluationHistory RPC implementation. ListEvaluationHistory RPC returns a paginated list of evaluation events based on the given cursor and filter. Routines for managing a filter are implemented as well, in a way that should be reusable within other endpoints supporting filters. This implementation only allows and-joined predicates. Such predicates allow only or-joined equality/inequality checks. Simply put, if a filter entry starts with the exclamation mark, it is added to the inequality check, while it is added to the equality check otherwise. Finally, timerange based filtering is supported. Routines for managing a cursor are implemented as well, but are not intended to be generic. Cursors are tightly coupled with the underlying extraction logic and are harder to refactor, and the additional effort was not considered valuable at this time. Fixes #3746 --- internal/controlplane/handlers_evalstatus.go | 87 +++- internal/history/mock/service.go | 17 + internal/history/models.go | 522 +++++++++++++++++++ internal/history/service.go | 21 + 4 files changed, 629 insertions(+), 18 deletions(-) create mode 100644 internal/history/models.go diff --git a/internal/controlplane/handlers_evalstatus.go b/internal/controlplane/handlers_evalstatus.go index 9455a69925..7a6d4ac296 100644 --- a/internal/controlplane/handlers_evalstatus.go +++ b/internal/controlplane/handlers_evalstatus.go @@ -18,6 +18,7 @@ package controlplane import ( "context" "fmt" + "strings" "github.com/google/uuid" "github.com/rs/zerolog" @@ -28,33 +29,83 @@ import ( "github.com/stacklok/minder/internal/db" "github.com/stacklok/minder/internal/engine/engcontext" "github.com/stacklok/minder/internal/flags" + "github.com/stacklok/minder/internal/history" minderv1 "github.com/stacklok/minder/pkg/api/protobuf/go/minder/v1" ) +const ( + defaultPageSize uint64 = 25 +) + // ListEvaluationHistory lists current and past evaluation results for // entities. func (s *Server) ListEvaluationHistory( ctx context.Context, in *minderv1.ListEvaluationHistoryRequest, ) (*minderv1.ListEvaluationHistoryResponse, error) { - if flags.Bool(ctx, s.featureFlags, flags.EvalHistory) { - cursor := in.GetCursor() - zerolog.Ctx(ctx).Debug(). - Strs("entity_type", in.GetEntityType()). - Strs("entity_name", in.GetEntityName()). - Strs("profile_name", in.GetProfileName()). - Strs("status", in.GetStatus()). - Strs("remediation", in.GetRemediation()). - Strs("alert", in.GetAlert()). - Str("from", in.GetFrom().String()). - Str("to", in.GetTo().String()). - Str("cursor.cursor", cursor.Cursor). - Uint64("cursor.size", cursor.Size). - Msg("ListEvaluationHistory request") - return &minderv1.ListEvaluationHistoryResponse{}, nil - } - - return nil, status.Error(codes.Unimplemented, "Not implemented") + if !flags.Bool(ctx, s.featureFlags, flags.EvalHistory) { + return nil, status.Error(codes.Unimplemented, "Not implemented") + } + + cursor := &history.DefaultCursor + size := defaultPageSize + if in.GetCursor() != nil { + parsedCursor, err := history.ParseListEvaluationCursor( + in.GetCursor().GetCursor(), + ) + if err != nil { + return nil, status.Error(codes.Internal, "error parsing cursor") + } + cursor = parsedCursor + size = in.GetCursor().GetSize() + } + + opts := []history.FilterOpt{} + opts = append(opts, optsFromStringList(in.GetEntityType(), history.WithEntityType)...) + opts = append(opts, optsFromStringList(in.GetEntityName(), history.WithEntityName)...) + opts = append(opts, optsFromStringList(in.GetProfileName(), history.WithProfileName)...) + opts = append(opts, optsFromStringList(in.GetStatus(), history.WithStatus)...) + opts = append(opts, optsFromStringList(in.GetRemediation(), history.WithRemediation)...) + opts = append(opts, optsFromStringList(in.GetAlert(), history.WithAlert)...) + + if in.GetFrom() != nil { + opts = append(opts, history.WithFrom(in.GetFrom().AsTime())) + } + if in.GetTo() != nil { + opts = append(opts, history.WithTo(in.GetTo().AsTime())) + } + + filter, err := history.NewListEvaluationFilter(opts...) + if err != nil { + return nil, status.Error(codes.InvalidArgument, "invalid filter") + } + + zerolog.Ctx(ctx).Debug(). + Str("cursor", fmt.Sprintf("%+v", cursor)). + Uint64("size", size). + Str("filter", fmt.Sprintf("%+v", filter)). + Msg("ListEvaluationHistory request") + + return &minderv1.ListEvaluationHistoryResponse{}, nil +} + +// optsFromStringList calls the given function `f` on each element of +// values. Such elements are either "complex", i.e. they represent a +// comma-separated list of sub-elements, or "simple", they do not +// contain comma characters. If element contains one or more comma +// characters, it is further split into sub-elements before calling +// `f` in them. +func optsFromStringList( + values []string, + f func(string) history.FilterOpt, +) []history.FilterOpt { + opts := []history.FilterOpt{} + for _, val := range values { + for _, part := range strings.Split(val, ",") { + opts = append(opts, f(part)) + } + } + return opts } // ListEvaluationResults lists the latest evaluation results for diff --git a/internal/history/mock/service.go b/internal/history/mock/service.go index 4dd2249204..c7b51c203d 100644 --- a/internal/history/mock/service.go +++ b/internal/history/mock/service.go @@ -15,6 +15,8 @@ import ( uuid "github.com/google/uuid" db "github.com/stacklok/minder/internal/db" + history "github.com/stacklok/minder/internal/history" + v1 "github.com/stacklok/minder/pkg/api/protobuf/go/minder/v1" gomock "go.uber.org/mock/gomock" ) @@ -41,6 +43,21 @@ func (m *MockEvaluationHistoryService) EXPECT() *MockEvaluationHistoryServiceMoc return m.recorder } +// ListEvaluationHistory mocks base method. +func (m *MockEvaluationHistoryService) ListEvaluationHistory(ctx context.Context, qtx db.Querier, cursor history.ListEvaluationCursor, size uint64, filter history.ListEvaluationFilter) ([]*v1.EvaluationHistory, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListEvaluationHistory", ctx, qtx, cursor, size, filter) + ret0, _ := ret[0].([]*v1.EvaluationHistory) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListEvaluationHistory indicates an expected call of ListEvaluationHistory. +func (mr *MockEvaluationHistoryServiceMockRecorder) ListEvaluationHistory(ctx, qtx, cursor, size, filter any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEvaluationHistory", reflect.TypeOf((*MockEvaluationHistoryService)(nil).ListEvaluationHistory), ctx, qtx, cursor, size, filter) +} + // StoreEvaluationStatus mocks base method. func (m *MockEvaluationHistoryService) StoreEvaluationStatus(ctx context.Context, qtx db.Querier, ruleID uuid.UUID, entityType db.Entities, entityID uuid.UUID, evalError error) (uuid.UUID, error) { m.ctrl.T.Helper() diff --git a/internal/history/models.go b/internal/history/models.go new file mode 100644 index 0000000000..541d856ae4 --- /dev/null +++ b/internal/history/models.go @@ -0,0 +1,522 @@ +package history + +import ( + "encoding/base64" + "errors" + "fmt" + "strings" + "time" + + "github.com/google/uuid" +) + +var ( + // ErrMalformedCursor represents errors in the cursor payload. + ErrMalformedCursor = errors.New("malformed cursor") + // ErrAlreadySet is returned when a field is set multiple + // times. + ErrAlreadySet = errors.New("field already set") + // ErrInvalidTimeRange is returned the time range from-to is + // either missing one end or from is greater than to. + ErrInvalidTimeRange = errors.New("invalid time range") + // ErrInvalidIdentifier is returned when an identifier + // (e.g. entity name) is empty or malformed. + ErrInvalidIdentifier = errors.New("invalid identifier") +) + +// Direction enumerates the direction of the Cursor. +type Direction string + +const ( + // Next represents the next page. + Next = "next" + // Prev represents the prev page. + Prev = "prev" +) + +// ListEvaluationCursor is a struct representing a cursor in the +// dataset of historical evaluations. +type ListEvaluationCursor struct { + ID uuid.UUID + Timestamp time.Time + Direction Direction +} + +var ( + // DefaultCursor is a cursor starting from the beginning of + // the data set. + DefaultCursor = ListEvaluationCursor{ + ID: uuid.Nil, + Timestamp: time.UnixMilli(0), + Direction: Next, + } +) + +// ParseListEvaluationCursor interprets an opaque payload and returns +// a ListEvaluationCursor. The opaque paylaod is expected to be of one +// of the following forms +// +// - `"+00000000-0000-0000-0000-000000000000"` meaning the next page +// of data starting from the given UUID excluded +// +// - `"-00000000-0000-0000-0000-000000000000"` meaning the previous +// page of data starting from the given UUID excluded +// +// - `"00000000-0000-0000-0000-000000000000"` meaning the next page +// of data (default) starting from the given UUID excluded +func ParseListEvaluationCursor(payload string) (*ListEvaluationCursor, error) { + decoded, err := base64.StdEncoding.DecodeString(payload) + if err != nil { + return nil, fmt.Errorf("%w: %s", ErrMalformedCursor, err) + } + + switch { + case string(decoded) == "": + return &DefaultCursor, nil + case strings.HasPrefix(string(decoded), "+"): + // +00000000-0000-0000-0000-000000000000 + id, err := uuid.ParseBytes(decoded[1:]) + if err != nil { + return nil, fmt.Errorf("%w: %s", ErrMalformedCursor, err) + } + return &ListEvaluationCursor{ + ID: id, + Timestamp: time.UnixMilli(0), + Direction: Next, + }, nil + case strings.HasPrefix(string(decoded), "-"): + // -00000000-0000-0000-0000-000000000000 + id, err := uuid.ParseBytes(decoded[1:]) + if err != nil { + return nil, fmt.Errorf("%w: %s", ErrMalformedCursor, err) + } + return &ListEvaluationCursor{ + ID: id, + Timestamp: time.UnixMilli(0), + Direction: Prev, + }, nil + default: + // 00000000-0000-0000-0000-000000000000 + id, err := uuid.ParseBytes(decoded) + if err != nil { + return nil, fmt.Errorf("%w: %s", ErrMalformedCursor, err) + } + return &ListEvaluationCursor{ + ID: id, + Timestamp: time.UnixMilli(0), + Direction: Next, + }, nil + } +} + +// Filter is an empty interface to be implemented by structs +// representing filters. Its main purpose is to allow a generic +// definition of options functions. +type Filter interface{} + +// FilterOpt is the option type used to configure filters. +type FilterOpt func(Filter) error + +// EntityTypeFilter interface should be implemented by types +// implementing a filter on entity types. +type EntityTypeFilter interface { + // AddEntityType adds an entity type for inclusion/exclusion + // in the filter. + AddEntityType(string) error + // IncludedEntityTypes returns the list of included entity + // types. + IncludedEntityTypes() []string + // ExcludedEntityTypes returns the list of excluded entity + // types. + ExcludedEntityTypes() []string +} + +// EntityNameFilter interface should be implemented by types +// implementing a filter on entity names. +type EntityNameFilter interface { + // AddEntityName adds an entity name for inclusion/exclution + // in the filter. + AddEntityName(string) error + // IncludedEntityNames returns the list of included entity + // names. + IncludedEntityNames() []string + // ExcludedEntityNames returns the list of excluded entity + // names. + ExcludedEntityNames() []string +} + +// ProfileNameFilter interface should be implemented by types +// implementing a filter on profile names. +type ProfileNameFilter interface { + // AddProfileName adds a profile name for inclusion/exclusion + // in the filter. + AddProfileName(string) error + // IncludedProfileNames returns the list of included profile + // names. + IncludedProfileNames() []string + // ExcludedProfileNames returns the list of excluded profile + // names. + ExcludedProfileNames() []string +} + +// StatusFilter interface should be implemented by types implementing +// a filter on statuses. +type StatusFilter interface { + // AddStatus adds a status for inclusion/exclusion in the + // filter. + AddStatus(string) error + // IncludedStatus returns the list of included statuses. + IncludedStatus() []string + // ExcludedStatus returns the list of excluded statuses. + ExcludedStatus() []string +} + +// RemediationFilter interface should be implemented by types +// implementing a filter on remediation statuses. +type RemediationFilter interface { + // AddRemediation adds a remediation for inclusion/exclusion + // in the filter. + AddRemediation(string) error + // IncludedRemediation returns the list of included + // remediations. + IncludedRemediation() []string + // ExcludedRemediation returns the list of excluded + // remediations. + ExcludedRemediation() []string +} + +// AlertFilter interface should be implemented by types implementing a +// filter on alert settings. +type AlertFilter interface { + // AddAlert adds an alert setting for inclusion/exclusion in + // the filter. + AddAlert(string) error + // IncludedAlert returns the list of included alert settings. + IncludedAlert() []string + // IncludedAlert returns the list of excluded alert settings. + ExcludedAlert() []string +} + +// TimeRangeFilter interface should be implemented by types +// implementing a filter based on time range. +type TimeRangeFilter interface { + // SetFrom sets the start of the time range. + SetFrom(time.Time) error + // SetTo sets the end of the time range. + SetTo(time.Time) error + // GetFrom retrieves the start of the time range. + GetFrom() *time.Time + // GetTo retrieves the end of the time range. + GetTo() *time.Time +} + +// ListEvaluationFilter is a filter to be used when listing historical +// evaluations. +type ListEvaluationFilter interface { + EntityTypeFilter + EntityNameFilter + ProfileNameFilter + StatusFilter + RemediationFilter + AlertFilter + TimeRangeFilter +} + +type listEvaluationFilter struct { + // List of entity types to include in the selection + includedEntityTypes []string + // List of entity types to exclude from the selection + excludedEntityTypes []string + // List of entity names to include in the selection + includedEntityNames []string + // List of entity names to exclude from the selection + excludedEntityNames []string + // List of profile names to include in the selection + includedProfileNames []string + // List of profile names to exclude from the selection + excludedProfileNames []string + // List of statuses to include in the selection + includedStatuses []string + // List of statuses to exclude from the selection + excludedStatuses []string + // List of remediations to include in the selection + includedRemediation []string + // List of remediations to exclude from the selection + excludedRemediation []string + // List of alerts to include in the selection + includedAlerts []string + // List of alerts to exclude from the selection + excludedAlerts []string + // Lower bound of the time range, inclusive + from *time.Time + // Upper bound of the time range, exclusive + to *time.Time +} + +func (filter *listEvaluationFilter) AddEntityType(entityType string) error { + if strings.HasPrefix(entityType, "!") { + entityType = strings.Split(entityType, "!")[1] // guaranteed to exist + filter.excludedEntityTypes = append(filter.excludedEntityTypes, entityType) + } else { + filter.includedEntityTypes = append(filter.includedEntityTypes, entityType) + } + return nil +} +func (filter *listEvaluationFilter) IncludedEntityTypes() []string { + return filter.includedEntityTypes +} +func (filter *listEvaluationFilter) ExcludedEntityTypes() []string { + return filter.excludedEntityTypes +} + +func (filter *listEvaluationFilter) AddEntityName(entityName string) error { + if strings.HasPrefix(entityName, "!") { + entityName = strings.Split(entityName, "!")[1] // guaranteed to exist + filter.excludedEntityNames = append(filter.excludedEntityNames, entityName) + } else { + filter.includedEntityNames = append(filter.includedEntityNames, entityName) + } + return nil +} +func (filter *listEvaluationFilter) IncludedEntityNames() []string { + return filter.includedEntityNames +} +func (filter *listEvaluationFilter) ExcludedEntityNames() []string { + return filter.excludedEntityNames +} + +func (filter *listEvaluationFilter) AddProfileName(profileName string) error { + if strings.HasPrefix(profileName, "!") { + profileName = strings.Split(profileName, "!")[1] // guaranteed to exist + filter.excludedProfileNames = append(filter.excludedProfileNames, profileName) + } else { + filter.includedProfileNames = append(filter.includedProfileNames, profileName) + } + return nil +} +func (filter *listEvaluationFilter) IncludedProfileNames() []string { + return filter.includedProfileNames +} +func (filter *listEvaluationFilter) ExcludedProfileNames() []string { + return filter.excludedProfileNames +} + +func (filter *listEvaluationFilter) AddStatus(status string) error { + if strings.HasPrefix(status, "!") { + status = strings.Split(status, "!")[1] // guaranteed to exist + filter.excludedStatuses = append(filter.excludedStatuses, status) + } else { + filter.includedStatuses = append(filter.includedStatuses, status) + } + return nil +} +func (filter *listEvaluationFilter) IncludedStatus() []string { + return filter.includedStatuses +} +func (filter *listEvaluationFilter) ExcludedStatus() []string { + return filter.excludedStatuses +} + +func (filter *listEvaluationFilter) AddRemediation(remediation string) error { + if strings.HasPrefix(remediation, "!") { + remediation = strings.Split(remediation, "!")[1] // guaranteed to exist + filter.excludedRemediation = append(filter.excludedRemediation, remediation) + } else { + filter.includedRemediation = append(filter.includedRemediation, remediation) + } + return nil +} +func (filter *listEvaluationFilter) IncludedRemediation() []string { + return filter.includedRemediation +} +func (filter *listEvaluationFilter) ExcludedRemediation() []string { + return filter.excludedRemediation +} + +func (filter *listEvaluationFilter) AddAlert(alert string) error { + if strings.HasPrefix(alert, "!") { + alert = strings.Split(alert, "!")[1] // guaranteed to exist + filter.excludedAlerts = append(filter.excludedAlerts, alert) + } else { + filter.includedAlerts = append(filter.includedAlerts, alert) + } + return nil +} +func (filter *listEvaluationFilter) IncludedAlert() []string { + return filter.includedAlerts +} +func (filter *listEvaluationFilter) ExcludedAlert() []string { + return filter.excludedAlerts +} + +func (filter *listEvaluationFilter) SetFrom(from time.Time) error { + if filter.from != nil { + return fmt.Errorf("%w: from", ErrAlreadySet) + } + filter.from = &from + return nil +} +func (filter *listEvaluationFilter) SetTo(to time.Time) error { + if filter.to != nil { + return fmt.Errorf("%w: to", ErrAlreadySet) + } + filter.to = &to + return nil +} +func (filter *listEvaluationFilter) GetFrom() *time.Time { + return filter.from +} +func (filter *listEvaluationFilter) GetTo() *time.Time { + return filter.to +} + +var _ Filter = (*listEvaluationFilter)(nil) +var _ ListEvaluationFilter = (*listEvaluationFilter)(nil) + +// WithEntityType adds an entity type string to the filter. The entity +// type is added for inclusion unless it starts with a `!` characters, +// in which case it is added for exclusion. +func WithEntityType(entityType string) FilterOpt { + return func(filter Filter) error { + if entityType == "" || entityType == "!" { + return fmt.Errorf("%w: entity type", ErrInvalidIdentifier) + } + inner, ok := filter.(EntityTypeFilter) + if !ok { + return fmt.Errorf("%w: wrong filter type", ErrInvalidIdentifier) + } + // TODO add validation on enumerated types + return inner.AddEntityType(entityType) + } +} + +// WithEntityName adds an entity name string to the filter. The entity +// name is added for inclusion unless it starts with a `!` characters, +// in which case it is added for exclusion. +func WithEntityName(entityName string) FilterOpt { + return func(filter Filter) error { + if entityName == "" || entityName == "!" { + return fmt.Errorf("%w: entity name", ErrInvalidIdentifier) + } + inner, ok := filter.(EntityNameFilter) + if !ok { + return fmt.Errorf("%w: wrong filter type", ErrInvalidIdentifier) + } + return inner.AddEntityName(entityName) + } +} + +// WithProfileName adds an profile name string to the filter. The +// profile name is added for inclusion unless it starts with a `!` +// characters, in which case it is added for exclusion. +func WithProfileName(profileName string) FilterOpt { + return func(filter Filter) error { + if profileName == "" || profileName == "!" { + return fmt.Errorf("%w: profile name", ErrInvalidIdentifier) + } + inner, ok := filter.(ProfileNameFilter) + if !ok { + return fmt.Errorf("%w: wrong filter type", ErrInvalidIdentifier) + } + return inner.AddProfileName(profileName) + } +} + +// WithStatus adds a status string to the filter. The status is added +// for inclusion unless it starts with a `!` characters, in which case +// it is added for exclusion. +func WithStatus(status string) FilterOpt { + return func(filter Filter) error { + if status == "" || status == "!" { + return fmt.Errorf("%w: status", ErrInvalidIdentifier) + } + inner, ok := filter.(StatusFilter) + if !ok { + return fmt.Errorf("%w: wrong filter type", ErrInvalidIdentifier) + } + // TODO add validation on enumerated types + return inner.AddStatus(status) + } +} + +// WithRemediation adds a remediation string to the filter. The +// remediation is added for inclusion unless it starts with a `!` +// characters, in which case it is added for exclusion. +func WithRemediation(remediation string) FilterOpt { + return func(filter Filter) error { + if remediation == "" || remediation == "!" { + return fmt.Errorf("%w: remediation", ErrInvalidIdentifier) + } + inner, ok := filter.(RemediationFilter) + if !ok { + return fmt.Errorf("%w: wrong filter type", ErrInvalidIdentifier) + } + // TODO add validation on enumerated types + return inner.AddRemediation(remediation) + } +} + +// WithAlert adds an alert string to the filter. The alert is added +// for inclusion unless it starts with a `!` characters, in which case +// it is added for exclusion. +func WithAlert(alert string) FilterOpt { + return func(filter Filter) error { + if alert == "" || alert == "!" { + return fmt.Errorf("%w: alert", ErrInvalidIdentifier) + } + inner, ok := filter.(AlertFilter) + if !ok { + return fmt.Errorf("%w: wrong filter type", ErrInvalidIdentifier) + } + // TODO add validation on enumerated types + return inner.AddAlert(alert) + } +} + +// WithFrom sets the start of the time range, inclusive. +func WithFrom(from time.Time) FilterOpt { + return func(filter Filter) error { + inner, ok := filter.(TimeRangeFilter) + if !ok { + return fmt.Errorf("%w: wrong filter type", ErrInvalidIdentifier) + } + return inner.SetFrom(from) + } +} + +// WithTo sets the end of the time range, exclusive. +func WithTo(to time.Time) FilterOpt { + return func(filter Filter) error { + inner, ok := filter.(TimeRangeFilter) + if !ok { + return fmt.Errorf("%w: wrong filter type", ErrInvalidIdentifier) + } + return inner.SetTo(to) + } +} + +// NewListEvaluationFilter is a constructor routine for +// ListEvaluationFilter objects. +// +// It accepts a list of ListEvaluationFilterOpt options and performs +// validation on them, allowing only logically sound filters. +func NewListEvaluationFilter(opts ...FilterOpt) (ListEvaluationFilter, error) { + filter := &listEvaluationFilter{} + for _, opt := range opts { + if err := opt(filter); err != nil { + return nil, err + } + } + + if filter.to != nil && filter.from == nil { + return nil, fmt.Errorf("%w: from is missing", ErrInvalidTimeRange) + } + if filter.from != nil && filter.to == nil { + return nil, fmt.Errorf("%w: to is missing", ErrInvalidTimeRange) + } + if filter.from != nil && filter.to != nil && filter.from.After(*filter.to) { + return nil, fmt.Errorf("%w: from is greated than to", ErrInvalidTimeRange) + } + + return filter, nil +} diff --git a/internal/history/service.go b/internal/history/service.go index c38e834049..5fbd9ffa8d 100644 --- a/internal/history/service.go +++ b/internal/history/service.go @@ -26,6 +26,7 @@ import ( "github.com/stacklok/minder/internal/db" evalerrors "github.com/stacklok/minder/internal/engine/errors" + minderv1 "github.com/stacklok/minder/pkg/api/protobuf/go/minder/v1" ) //go:generate go run go.uber.org/mock/mockgen -package mock_$GOPACKAGE -destination=./mock/$GOFILE -source=./$GOFILE @@ -42,6 +43,15 @@ type EvaluationHistoryService interface { entityID uuid.UUID, evalError error, ) (uuid.UUID, error) + // ListEvaluationHistory returns a list of evaluations stored + // in the history table. + ListEvaluationHistory( + ctx context.Context, + qtx db.Querier, + cursor ListEvaluationCursor, + size uint64, + filter ListEvaluationFilter, + ) ([]*minderv1.EvaluationHistory, error) } // NewEvaluationHistoryService creates a new instance of EvaluationHistoryService @@ -195,3 +205,14 @@ type ruleEntityParams struct { ArtifactID uuid.NullUUID PullRequestID uuid.NullUUID } + +//nolint:revive +func (e *evaluationHistoryService) ListEvaluationHistory( + ctx context.Context, + qtx db.Querier, + cursor ListEvaluationCursor, + size uint64, + filter ListEvaluationFilter, +) ([]*minderv1.EvaluationHistory, error) { + return []*minderv1.EvaluationHistory{}, nil +} From bdf55eff5edd7f06989429bb1721f0faf744feb5 Mon Sep 17 00:00:00 2001 From: Michelangelo Mori Date: Mon, 1 Jul 2024 15:53:58 +0200 Subject: [PATCH 02/13] Handler-to-Service wiring. --- internal/controlplane/handlers_evalstatus.go | 30 +++++++++++++++----- internal/controlplane/server.go | 4 +++ internal/history/mock/service.go | 2 +- internal/history/service.go | 11 +++++-- internal/service/service.go | 2 ++ 5 files changed, 39 insertions(+), 10 deletions(-) diff --git a/internal/controlplane/handlers_evalstatus.go b/internal/controlplane/handlers_evalstatus.go index 7a6d4ac296..75087dccf2 100644 --- a/internal/controlplane/handlers_evalstatus.go +++ b/internal/controlplane/handlers_evalstatus.go @@ -47,6 +47,7 @@ func (s *Server) ListEvaluationHistory( return nil, status.Error(codes.Unimplemented, "Not implemented") } + // process cursor cursor := &history.DefaultCursor size := defaultPageSize if in.GetCursor() != nil { @@ -54,12 +55,13 @@ func (s *Server) ListEvaluationHistory( in.GetCursor().GetCursor(), ) if err != nil { - return nil, status.Error(codes.Internal, "error parsing cursor") + return nil, status.Error(codes.InvalidArgument, "invalid cursor") } cursor = parsedCursor size = in.GetCursor().GetSize() } + // process filter opts := []history.FilterOpt{} opts = append(opts, optsFromStringList(in.GetEntityType(), history.WithEntityType)...) opts = append(opts, optsFromStringList(in.GetEntityName(), history.WithEntityName)...) @@ -80,13 +82,27 @@ func (s *Server) ListEvaluationHistory( return nil, status.Error(codes.InvalidArgument, "invalid filter") } - zerolog.Ctx(ctx).Debug(). - Str("cursor", fmt.Sprintf("%+v", cursor)). - Uint64("size", size). - Str("filter", fmt.Sprintf("%+v", filter)). - Msg("ListEvaluationHistory request") + // retrieve data set + tx, err := s.store.BeginTransaction() + if err != nil { + return nil, status.Errorf(codes.Internal, "error starting transaction: %v", err) + } + defer s.store.Rollback(tx) - return &minderv1.ListEvaluationHistoryResponse{}, nil + data, err := s.history.ListEvaluationHistory( + ctx, + s.store.GetQuerierWithTransaction(tx), + cursor, + size, + filter, + ) + if err != nil { + return nil, status.Error(codes.Internal, "error retrieving evaluations") + } + + return &minderv1.ListEvaluationHistoryResponse{ + Data: data, + }, nil } // optsFromStringList calls the given function `f` on each element of diff --git a/internal/controlplane/server.go b/internal/controlplane/server.go index 8563713be3..782ef5c54f 100644 --- a/internal/controlplane/server.go +++ b/internal/controlplane/server.go @@ -57,6 +57,7 @@ import ( "github.com/stacklok/minder/internal/crypto" "github.com/stacklok/minder/internal/db" "github.com/stacklok/minder/internal/events" + "github.com/stacklok/minder/internal/history" "github.com/stacklok/minder/internal/logger" "github.com/stacklok/minder/internal/profiles" "github.com/stacklok/minder/internal/projects" @@ -99,6 +100,7 @@ type Server struct { ruleTypes ruletypes.RuleTypeService repos github.RepositoryService profiles profiles.ProfileService + history history.EvaluationHistoryService ghProviders service.GitHubProviderService providerStore providers.ProviderStore ghClient ghprov.ClientService @@ -134,6 +136,7 @@ func NewServer( idClient auth.Resolver, repoService github.RepositoryService, profileService profiles.ProfileService, + historyService history.EvaluationHistoryService, ruleService ruletypes.RuleTypeService, ghProviders service.GitHubProviderService, providerManager manager.ProviderManager, @@ -152,6 +155,7 @@ func NewServer( jwt: jwtValidator, mt: serverMetrics, profiles: profileService, + history: historyService, ruleTypes: ruleService, providerStore: providerStore, featureFlags: featureFlagClient, diff --git a/internal/history/mock/service.go b/internal/history/mock/service.go index c7b51c203d..7e2c21eb90 100644 --- a/internal/history/mock/service.go +++ b/internal/history/mock/service.go @@ -44,7 +44,7 @@ func (m *MockEvaluationHistoryService) EXPECT() *MockEvaluationHistoryServiceMoc } // ListEvaluationHistory mocks base method. -func (m *MockEvaluationHistoryService) ListEvaluationHistory(ctx context.Context, qtx db.Querier, cursor history.ListEvaluationCursor, size uint64, filter history.ListEvaluationFilter) ([]*v1.EvaluationHistory, error) { +func (m *MockEvaluationHistoryService) ListEvaluationHistory(ctx context.Context, qtx db.Querier, cursor *history.ListEvaluationCursor, size uint64, filter history.ListEvaluationFilter) ([]*v1.EvaluationHistory, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListEvaluationHistory", ctx, qtx, cursor, size, filter) ret0, _ := ret[0].([]*v1.EvaluationHistory) diff --git a/internal/history/service.go b/internal/history/service.go index 5fbd9ffa8d..7bcdbb6fc4 100644 --- a/internal/history/service.go +++ b/internal/history/service.go @@ -23,6 +23,7 @@ import ( "time" "github.com/google/uuid" + "github.com/rs/zerolog" "github.com/stacklok/minder/internal/db" evalerrors "github.com/stacklok/minder/internal/engine/errors" @@ -48,7 +49,7 @@ type EvaluationHistoryService interface { ListEvaluationHistory( ctx context.Context, qtx db.Querier, - cursor ListEvaluationCursor, + cursor *ListEvaluationCursor, size uint64, filter ListEvaluationFilter, ) ([]*minderv1.EvaluationHistory, error) @@ -210,9 +211,15 @@ type ruleEntityParams struct { func (e *evaluationHistoryService) ListEvaluationHistory( ctx context.Context, qtx db.Querier, - cursor ListEvaluationCursor, + cursor *ListEvaluationCursor, size uint64, filter ListEvaluationFilter, ) ([]*minderv1.EvaluationHistory, error) { + zerolog.Ctx(ctx).Debug(). + Str("cursor", fmt.Sprintf("%+v", cursor)). + Uint64("size", size). + Str("filter", fmt.Sprintf("%+v", filter)). + Msg("ListEvaluationHistory request") + return []*minderv1.EvaluationHistory{}, nil } diff --git a/internal/service/service.go b/internal/service/service.go index dc20228418..523193f487 100644 --- a/internal/service/service.go +++ b/internal/service/service.go @@ -91,6 +91,7 @@ func AllInOneServerService( serverconfig.FallbackOAuthClientConfigValues("github", &cfg.Provider.GitHub.OAuthClientConfig) serverconfig.FallbackOAuthClientConfigValues("github-app", &cfg.Provider.GitHubApp.OAuthClientConfig) + historySvc := history.NewEvaluationHistoryService() profileSvc := profiles.NewProfileService(evt) ruleSvc := ruletypes.NewRuleTypeService() marketplace, err := marketplaces.NewMarketplaceFromServiceConfig(cfg.Marketplace, profileSvc, ruleSvc) @@ -152,6 +153,7 @@ func AllInOneServerService( idClient, repos, profileSvc, + historySvc, ruleSvc, ghProviders, providerManager, From ea8bbf3a655468eb8bc1c3941976f0cefa6f4445 Mon Sep 17 00:00:00 2001 From: Michelangelo Mori Date: Mon, 1 Jul 2024 17:38:16 +0200 Subject: [PATCH 03/13] Filter and Cursor routines fully tested. --- internal/controlplane/handlers_evalstatus.go | 20 +- internal/history/models.go | 63 +- internal/history/models_test.go | 655 +++++++++++++++++++ 3 files changed, 699 insertions(+), 39 deletions(-) create mode 100644 internal/history/models_test.go diff --git a/internal/controlplane/handlers_evalstatus.go b/internal/controlplane/handlers_evalstatus.go index 75087dccf2..1bb9706376 100644 --- a/internal/controlplane/handlers_evalstatus.go +++ b/internal/controlplane/handlers_evalstatus.go @@ -63,12 +63,12 @@ func (s *Server) ListEvaluationHistory( // process filter opts := []history.FilterOpt{} - opts = append(opts, optsFromStringList(in.GetEntityType(), history.WithEntityType)...) - opts = append(opts, optsFromStringList(in.GetEntityName(), history.WithEntityName)...) - opts = append(opts, optsFromStringList(in.GetProfileName(), history.WithProfileName)...) - opts = append(opts, optsFromStringList(in.GetStatus(), history.WithStatus)...) - opts = append(opts, optsFromStringList(in.GetRemediation(), history.WithRemediation)...) - opts = append(opts, optsFromStringList(in.GetAlert(), history.WithAlert)...) + opts = append(opts, FilterOptsFromStrings(in.GetEntityType(), history.WithEntityType)...) + opts = append(opts, FilterOptsFromStrings(in.GetEntityName(), history.WithEntityName)...) + opts = append(opts, FilterOptsFromStrings(in.GetProfileName(), history.WithProfileName)...) + opts = append(opts, FilterOptsFromStrings(in.GetStatus(), history.WithStatus)...) + opts = append(opts, FilterOptsFromStrings(in.GetRemediation(), history.WithRemediation)...) + opts = append(opts, FilterOptsFromStrings(in.GetAlert(), history.WithAlert)...) if in.GetFrom() != nil { opts = append(opts, history.WithFrom(in.GetFrom().AsTime())) @@ -105,13 +105,13 @@ func (s *Server) ListEvaluationHistory( }, nil } -// optsFromStringList calls the given function `f` on each element of -// values. Such elements are either "complex", i.e. they represent a -// comma-separated list of sub-elements, or "simple", they do not +// FilterOptsFromStrings calls the given function `f` on each element +// of values. Such elements are either "complex", i.e. they represent +// a comma-separated list of sub-elements, or "simple", they do not // contain comma characters. If element contains one or more comma // characters, it is further split into sub-elements before calling // `f` in them. -func optsFromStringList( +func FilterOptsFromStrings( values []string, f func(string) history.FilterOpt, ) []history.FilterOpt { diff --git a/internal/history/models.go b/internal/history/models.go index 541d856ae4..72c44aedf3 100644 --- a/internal/history/models.go +++ b/internal/history/models.go @@ -1,3 +1,17 @@ +// Copyright 2024 Stacklok, Inc +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + package history import ( @@ -13,9 +27,6 @@ import ( var ( // ErrMalformedCursor represents errors in the cursor payload. ErrMalformedCursor = errors.New("malformed cursor") - // ErrAlreadySet is returned when a field is set multiple - // times. - ErrAlreadySet = errors.New("field already set") // ErrInvalidTimeRange is returned the time range from-to is // either missing one end or from is greater than to. ErrInvalidTimeRange = errors.New("invalid time range") @@ -29,9 +40,9 @@ type Direction string const ( // Next represents the next page. - Next = "next" + Next = Direction("next") // Prev represents the prev page. - Prev = "prev" + Prev = Direction("prev") ) // ListEvaluationCursor is a struct representing a cursor in the @@ -165,10 +176,10 @@ type StatusFilter interface { // AddStatus adds a status for inclusion/exclusion in the // filter. AddStatus(string) error - // IncludedStatus returns the list of included statuses. - IncludedStatus() []string - // ExcludedStatus returns the list of excluded statuses. - ExcludedStatus() []string + // IncludedStatuses returns the list of included statuses. + IncludedStatuses() []string + // ExcludedStatuses returns the list of excluded statuses. + ExcludedStatuses() []string } // RemediationFilter interface should be implemented by types @@ -177,12 +188,12 @@ type RemediationFilter interface { // AddRemediation adds a remediation for inclusion/exclusion // in the filter. AddRemediation(string) error - // IncludedRemediation returns the list of included + // IncludedRemediations returns the list of included // remediations. - IncludedRemediation() []string - // ExcludedRemediation returns the list of excluded + IncludedRemediations() []string + // ExcludedRemediations returns the list of excluded // remediations. - ExcludedRemediation() []string + ExcludedRemediations() []string } // AlertFilter interface should be implemented by types implementing a @@ -191,10 +202,10 @@ type AlertFilter interface { // AddAlert adds an alert setting for inclusion/exclusion in // the filter. AddAlert(string) error - // IncludedAlert returns the list of included alert settings. - IncludedAlert() []string - // IncludedAlert returns the list of excluded alert settings. - ExcludedAlert() []string + // IncludedAlerts returns the list of included alert settings. + IncludedAlerts() []string + // IncludedAlerts returns the list of excluded alert settings. + ExcludedAlerts() []string } // TimeRangeFilter interface should be implemented by types @@ -310,10 +321,10 @@ func (filter *listEvaluationFilter) AddStatus(status string) error { } return nil } -func (filter *listEvaluationFilter) IncludedStatus() []string { +func (filter *listEvaluationFilter) IncludedStatuses() []string { return filter.includedStatuses } -func (filter *listEvaluationFilter) ExcludedStatus() []string { +func (filter *listEvaluationFilter) ExcludedStatuses() []string { return filter.excludedStatuses } @@ -326,10 +337,10 @@ func (filter *listEvaluationFilter) AddRemediation(remediation string) error { } return nil } -func (filter *listEvaluationFilter) IncludedRemediation() []string { +func (filter *listEvaluationFilter) IncludedRemediations() []string { return filter.includedRemediation } -func (filter *listEvaluationFilter) ExcludedRemediation() []string { +func (filter *listEvaluationFilter) ExcludedRemediations() []string { return filter.excludedRemediation } @@ -342,24 +353,18 @@ func (filter *listEvaluationFilter) AddAlert(alert string) error { } return nil } -func (filter *listEvaluationFilter) IncludedAlert() []string { +func (filter *listEvaluationFilter) IncludedAlerts() []string { return filter.includedAlerts } -func (filter *listEvaluationFilter) ExcludedAlert() []string { +func (filter *listEvaluationFilter) ExcludedAlerts() []string { return filter.excludedAlerts } func (filter *listEvaluationFilter) SetFrom(from time.Time) error { - if filter.from != nil { - return fmt.Errorf("%w: from", ErrAlreadySet) - } filter.from = &from return nil } func (filter *listEvaluationFilter) SetTo(to time.Time) error { - if filter.to != nil { - return fmt.Errorf("%w: to", ErrAlreadySet) - } filter.to = &to return nil } diff --git a/internal/history/models_test.go b/internal/history/models_test.go new file mode 100644 index 0000000000..5c5bad2a1f --- /dev/null +++ b/internal/history/models_test.go @@ -0,0 +1,655 @@ +// Copyright 2024 Stacklok, Inc +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package history + +import ( + "encoding/base64" + "testing" + "time" + + "github.com/google/uuid" + "github.com/stretchr/testify/require" +) + +func TestListEvaluationCursor(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + cursor func(*testing.T) string + check func(*testing.T, *ListEvaluationCursor) + err bool + }{ + { + name: "implicit next", + cursor: func(t *testing.T) string { + t.Helper() + payload := []byte("00000000-0000-0000-0000-000000000000") + return base64.StdEncoding.EncodeToString(payload) + }, + check: func(t *testing.T, cursor *ListEvaluationCursor) { + t.Helper() + require.Equal(t, uuid.Nil, cursor.ID) + require.Equal(t, time.UnixMilli(0), cursor.Timestamp) + require.Equal(t, Next, cursor.Direction) + }, + }, + { + name: "explicit next", + cursor: func(t *testing.T) string { + t.Helper() + payload := []byte("+00000000-0000-0000-0000-000000000000") + return base64.StdEncoding.EncodeToString(payload) + }, + check: func(t *testing.T, cursor *ListEvaluationCursor) { + t.Helper() + require.Equal(t, uuid.Nil, cursor.ID) + require.Equal(t, time.UnixMilli(0), cursor.Timestamp) + require.Equal(t, Next, cursor.Direction) + }, + }, + { + name: "explicit prev", + cursor: func(t *testing.T) string { + t.Helper() + payload := []byte("-00000000-0000-0000-0000-000000000000") + return base64.StdEncoding.EncodeToString(payload) + }, + check: func(t *testing.T, cursor *ListEvaluationCursor) { + t.Helper() + require.Equal(t, uuid.Nil, cursor.ID) + require.Equal(t, time.UnixMilli(0), cursor.Timestamp) + require.Equal(t, Prev, cursor.Direction) + }, + }, + { + name: "wrong uuid", + cursor: func(t *testing.T) string { + t.Helper() + payload := []byte("malformed") + return base64.StdEncoding.EncodeToString(payload) + }, + err: true, + }, + { + name: "wrong uuid next", + cursor: func(t *testing.T) string { + t.Helper() + payload := []byte("+malformed") + return base64.StdEncoding.EncodeToString(payload) + }, + err: true, + }, + { + name: "wrong uuid prev", + cursor: func(t *testing.T) string { + t.Helper() + payload := []byte("-malformed") + return base64.StdEncoding.EncodeToString(payload) + }, + err: true, + }, + { + name: "empty", + cursor: func(t *testing.T) string { + t.Helper() + return "" + }, + check: func(t *testing.T, cursor *ListEvaluationCursor) { + t.Helper() + require.Equal(t, uuid.Nil, cursor.ID) + require.Equal(t, time.UnixMilli(0), cursor.Timestamp) + require.Equal(t, Next, cursor.Direction) + }, + }, + { + name: "not base64 encoded", + cursor: func(t *testing.T) string { + t.Helper() + return "not base64 encoded" + }, + err: true, + }, + } + + for _, tt := range tests { + tt := tt + + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + + encoded := tt.cursor(t) + res, err := ParseListEvaluationCursor(encoded) + + if tt.err { + require.Error(t, err) + require.Nil(t, res) + return + } + + require.NoError(t, err) + tt.check(t, res) + }) + } +} + +func TestListEvaluationFilter(t *testing.T) { + t.Parallel() + + now := time.Now() + + tests := []struct { + name string + filter func(*testing.T) (ListEvaluationFilter, error) + check func(*testing.T, ListEvaluationFilter) + err bool + }{ + { + name: "happy path", + filter: func(t *testing.T) (ListEvaluationFilter, error) { + t.Helper() + return NewListEvaluationFilter( + WithEntityType("repository"), + ) + }, + check: func(t *testing.T, filter ListEvaluationFilter) { + t.Helper() + require.Equal(t, []string{"repository"}, filter.IncludedEntityTypes()) + }, + }, + { + name: "bogus", + filter: func(t *testing.T) (ListEvaluationFilter, error) { + t.Helper() + return NewListEvaluationFilter( + WithEntityType(""), + ) + }, + err: true, + }, + { + name: "valid time range", + filter: func(t *testing.T) (ListEvaluationFilter, error) { + t.Helper() + return NewListEvaluationFilter( + WithEntityType("repository"), + WithFrom(now), + WithTo(now), + ) + }, + check: func(t *testing.T, filter ListEvaluationFilter) { + t.Helper() + require.Equal(t, []string{"repository"}, filter.IncludedEntityTypes()) + require.Equal(t, now, *filter.GetFrom()) + require.Equal(t, now, *filter.GetTo()) + }, + }, + { + name: "no from", + filter: func(t *testing.T) (ListEvaluationFilter, error) { + t.Helper() + return NewListEvaluationFilter( + WithEntityType("repository"), + WithTo(now), + ) + }, + err: true, + }, + { + name: "no to", + filter: func(t *testing.T) (ListEvaluationFilter, error) { + t.Helper() + return NewListEvaluationFilter( + WithEntityType("repository"), + WithFrom(now), + ) + }, + err: true, + }, + { + name: "from after to", + filter: func(t *testing.T) (ListEvaluationFilter, error) { + t.Helper() + return NewListEvaluationFilter( + WithEntityType("repository"), + WithFrom(now.Add(1*time.Millisecond)), + WithTo(now), + ) + }, + err: true, + }, + } + + for _, tt := range tests { + tt := tt + + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + + res, err := tt.filter(t) + + if tt.err { + require.Error(t, err) + return + } + + require.NoError(t, err) + tt.check(t, res) + }) + } +} + +func TestFilterOptions(t *testing.T) { + t.Parallel() + + now := time.Now() + + tests := []struct { + name string + option func(*testing.T) FilterOpt + filter func(*testing.T) Filter + check func(*testing.T, Filter) + err bool + }{ + // entity type + { + name: "entity type in filter", + option: func(t *testing.T) FilterOpt { + t.Helper() + return WithEntityType("repository") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(EntityTypeFilter) + require.NotNil(t, f.IncludedEntityTypes()) + require.Equal(t, []string{"repository"}, f.IncludedEntityTypes()) + require.Nil(t, f.ExcludedEntityTypes()) + }, + }, + { + name: "entity type not in filter", + option: func(t *testing.T) FilterOpt { + return WithEntityType("!repository") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(EntityTypeFilter) + require.Nil(t, f.IncludedEntityTypes()) + require.NotNil(t, f.ExcludedEntityTypes()) + require.Equal(t, []string{"repository"}, f.ExcludedEntityTypes()) + }, + }, + { + name: "empty entity type", + option: func(t *testing.T) FilterOpt { + return WithEntityType("") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + err: true, + }, + { + name: "bogus entity type", + option: func(t *testing.T) FilterOpt { + return WithEntityType("!") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + err: true, + }, + { + name: "wrong entity type filter", + option: func(t *testing.T) FilterOpt { + return WithEntityType("repository") + }, + filter: func(t *testing.T) Filter { return "foo" }, + err: true, + }, + + // entity name + { + name: "entity name in filter", + option: func(t *testing.T) FilterOpt { + return WithEntityName("repository") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(EntityNameFilter) + require.NotNil(t, f.IncludedEntityNames()) + require.Equal(t, []string{"repository"}, f.IncludedEntityNames()) + require.Nil(t, f.ExcludedEntityNames()) + }, + }, + { + name: "entity name not in filter", + option: func(t *testing.T) FilterOpt { + return WithEntityName("!repository") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(EntityNameFilter) + require.Nil(t, f.IncludedEntityNames()) + require.NotNil(t, f.ExcludedEntityNames()) + require.Equal(t, []string{"repository"}, f.ExcludedEntityNames()) + }, + }, + { + name: "empty entity name", + option: func(t *testing.T) FilterOpt { + return WithEntityName("") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + err: true, + }, + { + name: "bogus entity name", + option: func(t *testing.T) FilterOpt { + return WithEntityName("!") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + err: true, + }, + { + name: "wrong entity name filter", + option: func(t *testing.T) FilterOpt { + return WithEntityName("repository") + }, + filter: func(t *testing.T) Filter { return "foo" }, + err: true, + }, + + // profile name + { + name: "profile name in filter", + option: func(t *testing.T) FilterOpt { + return WithProfileName("repository") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(ProfileNameFilter) + require.NotNil(t, f.IncludedProfileNames()) + require.Equal(t, []string{"repository"}, f.IncludedProfileNames()) + require.Nil(t, f.ExcludedProfileNames()) + }, + }, + { + name: "profile name not in filter", + option: func(t *testing.T) FilterOpt { + return WithProfileName("!repository") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(ProfileNameFilter) + require.Nil(t, f.IncludedProfileNames()) + require.NotNil(t, f.ExcludedProfileNames()) + require.Equal(t, []string{"repository"}, f.ExcludedProfileNames()) + }, + }, + { + name: "empty profile name", + option: func(t *testing.T) FilterOpt { + return WithProfileName("") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + err: true, + }, + { + name: "bogus profile name", + option: func(t *testing.T) FilterOpt { + return WithProfileName("!") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + err: true, + }, + { + name: "wrong profile name filter", + option: func(t *testing.T) FilterOpt { + return WithProfileName("repository") + }, + filter: func(t *testing.T) Filter { return "foo" }, + err: true, + }, + + // status + { + name: "status in filter", + option: func(t *testing.T) FilterOpt { + return WithStatus("repository") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(StatusFilter) + require.NotNil(t, f.IncludedStatuses()) + require.Equal(t, []string{"repository"}, f.IncludedStatuses()) + require.Nil(t, f.ExcludedStatuses()) + }, + }, + { + name: "status not in filter", + option: func(t *testing.T) FilterOpt { + return WithStatus("!repository") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(StatusFilter) + require.Nil(t, f.IncludedStatuses()) + require.NotNil(t, f.ExcludedStatuses()) + require.Equal(t, []string{"repository"}, f.ExcludedStatuses()) + }, + }, + { + name: "empty status", + option: func(t *testing.T) FilterOpt { + return WithStatus("") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + err: true, + }, + { + name: "bogus status", + option: func(t *testing.T) FilterOpt { + return WithStatus("!") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + err: true, + }, + { + name: "wrong status filter", + option: func(t *testing.T) FilterOpt { + return WithStatus("repository") + }, + filter: func(t *testing.T) Filter { return "foo" }, + err: true, + }, + + // remediation + { + name: "remediation in filter", + option: func(t *testing.T) FilterOpt { + return WithRemediation("repository") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(RemediationFilter) + require.NotNil(t, f.IncludedRemediations()) + require.Equal(t, []string{"repository"}, f.IncludedRemediations()) + require.Nil(t, f.ExcludedRemediations()) + }, + }, + { + name: "remediation not in filter", + option: func(t *testing.T) FilterOpt { + return WithRemediation("!repository") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(RemediationFilter) + require.Nil(t, f.IncludedRemediations()) + require.NotNil(t, f.ExcludedRemediations()) + require.Equal(t, []string{"repository"}, f.ExcludedRemediations()) + }, + }, + { + name: "empty remediation", + option: func(t *testing.T) FilterOpt { + return WithRemediation("") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + err: true, + }, + { + name: "bogus remediation", + option: func(t *testing.T) FilterOpt { + return WithRemediation("!") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + err: true, + }, + { + name: "wrong remediation filter", + option: func(t *testing.T) FilterOpt { + return WithRemediation("repository") + }, + filter: func(t *testing.T) Filter { return "foo" }, + err: true, + }, + + // alert + { + name: "alert in filter", + option: func(t *testing.T) FilterOpt { + return WithAlert("repository") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(AlertFilter) + require.NotNil(t, f.IncludedAlerts()) + require.Equal(t, []string{"repository"}, f.IncludedAlerts()) + require.Nil(t, f.ExcludedAlerts()) + }, + }, + { + name: "alert not in filter", + option: func(t *testing.T) FilterOpt { + return WithAlert("!repository") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(AlertFilter) + require.Nil(t, f.IncludedAlerts()) + require.NotNil(t, f.ExcludedAlerts()) + require.Equal(t, []string{"repository"}, f.ExcludedAlerts()) + }, + }, + { + name: "empty alert", + option: func(t *testing.T) FilterOpt { + return WithAlert("") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + err: true, + }, + { + name: "bogus alert", + option: func(t *testing.T) FilterOpt { + return WithAlert("!") + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + err: true, + }, + { + name: "wrong alert filter", + option: func(t *testing.T) FilterOpt { + return WithAlert("repository") + }, + filter: func(t *testing.T) Filter { return "foo" }, + err: true, + }, + + // from-to + { + name: "from in filter", + option: func(t *testing.T) FilterOpt { + return WithFrom(now) + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(TimeRangeFilter) + require.NotNil(t, f.GetFrom()) + require.Nil(t, f.GetTo()) + require.Equal(t, now, *f.GetFrom()) + }, + }, + { + name: "to in filter", + option: func(t *testing.T) FilterOpt { + return WithTo(now) + }, + filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(TimeRangeFilter) + require.Nil(t, f.GetFrom()) + require.NotNil(t, f.GetTo()) + require.Equal(t, now, *f.GetTo()) + }, + }, + { + name: "wrong timerange filter from", + option: func(t *testing.T) FilterOpt { + return WithFrom(now) + }, + filter: func(t *testing.T) Filter { return "foo" }, + err: true, + }, + { + name: "wrong timerange filter to", + option: func(t *testing.T) FilterOpt { + return WithTo(now) + }, + filter: func(t *testing.T) Filter { return "foo" }, + err: true, + }, + } + + for _, tt := range tests { + tt := tt + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + + opt := tt.option(t) + filter := tt.filter(t) + err := opt(filter) + if tt.err { + require.Error(t, err) + return + } + + require.NoError(t, err) + tt.check(t, filter) + }) + } +} From c4e76180f1ad70c13953b5b4692282151666cb53 Mon Sep 17 00:00:00 2001 From: Michelangelo Mori Date: Wed, 3 Jul 2024 09:46:43 +0200 Subject: [PATCH 04/13] Added extraction form database. --- database/mock/store.go | 15 + database/query/eval_history.sql | 53 +++ docs/docs/ref/proto.md | 1 + internal/controlplane/handlers_evalstatus.go | 93 ++++- internal/db/eval_history.sql.go | 130 +++++++ internal/db/querier.go | 1 + internal/engine/eval_status.go | 2 +- internal/history/mock/service.go | 5 +- internal/history/models.go | 49 ++- internal/history/models_test.go | 266 ++++++++++---- internal/history/service.go | 55 ++- internal/history/service_test.go | 23 ++ pkg/api/openapi/minder/v1/minder.swagger.json | 5 + pkg/api/protobuf/go/minder/v1/minder.pb.go | 342 +++++++++--------- proto/minder/v1/minder.proto | 3 + 15 files changed, 772 insertions(+), 271 deletions(-) diff --git a/database/mock/store.go b/database/mock/store.go index 2a882d6a49..861eab39e0 100644 --- a/database/mock/store.go +++ b/database/mock/store.go @@ -1524,6 +1524,21 @@ func (mr *MockStoreMockRecorder) ListArtifactsByRepoID(arg0, arg1 any) *gomock.C return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListArtifactsByRepoID", reflect.TypeOf((*MockStore)(nil).ListArtifactsByRepoID), arg0, arg1) } +// ListEvaluationHistory mocks base method. +func (m *MockStore) ListEvaluationHistory(arg0 context.Context, arg1 db.ListEvaluationHistoryParams) ([]db.ListEvaluationHistoryRow, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListEvaluationHistory", arg0, arg1) + ret0, _ := ret[0].([]db.ListEvaluationHistoryRow) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListEvaluationHistory indicates an expected call of ListEvaluationHistory. +func (mr *MockStoreMockRecorder) ListEvaluationHistory(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListEvaluationHistory", reflect.TypeOf((*MockStore)(nil).ListEvaluationHistory), arg0, arg1) +} + // ListFlushCache mocks base method. func (m *MockStore) ListFlushCache(arg0 context.Context) ([]db.FlushCache, error) { m.ctrl.T.Helper() diff --git a/database/query/eval_history.sql b/database/query/eval_history.sql index 8239403a86..4cff8876e6 100644 --- a/database/query/eval_history.sql +++ b/database/query/eval_history.sql @@ -93,3 +93,56 @@ INSERT INTO alert_events( $3, $4 ); + +-- name: ListEvaluationHistory :many +SELECT s.id::uuid AS evaluation_id, + s.most_recent_evaluation as evaluated_at, + -- entity type + CASE WHEN ere.repository_id IS NOT NULL THEN 'repository'::entities + WHEN ere.pull_request_id IS NOT NULL THEN 'pull_request'::entities + WHEN ere.artifact_id IS NOT NULL THEN 'artifact'::entities + END AS entity_type, + -- entity id + CASE WHEN ere.repository_id IS NOT NULL THEN r.id + WHEN ere.pull_request_id IS NOT NULL THEN pr.id + WHEN ere.artifact_id IS NOT NULL THEN a.id + END AS entity_id, + -- entity name + CASE WHEN ere.repository_id IS NOT NULL THEN r.repo_name + WHEN ere.pull_request_id IS NOT NULL THEN pr.pr_number::text + WHEN ere.artifact_id IS NOT NULL THEN a.artifact_name + END AS entity_name, + -- rule type, name, and profile + rt.name AS rule_type, + ri.name AS rule_name, + p.name AS profile_name, + -- evaluation status and details + s.status AS evaluation_status, + s.details AS evaluation_details, + -- remediation status and details + re.status AS remediation_status, + re.details AS remediation_details, + -- alert status and details + ae.status AS alert_status, + ae.details AS alert_details + FROM evaluation_statuses s + JOIN evaluation_rule_entities ere ON ere.id = s.rule_entity_id + JOIN rule_instances ri ON ere.rule_id = ri.id + JOIN rule_type rt ON ri.rule_type_id = rt.id + JOIN profiles p ON ri.profile_id = p.id + LEFT JOIN repositories r ON ere.repository_id = r.id + LEFT JOIN pull_requests pr ON ere.pull_request_id = pr.id + LEFT JOIN artifacts a ON ere.artifact_id = a.id + LEFT JOIN remediation_events re ON re.evaluation_id = s.id + LEFT JOIN alert_events ae ON ae.evaluation_id = s.id + WHERE (sqlc.narg(next)::timestamp without time zone IS NULL OR sqlc.narg(next) > s.most_recent_evaluation) + AND (sqlc.narg(prev)::timestamp without time zone IS NULL OR sqlc.narg(prev) < s.most_recent_evaluation) + AND (sqlc.slice(entityNames)::text[] IS NULL OR ere.repository_id IS NULL OR r.repo_name = ANY(sqlc.slice(entityNames)::text[])) + AND (sqlc.slice(entityNames)::text[] IS NULL OR ere.pull_request_id IS NULL OR pr.pr_number::text = ANY(sqlc.slice(entityNames)::text[])) + AND (sqlc.slice(entityNames)::text[] IS NULL OR ere.artifact_id IS NULL OR a.artifact_name = ANY(sqlc.slice(entityNames)::text[])) + AND (sqlc.slice(profileNames)::text[] IS NULL OR p.name = ANY(sqlc.slice(profileNames)::text[])) + AND (sqlc.slice(remediations)::action_type[] IS NULL OR p.remediate = ANY(sqlc.slice(remediations)::action_type[])) + AND (sqlc.slice(alerts)::action_type[] IS NULL OR p.alert = ANY(sqlc.slice(alerts)::action_type[])) + AND (sqlc.slice(statuses)::eval_status_types[] IS NULL OR s.status = ANY(sqlc.slice(statuses)::eval_status_types[])) + ORDER BY s.most_recent_evaluation DESC + LIMIT sqlc.arg(size)::integer; diff --git a/docs/docs/ref/proto.md b/docs/docs/ref/proto.md index 37d8b2ed47..b269f6ec09 100644 --- a/docs/docs/ref/proto.md +++ b/docs/docs/ref/proto.md @@ -865,6 +865,7 @@ EvalResultAlert holds the alert details for a given rule evaluation | ----- | ---- | ----- | ----------- | | status | string | | status is one of (success, error, failure, skipped) not using enums to mirror the behaviour of the existing API contracts. | | details | string | | details contains optional details about the evaluation. the structure and contents are rule type specific, and are subject to change. | +| evaluated_at | google.protobuf.Timestamp | | created_at is the timestamp of creation of this evaluation | diff --git a/internal/controlplane/handlers_evalstatus.go b/internal/controlplane/handlers_evalstatus.go index 1bb9706376..18278f3d76 100644 --- a/internal/controlplane/handlers_evalstatus.go +++ b/internal/controlplane/handlers_evalstatus.go @@ -17,6 +17,8 @@ package controlplane import ( "context" + "encoding/base64" + "errors" "fmt" "strings" @@ -89,7 +91,7 @@ func (s *Server) ListEvaluationHistory( } defer s.store.Rollback(tx) - data, err := s.history.ListEvaluationHistory( + result, err := s.history.ListEvaluationHistory( ctx, s.store.GetQuerierWithTransaction(tx), cursor, @@ -100,9 +102,92 @@ func (s *Server) ListEvaluationHistory( return nil, status.Error(codes.Internal, "error retrieving evaluations") } - return &minderv1.ListEvaluationHistoryResponse{ - Data: data, - }, nil + // convert data set to proto + data, err := fromEvaluationHistoryRow(result.Data) + if err != nil { + return nil, err + } + + // return data set to client + resp := &minderv1.ListEvaluationHistoryResponse{} + if len(data) == 0 { + return resp, nil + } + + resp.Data = data + resp.Page = &minderv1.CursorPage{} + + if result.Next != nil { + resp.Page.Next = makeCursor(result.Next, size) + } + if result.Prev != nil { + resp.Page.Prev = makeCursor(result.Prev, size) + } + + return resp, nil +} + +func fromEvaluationHistoryRow( + rows []db.ListEvaluationHistoryRow, +) ([]*minderv1.EvaluationHistory, error) { + res := []*minderv1.EvaluationHistory{} + + for _, row := range rows { + var dbEntityType db.Entities + if err := dbEntityType.Scan(row.EntityType); err != nil { + return nil, errors.New("internal error") + } + entityType := dbEntityToEntity(dbEntityType) + + entityName, ok := row.EntityName.(string) + if !ok { + return nil, errors.New("internal error") + } + + var alert *minderv1.EvaluationHistoryAlert + if row.AlertStatus.Valid { + alert = &minderv1.EvaluationHistoryAlert{ + Status: string(row.AlertStatus.AlertStatusTypes), + Details: row.AlertDetails.String, + } + } + var remediation *minderv1.EvaluationHistoryRemediation + if row.RemediationStatus.Valid { + remediation = &minderv1.EvaluationHistoryRemediation{ + Status: string(row.RemediationStatus.RemediationStatusTypes), + Details: row.RemediationDetails.String, + } + } + + res = append(res, &minderv1.EvaluationHistory{ + Entity: &minderv1.EvaluationHistoryEntity{ + Id: row.EvaluationID.String(), + Type: entityType, + Name: entityName, + }, + Rule: &minderv1.EvaluationHistoryRule{ + Name: row.RuleName, + Type: row.RuleType, + Profile: row.ProfileName, + }, + Status: &minderv1.EvaluationHistoryStatus{ + Status: string(row.EvaluationStatus), + Details: row.EvaluationDetails, + EvaluatedAt: timestamppb.New(row.EvaluatedAt), + }, + Alert: alert, + Remediation: remediation, + }) + } + + return res, nil +} + +func makeCursor(cursor []byte, size uint64) *minderv1.Cursor { + return &minderv1.Cursor{ + Cursor: base64.StdEncoding.EncodeToString(cursor), + Size: size, + } } // FilterOptsFromStrings calls the given function `f` on each element diff --git a/internal/db/eval_history.sql.go b/internal/db/eval_history.sql.go index 840917b5aa..6035d8aed6 100644 --- a/internal/db/eval_history.sql.go +++ b/internal/db/eval_history.sql.go @@ -7,6 +7,7 @@ package db import ( "context" + "database/sql" "encoding/json" "time" @@ -189,6 +190,135 @@ func (q *Queries) InsertRemediationEvent(ctx context.Context, arg InsertRemediat return err } +const listEvaluationHistory = `-- name: ListEvaluationHistory :many +SELECT s.id::uuid AS evaluation_id, + s.most_recent_evaluation as evaluated_at, + -- entity type + CASE WHEN ere.repository_id IS NOT NULL THEN 'repository'::entities + WHEN ere.pull_request_id IS NOT NULL THEN 'pull_request'::entities + WHEN ere.artifact_id IS NOT NULL THEN 'artifact'::entities + END AS entity_type, + -- entity id + CASE WHEN ere.repository_id IS NOT NULL THEN r.id + WHEN ere.pull_request_id IS NOT NULL THEN pr.id + WHEN ere.artifact_id IS NOT NULL THEN a.id + END AS entity_id, + -- entity name + CASE WHEN ere.repository_id IS NOT NULL THEN r.repo_name + WHEN ere.pull_request_id IS NOT NULL THEN pr.pr_number::text + WHEN ere.artifact_id IS NOT NULL THEN a.artifact_name + END AS entity_name, + -- rule type, name, and profile + rt.name AS rule_type, + ri.name AS rule_name, + p.name AS profile_name, + -- evaluation status and details + s.status AS evaluation_status, + s.details AS evaluation_details, + -- remediation status and details + re.status AS remediation_status, + re.details AS remediation_details, + -- alert status and details + ae.status AS alert_status, + ae.details AS alert_details + FROM evaluation_statuses s + JOIN evaluation_rule_entities ere ON ere.id = s.rule_entity_id + JOIN rule_instances ri ON ere.rule_id = ri.id + JOIN rule_type rt ON ri.rule_type_id = rt.id + JOIN profiles p ON ri.profile_id = p.id + LEFT JOIN repositories r ON ere.repository_id = r.id + LEFT JOIN pull_requests pr ON ere.pull_request_id = pr.id + LEFT JOIN artifacts a ON ere.artifact_id = a.id + LEFT JOIN remediation_events re ON re.evaluation_id = s.id + LEFT JOIN alert_events ae ON ae.evaluation_id = s.id + WHERE ($1::timestamp without time zone IS NULL OR $1 > s.most_recent_evaluation) + AND ($2::timestamp without time zone IS NULL OR $2 < s.most_recent_evaluation) + AND ($3::text[] IS NULL OR ere.repository_id IS NULL OR r.repo_name = ANY($3::text[])) + AND ($3::text[] IS NULL OR ere.pull_request_id IS NULL OR pr.pr_number::text = ANY($3::text[])) + AND ($3::text[] IS NULL OR ere.artifact_id IS NULL OR a.artifact_name = ANY($3::text[])) + AND ($4::text[] IS NULL OR p.name = ANY($4::text[])) + AND ($5::action_type[] IS NULL OR p.remediate = ANY($5::action_type[])) + AND ($6::action_type[] IS NULL OR p.alert = ANY($6::action_type[])) + AND ($7::eval_status_types[] IS NULL OR s.status = ANY($7::eval_status_types[])) + ORDER BY s.most_recent_evaluation DESC + LIMIT $8::integer +` + +type ListEvaluationHistoryParams struct { + Next sql.NullTime `json:"next"` + Prev sql.NullTime `json:"prev"` + Entitynames []string `json:"entitynames"` + Profilenames []string `json:"profilenames"` + Remediations []ActionType `json:"remediations"` + Alerts []ActionType `json:"alerts"` + Statuses []EvalStatusTypes `json:"statuses"` + Size int32 `json:"size"` +} + +type ListEvaluationHistoryRow struct { + EvaluationID uuid.UUID `json:"evaluation_id"` + EvaluatedAt time.Time `json:"evaluated_at"` + EntityType interface{} `json:"entity_type"` + EntityID interface{} `json:"entity_id"` + EntityName interface{} `json:"entity_name"` + RuleType string `json:"rule_type"` + RuleName string `json:"rule_name"` + ProfileName string `json:"profile_name"` + EvaluationStatus EvalStatusTypes `json:"evaluation_status"` + EvaluationDetails string `json:"evaluation_details"` + RemediationStatus NullRemediationStatusTypes `json:"remediation_status"` + RemediationDetails sql.NullString `json:"remediation_details"` + AlertStatus NullAlertStatusTypes `json:"alert_status"` + AlertDetails sql.NullString `json:"alert_details"` +} + +func (q *Queries) ListEvaluationHistory(ctx context.Context, arg ListEvaluationHistoryParams) ([]ListEvaluationHistoryRow, error) { + rows, err := q.db.QueryContext(ctx, listEvaluationHistory, + arg.Next, + arg.Prev, + pq.Array(arg.Entitynames), + pq.Array(arg.Profilenames), + pq.Array(arg.Remediations), + pq.Array(arg.Alerts), + pq.Array(arg.Statuses), + arg.Size, + ) + if err != nil { + return nil, err + } + defer rows.Close() + items := []ListEvaluationHistoryRow{} + for rows.Next() { + var i ListEvaluationHistoryRow + if err := rows.Scan( + &i.EvaluationID, + &i.EvaluatedAt, + &i.EntityType, + &i.EntityID, + &i.EntityName, + &i.RuleType, + &i.RuleName, + &i.ProfileName, + &i.EvaluationStatus, + &i.EvaluationDetails, + &i.RemediationStatus, + &i.RemediationDetails, + &i.AlertStatus, + &i.AlertDetails, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Close(); err != nil { + return nil, err + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil +} + const updateEvaluationTimes = `-- name: UpdateEvaluationTimes :exec UPDATE evaluation_statuses SET diff --git a/internal/db/querier.go b/internal/db/querier.go index b0363aa658..516254064b 100644 --- a/internal/db/querier.go +++ b/internal/db/querier.go @@ -157,6 +157,7 @@ type Querier interface { InsertEvaluationStatus(ctx context.Context, arg InsertEvaluationStatusParams) (uuid.UUID, error) InsertRemediationEvent(ctx context.Context, arg InsertRemediationEventParams) error ListArtifactsByRepoID(ctx context.Context, repositoryID uuid.NullUUID) ([]Artifact, error) + ListEvaluationHistory(ctx context.Context, arg ListEvaluationHistoryParams) ([]ListEvaluationHistoryRow, error) ListFlushCache(ctx context.Context) ([]FlushCache, error) // ListInvitationsForProject collects the information visible to project // administrators after an invitation has been issued. In particular, it diff --git a/internal/engine/eval_status.go b/internal/engine/eval_status.go index d9cbf9ec76..55a3d5e67c 100644 --- a/internal/engine/eval_status.go +++ b/internal/engine/eval_status.go @@ -201,7 +201,7 @@ func (e *executor) createOrUpdateEvalStatus( logger.Err(err).Msg("error upserting rule alert details") } - if flags.Bool(ctx, e.featureFlags, flags.EvalHistory) { + if flags.Bool(ctx, e.featureFlags, flags.EvalHistory) || true { // Log in the evaluation history tables _, err = db.WithTransaction(e.querier, func(qtx db.ExtendQuerier) (uuid.UUID, error) { evalID, err := e.historyService.StoreEvaluationStatus( diff --git a/internal/history/mock/service.go b/internal/history/mock/service.go index 7e2c21eb90..a1eebdb853 100644 --- a/internal/history/mock/service.go +++ b/internal/history/mock/service.go @@ -16,7 +16,6 @@ import ( uuid "github.com/google/uuid" db "github.com/stacklok/minder/internal/db" history "github.com/stacklok/minder/internal/history" - v1 "github.com/stacklok/minder/pkg/api/protobuf/go/minder/v1" gomock "go.uber.org/mock/gomock" ) @@ -44,10 +43,10 @@ func (m *MockEvaluationHistoryService) EXPECT() *MockEvaluationHistoryServiceMoc } // ListEvaluationHistory mocks base method. -func (m *MockEvaluationHistoryService) ListEvaluationHistory(ctx context.Context, qtx db.Querier, cursor *history.ListEvaluationCursor, size uint64, filter history.ListEvaluationFilter) ([]*v1.EvaluationHistory, error) { +func (m *MockEvaluationHistoryService) ListEvaluationHistory(ctx context.Context, qtx db.Querier, cursor *history.ListEvaluationCursor, size uint64, filter history.ListEvaluationFilter) (*history.ListEvaluationHistoryResult, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListEvaluationHistory", ctx, qtx, cursor, size, filter) - ret0, _ := ret[0].([]*v1.EvaluationHistory) + ret0, _ := ret[0].(*history.ListEvaluationHistoryResult) ret1, _ := ret[1].(error) return ret0, ret1 } diff --git a/internal/history/models.go b/internal/history/models.go index 72c44aedf3..8e2aaa9cf4 100644 --- a/internal/history/models.go +++ b/internal/history/models.go @@ -18,10 +18,11 @@ import ( "encoding/base64" "errors" "fmt" + "strconv" "strings" "time" - "github.com/google/uuid" + "github.com/stacklok/minder/internal/db" ) var ( @@ -48,8 +49,7 @@ const ( // ListEvaluationCursor is a struct representing a cursor in the // dataset of historical evaluations. type ListEvaluationCursor struct { - ID uuid.UUID - Timestamp time.Time + Time time.Time Direction Direction } @@ -57,8 +57,7 @@ var ( // DefaultCursor is a cursor starting from the beginning of // the data set. DefaultCursor = ListEvaluationCursor{ - ID: uuid.Nil, - Timestamp: time.UnixMilli(0), + Time: time.UnixMicro(999999999999999999), Direction: Next, } ) @@ -67,13 +66,13 @@ var ( // a ListEvaluationCursor. The opaque paylaod is expected to be of one // of the following forms // -// - `"+00000000-0000-0000-0000-000000000000"` meaning the next page +// - `"+1257894000000000"` meaning the next page // of data starting from the given UUID excluded // -// - `"-00000000-0000-0000-0000-000000000000"` meaning the previous +// - `"-1257894000000000"` meaning the previous // page of data starting from the given UUID excluded // -// - `"00000000-0000-0000-0000-000000000000"` meaning the next page +// - `"1257894000000000"` meaning the next page // of data (default) starting from the given UUID excluded func ParseListEvaluationCursor(payload string) (*ListEvaluationCursor, error) { decoded, err := base64.StdEncoding.DecodeString(payload) @@ -85,36 +84,33 @@ func ParseListEvaluationCursor(payload string) (*ListEvaluationCursor, error) { case string(decoded) == "": return &DefaultCursor, nil case strings.HasPrefix(string(decoded), "+"): - // +00000000-0000-0000-0000-000000000000 - id, err := uuid.ParseBytes(decoded[1:]) + // +1257894000000000 + usecs, err := strconv.ParseInt(string(decoded[1:]), 10, 64) if err != nil { return nil, fmt.Errorf("%w: %s", ErrMalformedCursor, err) } return &ListEvaluationCursor{ - ID: id, - Timestamp: time.UnixMilli(0), + Time: time.UnixMicro(usecs).UTC(), Direction: Next, }, nil case strings.HasPrefix(string(decoded), "-"): - // -00000000-0000-0000-0000-000000000000 - id, err := uuid.ParseBytes(decoded[1:]) + // -1257894000000000 + usecs, err := strconv.ParseInt(string(decoded[1:]), 10, 64) if err != nil { return nil, fmt.Errorf("%w: %s", ErrMalformedCursor, err) } return &ListEvaluationCursor{ - ID: id, - Timestamp: time.UnixMilli(0), + Time: time.UnixMicro(usecs).UTC(), Direction: Prev, }, nil default: - // 00000000-0000-0000-0000-000000000000 - id, err := uuid.ParseBytes(decoded) + // 1257894000000000 + usecs, err := strconv.ParseInt(string(decoded), 10, 64) if err != nil { return nil, fmt.Errorf("%w: %s", ErrMalformedCursor, err) } return &ListEvaluationCursor{ - ID: id, - Timestamp: time.UnixMilli(0), + Time: time.UnixMicro(usecs).UTC(), Direction: Next, }, nil } @@ -525,3 +521,16 @@ func NewListEvaluationFilter(opts ...FilterOpt) (ListEvaluationFilter, error) { return filter, nil } + +// ListEvaluationHistoryResult is the return value of +// ListEvaluationHistory function. +type ListEvaluationHistoryResult struct { + // Data is an ordered collection of evaluation events. + Data []db.ListEvaluationHistoryRow + // Next is an object usable as cursor to fetch the next + // page. The page is absent if Next is nil. + Next []byte + // Prev is an object usable as cursor to fetch the previous + // page. The page is absent if Prev is nil. + Prev []byte +} diff --git a/internal/history/models_test.go b/internal/history/models_test.go index 5c5bad2a1f..322e519a37 100644 --- a/internal/history/models_test.go +++ b/internal/history/models_test.go @@ -19,13 +19,16 @@ import ( "testing" "time" - "github.com/google/uuid" "github.com/stretchr/testify/require" ) +var foo = "foo" + func TestListEvaluationCursor(t *testing.T) { t.Parallel() + epoch := time.UnixMicro(0) + tests := []struct { name string cursor func(*testing.T) string @@ -36,13 +39,12 @@ func TestListEvaluationCursor(t *testing.T) { name: "implicit next", cursor: func(t *testing.T) string { t.Helper() - payload := []byte("00000000-0000-0000-0000-000000000000") + payload := []byte("0") return base64.StdEncoding.EncodeToString(payload) }, check: func(t *testing.T, cursor *ListEvaluationCursor) { t.Helper() - require.Equal(t, uuid.Nil, cursor.ID) - require.Equal(t, time.UnixMilli(0), cursor.Timestamp) + require.Equal(t, epoch, cursor.Time) require.Equal(t, Next, cursor.Direction) }, }, @@ -50,13 +52,12 @@ func TestListEvaluationCursor(t *testing.T) { name: "explicit next", cursor: func(t *testing.T) string { t.Helper() - payload := []byte("+00000000-0000-0000-0000-000000000000") + payload := []byte("+0") return base64.StdEncoding.EncodeToString(payload) }, check: func(t *testing.T, cursor *ListEvaluationCursor) { t.Helper() - require.Equal(t, uuid.Nil, cursor.ID) - require.Equal(t, time.UnixMilli(0), cursor.Timestamp) + require.Equal(t, epoch, cursor.Time) require.Equal(t, Next, cursor.Direction) }, }, @@ -64,13 +65,12 @@ func TestListEvaluationCursor(t *testing.T) { name: "explicit prev", cursor: func(t *testing.T) string { t.Helper() - payload := []byte("-00000000-0000-0000-0000-000000000000") + payload := []byte("-0") return base64.StdEncoding.EncodeToString(payload) }, check: func(t *testing.T, cursor *ListEvaluationCursor) { t.Helper() - require.Equal(t, uuid.Nil, cursor.ID) - require.Equal(t, time.UnixMilli(0), cursor.Timestamp) + require.Equal(t, epoch, cursor.Time) require.Equal(t, Prev, cursor.Direction) }, }, @@ -109,8 +109,7 @@ func TestListEvaluationCursor(t *testing.T) { }, check: func(t *testing.T, cursor *ListEvaluationCursor) { t.Helper() - require.Equal(t, uuid.Nil, cursor.ID) - require.Equal(t, time.UnixMilli(0), cursor.Timestamp) + require.Equal(t, epoch, cursor.Time) require.Equal(t, Next, cursor.Direction) }, }, @@ -270,7 +269,10 @@ func TestFilterOptions(t *testing.T) { t.Helper() return WithEntityType("repository") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, check: func(t *testing.T, filter Filter) { t.Helper() f := filter.(EntityTypeFilter) @@ -282,9 +284,13 @@ func TestFilterOptions(t *testing.T) { { name: "entity type not in filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithEntityType("!repository") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, check: func(t *testing.T, filter Filter) { t.Helper() f := filter.(EntityTypeFilter) @@ -296,35 +302,51 @@ func TestFilterOptions(t *testing.T) { { name: "empty entity type", option: func(t *testing.T) FilterOpt { + t.Helper() return WithEntityType("") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + err: true, }, { name: "bogus entity type", option: func(t *testing.T) FilterOpt { + t.Helper() return WithEntityType("!") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + err: true, }, { name: "wrong entity type filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithEntityType("repository") }, - filter: func(t *testing.T) Filter { return "foo" }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return foo + }, + err: true, }, // entity name { name: "entity name in filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithEntityName("repository") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, check: func(t *testing.T, filter Filter) { t.Helper() f := filter.(EntityNameFilter) @@ -336,9 +358,13 @@ func TestFilterOptions(t *testing.T) { { name: "entity name not in filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithEntityName("!repository") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, check: func(t *testing.T, filter Filter) { t.Helper() f := filter.(EntityNameFilter) @@ -350,35 +376,51 @@ func TestFilterOptions(t *testing.T) { { name: "empty entity name", option: func(t *testing.T) FilterOpt { + t.Helper() return WithEntityName("") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + err: true, }, { name: "bogus entity name", option: func(t *testing.T) FilterOpt { + t.Helper() return WithEntityName("!") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + err: true, }, { name: "wrong entity name filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithEntityName("repository") }, - filter: func(t *testing.T) Filter { return "foo" }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return foo + }, + err: true, }, // profile name { name: "profile name in filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithProfileName("repository") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, check: func(t *testing.T, filter Filter) { t.Helper() f := filter.(ProfileNameFilter) @@ -390,9 +432,13 @@ func TestFilterOptions(t *testing.T) { { name: "profile name not in filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithProfileName("!repository") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, check: func(t *testing.T, filter Filter) { t.Helper() f := filter.(ProfileNameFilter) @@ -404,35 +450,51 @@ func TestFilterOptions(t *testing.T) { { name: "empty profile name", option: func(t *testing.T) FilterOpt { + t.Helper() return WithProfileName("") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + err: true, }, { name: "bogus profile name", option: func(t *testing.T) FilterOpt { + t.Helper() return WithProfileName("!") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + err: true, }, { name: "wrong profile name filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithProfileName("repository") }, - filter: func(t *testing.T) Filter { return "foo" }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return foo + }, + err: true, }, // status { name: "status in filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithStatus("repository") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, check: func(t *testing.T, filter Filter) { t.Helper() f := filter.(StatusFilter) @@ -444,9 +506,13 @@ func TestFilterOptions(t *testing.T) { { name: "status not in filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithStatus("!repository") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, check: func(t *testing.T, filter Filter) { t.Helper() f := filter.(StatusFilter) @@ -458,35 +524,51 @@ func TestFilterOptions(t *testing.T) { { name: "empty status", option: func(t *testing.T) FilterOpt { + t.Helper() return WithStatus("") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + err: true, }, { name: "bogus status", option: func(t *testing.T) FilterOpt { + t.Helper() return WithStatus("!") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + err: true, }, { name: "wrong status filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithStatus("repository") }, - filter: func(t *testing.T) Filter { return "foo" }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return foo + }, + err: true, }, // remediation { name: "remediation in filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithRemediation("repository") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, check: func(t *testing.T, filter Filter) { t.Helper() f := filter.(RemediationFilter) @@ -498,9 +580,13 @@ func TestFilterOptions(t *testing.T) { { name: "remediation not in filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithRemediation("!repository") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, check: func(t *testing.T, filter Filter) { t.Helper() f := filter.(RemediationFilter) @@ -512,35 +598,51 @@ func TestFilterOptions(t *testing.T) { { name: "empty remediation", option: func(t *testing.T) FilterOpt { + t.Helper() return WithRemediation("") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + err: true, }, { name: "bogus remediation", option: func(t *testing.T) FilterOpt { + t.Helper() return WithRemediation("!") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + err: true, }, { name: "wrong remediation filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithRemediation("repository") }, - filter: func(t *testing.T) Filter { return "foo" }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return foo + }, + err: true, }, // alert { name: "alert in filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithAlert("repository") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, check: func(t *testing.T, filter Filter) { t.Helper() f := filter.(AlertFilter) @@ -552,9 +654,13 @@ func TestFilterOptions(t *testing.T) { { name: "alert not in filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithAlert("!repository") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, check: func(t *testing.T, filter Filter) { t.Helper() f := filter.(AlertFilter) @@ -566,35 +672,51 @@ func TestFilterOptions(t *testing.T) { { name: "empty alert", option: func(t *testing.T) FilterOpt { + t.Helper() return WithAlert("") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + err: true, }, { name: "bogus alert", option: func(t *testing.T) FilterOpt { + t.Helper() return WithAlert("!") }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + err: true, }, { name: "wrong alert filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithAlert("repository") }, - filter: func(t *testing.T) Filter { return "foo" }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return foo + }, + err: true, }, // from-to { name: "from in filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithFrom(now) }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, check: func(t *testing.T, filter Filter) { t.Helper() f := filter.(TimeRangeFilter) @@ -606,9 +728,13 @@ func TestFilterOptions(t *testing.T) { { name: "to in filter", option: func(t *testing.T) FilterOpt { + t.Helper() return WithTo(now) }, - filter: func(t *testing.T) Filter { return &listEvaluationFilter{} }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, check: func(t *testing.T, filter Filter) { t.Helper() f := filter.(TimeRangeFilter) @@ -620,18 +746,26 @@ func TestFilterOptions(t *testing.T) { { name: "wrong timerange filter from", option: func(t *testing.T) FilterOpt { + t.Helper() return WithFrom(now) }, - filter: func(t *testing.T) Filter { return "foo" }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return foo + }, + err: true, }, { name: "wrong timerange filter to", option: func(t *testing.T) FilterOpt { + t.Helper() return WithTo(now) }, - filter: func(t *testing.T) Filter { return "foo" }, - err: true, + filter: func(t *testing.T) Filter { + t.Helper() + return foo + }, + err: true, }, } diff --git a/internal/history/service.go b/internal/history/service.go index 7bcdbb6fc4..fd51403f22 100644 --- a/internal/history/service.go +++ b/internal/history/service.go @@ -23,11 +23,9 @@ import ( "time" "github.com/google/uuid" - "github.com/rs/zerolog" "github.com/stacklok/minder/internal/db" evalerrors "github.com/stacklok/minder/internal/engine/errors" - minderv1 "github.com/stacklok/minder/pkg/api/protobuf/go/minder/v1" ) //go:generate go run go.uber.org/mock/mockgen -package mock_$GOPACKAGE -destination=./mock/$GOFILE -source=./$GOFILE @@ -52,7 +50,7 @@ type EvaluationHistoryService interface { cursor *ListEvaluationCursor, size uint64, filter ListEvaluationFilter, - ) ([]*minderv1.EvaluationHistory, error) + ) (*ListEvaluationHistoryResult, error) } // NewEvaluationHistoryService creates a new instance of EvaluationHistoryService @@ -207,19 +205,50 @@ type ruleEntityParams struct { PullRequestID uuid.NullUUID } -//nolint:revive -func (e *evaluationHistoryService) ListEvaluationHistory( +func (_ *evaluationHistoryService) ListEvaluationHistory( ctx context.Context, qtx db.Querier, cursor *ListEvaluationCursor, size uint64, filter ListEvaluationFilter, -) ([]*minderv1.EvaluationHistory, error) { - zerolog.Ctx(ctx).Debug(). - Str("cursor", fmt.Sprintf("%+v", cursor)). - Uint64("size", size). - Str("filter", fmt.Sprintf("%+v", filter)). - Msg("ListEvaluationHistory request") - - return []*minderv1.EvaluationHistory{}, nil +) (*ListEvaluationHistoryResult, error) { + params := db.ListEvaluationHistoryParams{ + Size: int32(size), + } + if string(cursor.Direction) == "next" { + params.Next = sql.NullTime{ + Time: cursor.Time, + Valid: true, + } + } + if string(cursor.Direction) == "prev" { + params.Prev = sql.NullTime{ + Time: cursor.Time, + Valid: true, + } + } + if len(filter.IncludedEntityNames()) != 0 { + params.Entitynames = filter.IncludedEntityNames() + } + if len(filter.IncludedProfileNames()) != 0 { + params.Profilenames = filter.IncludedProfileNames() + } + + rows, err := qtx.ListEvaluationHistory(ctx, params) + if err != nil { + return nil, errors.New("internal error") + } + + result := &ListEvaluationHistoryResult{ + Data: rows, + } + if len(rows) > 0 { + newest := rows[0] + oldest := rows[len(rows)-1] + + result.Next = []byte(fmt.Sprintf("+%d", oldest.EvaluatedAt.UnixMicro())) + result.Prev = []byte(fmt.Sprintf("-%d", newest.EvaluatedAt.UnixMicro())) + } + + return result, nil } diff --git a/internal/history/service_test.go b/internal/history/service_test.go index 7619f5c8fc..5f1c79a166 100644 --- a/internal/history/service_test.go +++ b/internal/history/service_test.go @@ -154,6 +154,29 @@ func TestStoreEvaluationStatus(t *testing.T) { } } +func TestListEvaluationHistory(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + entityType db.Entities + dbSetup dbf.DBMockBuilder + err bool + }{ + { + name: "StoreEvaluationStatus rejects invalid entity type", + entityType: "I'm a little teapot", + err: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + }) + } +} + var ( ruleID = uuid.New() entityID = uuid.New() diff --git a/pkg/api/openapi/minder/v1/minder.swagger.json b/pkg/api/openapi/minder/v1/minder.swagger.json index eaa13c7b76..c0fdecfbb9 100644 --- a/pkg/api/openapi/minder/v1/minder.swagger.json +++ b/pkg/api/openapi/minder/v1/minder.swagger.json @@ -3710,6 +3710,11 @@ "details": { "type": "string", "description": "details contains optional details about the evaluation.\nthe structure and contents are rule type specific, and are subject to change." + }, + "evaluatedAt": { + "type": "string", + "format": "date-time", + "title": "created_at is the timestamp of creation of this evaluation" } } }, diff --git a/pkg/api/protobuf/go/minder/v1/minder.pb.go b/pkg/api/protobuf/go/minder/v1/minder.pb.go index 851c15c634..e53749f9b9 100644 --- a/pkg/api/protobuf/go/minder/v1/minder.pb.go +++ b/pkg/api/protobuf/go/minder/v1/minder.pb.go @@ -10888,6 +10888,8 @@ type EvaluationHistoryStatus struct { // details contains optional details about the evaluation. // the structure and contents are rule type specific, and are subject to change. Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"` + // created_at is the timestamp of creation of this evaluation + EvaluatedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=evaluated_at,json=evaluatedAt,proto3" json:"evaluated_at,omitempty"` } func (x *EvaluationHistoryStatus) Reset() { @@ -10936,6 +10938,13 @@ func (x *EvaluationHistoryStatus) GetDetails() string { return "" } +func (x *EvaluationHistoryStatus) GetEvaluatedAt() *timestamppb.Timestamp { + if x != nil { + return x.EvaluatedAt + } + return nil +} + type EvaluationHistoryRemediation struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -14395,12 +14404,16 @@ var file_minder_v1_minder_proto_rawDesc = []byte{ 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, - 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x22, 0x4b, 0x0a, 0x17, 0x45, 0x76, 0x61, 0x6c, 0x75, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, - 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, 0x74, - 0x61, 0x69, 0x6c, 0x73, 0x22, 0x50, 0x0a, 0x1c, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, + 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x22, 0x8a, 0x01, 0x0a, 0x17, 0x45, 0x76, 0x61, 0x6c, + 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x64, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x3d, 0x0a, 0x0c, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, + 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, + 0x65, 0x64, 0x41, 0x74, 0x22, 0x50, 0x0a, 0x1c, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, @@ -15569,164 +15582,165 @@ var file_minder_v1_minder_proto_depIdxs = []int32{ 177, // 179: minder.v1.EvaluationHistory.alert:type_name -> minder.v1.EvaluationHistoryAlert 176, // 180: minder.v1.EvaluationHistory.remediation:type_name -> minder.v1.EvaluationHistoryRemediation 4, // 181: minder.v1.EvaluationHistoryEntity.type:type_name -> minder.v1.Entity - 22, // 182: minder.v1.PrDependencies.ContextualDependency.dep:type_name -> minder.v1.Dependency - 179, // 183: minder.v1.PrDependencies.ContextualDependency.file:type_name -> minder.v1.PrDependencies.ContextualDependency.FilePatch - 181, // 184: minder.v1.PrContents.File.patch_lines:type_name -> minder.v1.PrContents.File.Line - 86, // 185: minder.v1.AutoRegistration.EntitiesEntry.value:type_name -> minder.v1.EntityAutoRegistrationConfig - 78, // 186: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults.profile_status:type_name -> minder.v1.ProfileStatus - 80, // 187: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults.results:type_name -> minder.v1.RuleEvaluationStatus - 81, // 188: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults.entity:type_name -> minder.v1.EntityTypedId - 185, // 189: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults.profiles:type_name -> minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults - 208, // 190: minder.v1.RuleType.Definition.rule_schema:type_name -> google.protobuf.Struct - 208, // 191: minder.v1.RuleType.Definition.param_schema:type_name -> google.protobuf.Struct - 190, // 192: minder.v1.RuleType.Definition.ingest:type_name -> minder.v1.RuleType.Definition.Ingest - 191, // 193: minder.v1.RuleType.Definition.eval:type_name -> minder.v1.RuleType.Definition.Eval - 192, // 194: minder.v1.RuleType.Definition.remediate:type_name -> minder.v1.RuleType.Definition.Remediate - 193, // 195: minder.v1.RuleType.Definition.alert:type_name -> minder.v1.RuleType.Definition.Alert - 110, // 196: minder.v1.RuleType.Definition.Ingest.rest:type_name -> minder.v1.RestType - 111, // 197: minder.v1.RuleType.Definition.Ingest.builtin:type_name -> minder.v1.BuiltinType - 112, // 198: minder.v1.RuleType.Definition.Ingest.artifact:type_name -> minder.v1.ArtifactType - 113, // 199: minder.v1.RuleType.Definition.Ingest.git:type_name -> minder.v1.GitType - 114, // 200: minder.v1.RuleType.Definition.Ingest.diff:type_name -> minder.v1.DiffType - 194, // 201: minder.v1.RuleType.Definition.Eval.jq:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison - 195, // 202: minder.v1.RuleType.Definition.Eval.rego:type_name -> minder.v1.RuleType.Definition.Eval.Rego - 196, // 203: minder.v1.RuleType.Definition.Eval.vulncheck:type_name -> minder.v1.RuleType.Definition.Eval.Vulncheck - 197, // 204: minder.v1.RuleType.Definition.Eval.trusty:type_name -> minder.v1.RuleType.Definition.Eval.Trusty - 198, // 205: minder.v1.RuleType.Definition.Eval.homoglyphs:type_name -> minder.v1.RuleType.Definition.Eval.Homoglyphs - 110, // 206: minder.v1.RuleType.Definition.Remediate.rest:type_name -> minder.v1.RestType - 200, // 207: minder.v1.RuleType.Definition.Remediate.gh_branch_protection:type_name -> minder.v1.RuleType.Definition.Remediate.GhBranchProtectionType - 201, // 208: minder.v1.RuleType.Definition.Remediate.pull_request:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation - 204, // 209: minder.v1.RuleType.Definition.Alert.security_advisory:type_name -> minder.v1.RuleType.Definition.Alert.AlertTypeSA - 199, // 210: minder.v1.RuleType.Definition.Eval.JQComparison.ingested:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison.Operator - 199, // 211: minder.v1.RuleType.Definition.Eval.JQComparison.profile:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison.Operator - 202, // 212: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.contents:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.Content - 203, // 213: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.actions_replace_tags_with_sha:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.ActionsReplaceTagsWithSha - 208, // 214: minder.v1.Profile.Rule.params:type_name -> google.protobuf.Struct - 208, // 215: minder.v1.Profile.Rule.def:type_name -> google.protobuf.Struct - 210, // 216: minder.v1.name:extendee -> google.protobuf.EnumValueOptions - 211, // 217: minder.v1.rpc_options:extendee -> google.protobuf.MethodOptions - 10, // 218: minder.v1.rpc_options:type_name -> minder.v1.RpcOptions - 27, // 219: minder.v1.HealthService.CheckHealth:input_type -> minder.v1.CheckHealthRequest - 13, // 220: minder.v1.ArtifactService.ListArtifacts:input_type -> minder.v1.ListArtifactsRequest - 17, // 221: minder.v1.ArtifactService.GetArtifactById:input_type -> minder.v1.GetArtifactByIdRequest - 19, // 222: minder.v1.ArtifactService.GetArtifactByName:input_type -> minder.v1.GetArtifactByNameRequest - 29, // 223: minder.v1.OAuthService.GetAuthorizationURL:input_type -> minder.v1.GetAuthorizationURLRequest - 31, // 224: minder.v1.OAuthService.StoreProviderToken:input_type -> minder.v1.StoreProviderTokenRequest - 53, // 225: minder.v1.OAuthService.VerifyProviderTokenFrom:input_type -> minder.v1.VerifyProviderTokenFromRequest - 55, // 226: minder.v1.OAuthService.VerifyProviderCredential:input_type -> minder.v1.VerifyProviderCredentialRequest - 38, // 227: minder.v1.RepositoryService.RegisterRepository:input_type -> minder.v1.RegisterRepositoryRequest - 34, // 228: minder.v1.RepositoryService.ListRemoteRepositoriesFromProvider:input_type -> minder.v1.ListRemoteRepositoriesFromProviderRequest - 49, // 229: minder.v1.RepositoryService.ListRepositories:input_type -> minder.v1.ListRepositoriesRequest - 41, // 230: minder.v1.RepositoryService.GetRepositoryById:input_type -> minder.v1.GetRepositoryByIdRequest - 45, // 231: minder.v1.RepositoryService.GetRepositoryByName:input_type -> minder.v1.GetRepositoryByNameRequest - 43, // 232: minder.v1.RepositoryService.DeleteRepositoryById:input_type -> minder.v1.DeleteRepositoryByIdRequest - 47, // 233: minder.v1.RepositoryService.DeleteRepositoryByName:input_type -> minder.v1.DeleteRepositoryByNameRequest - 58, // 234: minder.v1.UserService.CreateUser:input_type -> minder.v1.CreateUserRequest - 60, // 235: minder.v1.UserService.DeleteUser:input_type -> minder.v1.DeleteUserRequest - 64, // 236: minder.v1.UserService.GetUser:input_type -> minder.v1.GetUserRequest - 145, // 237: minder.v1.UserService.ListInvitations:input_type -> minder.v1.ListInvitationsRequest - 147, // 238: minder.v1.UserService.ResolveInvitation:input_type -> minder.v1.ResolveInvitationRequest - 66, // 239: minder.v1.ProfileService.CreateProfile:input_type -> minder.v1.CreateProfileRequest - 68, // 240: minder.v1.ProfileService.UpdateProfile:input_type -> minder.v1.UpdateProfileRequest - 70, // 241: minder.v1.ProfileService.PatchProfile:input_type -> minder.v1.PatchProfileRequest - 72, // 242: minder.v1.ProfileService.DeleteProfile:input_type -> minder.v1.DeleteProfileRequest - 74, // 243: minder.v1.ProfileService.ListProfiles:input_type -> minder.v1.ListProfilesRequest - 76, // 244: minder.v1.ProfileService.GetProfileById:input_type -> minder.v1.GetProfileByIdRequest - 82, // 245: minder.v1.ProfileService.GetProfileStatusByName:input_type -> minder.v1.GetProfileStatusByNameRequest - 84, // 246: minder.v1.ProfileService.GetProfileStatusByProject:input_type -> minder.v1.GetProfileStatusByProjectRequest - 96, // 247: minder.v1.ProfileService.ListRuleTypes:input_type -> minder.v1.ListRuleTypesRequest - 98, // 248: minder.v1.ProfileService.GetRuleTypeByName:input_type -> minder.v1.GetRuleTypeByNameRequest - 100, // 249: minder.v1.ProfileService.GetRuleTypeById:input_type -> minder.v1.GetRuleTypeByIdRequest - 102, // 250: minder.v1.ProfileService.CreateRuleType:input_type -> minder.v1.CreateRuleTypeRequest - 104, // 251: minder.v1.ProfileService.UpdateRuleType:input_type -> minder.v1.UpdateRuleTypeRequest - 106, // 252: minder.v1.ProfileService.DeleteRuleType:input_type -> minder.v1.DeleteRuleTypeRequest - 108, // 253: minder.v1.EvalResultsService.ListEvaluationResults:input_type -> minder.v1.ListEvaluationResultsRequest - 170, // 254: minder.v1.EvalResultsService.ListEvaluationHistory:input_type -> minder.v1.ListEvaluationHistoryRequest - 133, // 255: minder.v1.PermissionsService.ListRoles:input_type -> minder.v1.ListRolesRequest - 135, // 256: minder.v1.PermissionsService.ListRoleAssignments:input_type -> minder.v1.ListRoleAssignmentsRequest - 137, // 257: minder.v1.PermissionsService.AssignRole:input_type -> minder.v1.AssignRoleRequest - 139, // 258: minder.v1.PermissionsService.UpdateRole:input_type -> minder.v1.UpdateRoleRequest - 141, // 259: minder.v1.PermissionsService.RemoveRole:input_type -> minder.v1.RemoveRoleRequest - 118, // 260: minder.v1.ProjectsService.ListProjects:input_type -> minder.v1.ListProjectsRequest - 120, // 261: minder.v1.ProjectsService.CreateProject:input_type -> minder.v1.CreateProjectRequest - 129, // 262: minder.v1.ProjectsService.ListChildProjects:input_type -> minder.v1.ListChildProjectsRequest - 122, // 263: minder.v1.ProjectsService.DeleteProject:input_type -> minder.v1.DeleteProjectRequest - 124, // 264: minder.v1.ProjectsService.UpdateProject:input_type -> minder.v1.UpdateProjectRequest - 127, // 265: minder.v1.ProjectsService.PatchProject:input_type -> minder.v1.PatchProjectRequest - 131, // 266: minder.v1.ProjectsService.CreateEntityReconciliationTask:input_type -> minder.v1.CreateEntityReconciliationTaskRequest - 164, // 267: minder.v1.ProvidersService.PatchProvider:input_type -> minder.v1.PatchProviderRequest - 150, // 268: minder.v1.ProvidersService.GetProvider:input_type -> minder.v1.GetProviderRequest - 152, // 269: minder.v1.ProvidersService.ListProviders:input_type -> minder.v1.ListProvidersRequest - 154, // 270: minder.v1.ProvidersService.CreateProvider:input_type -> minder.v1.CreateProviderRequest - 156, // 271: minder.v1.ProvidersService.DeleteProvider:input_type -> minder.v1.DeleteProviderRequest - 158, // 272: minder.v1.ProvidersService.DeleteProviderByID:input_type -> minder.v1.DeleteProviderByIDRequest - 160, // 273: minder.v1.ProvidersService.GetUnclaimedProviders:input_type -> minder.v1.GetUnclaimedProvidersRequest - 162, // 274: minder.v1.ProvidersService.ListProviderClasses:input_type -> minder.v1.ListProviderClassesRequest - 51, // 275: minder.v1.ProvidersService.ReconcileEntityRegistration:input_type -> minder.v1.ReconcileEntityRegistrationRequest - 25, // 276: minder.v1.InviteService.GetInviteDetails:input_type -> minder.v1.GetInviteDetailsRequest - 28, // 277: minder.v1.HealthService.CheckHealth:output_type -> minder.v1.CheckHealthResponse - 14, // 278: minder.v1.ArtifactService.ListArtifacts:output_type -> minder.v1.ListArtifactsResponse - 18, // 279: minder.v1.ArtifactService.GetArtifactById:output_type -> minder.v1.GetArtifactByIdResponse - 20, // 280: minder.v1.ArtifactService.GetArtifactByName:output_type -> minder.v1.GetArtifactByNameResponse - 30, // 281: minder.v1.OAuthService.GetAuthorizationURL:output_type -> minder.v1.GetAuthorizationURLResponse - 32, // 282: minder.v1.OAuthService.StoreProviderToken:output_type -> minder.v1.StoreProviderTokenResponse - 54, // 283: minder.v1.OAuthService.VerifyProviderTokenFrom:output_type -> minder.v1.VerifyProviderTokenFromResponse - 56, // 284: minder.v1.OAuthService.VerifyProviderCredential:output_type -> minder.v1.VerifyProviderCredentialResponse - 40, // 285: minder.v1.RepositoryService.RegisterRepository:output_type -> minder.v1.RegisterRepositoryResponse - 35, // 286: minder.v1.RepositoryService.ListRemoteRepositoriesFromProvider:output_type -> minder.v1.ListRemoteRepositoriesFromProviderResponse - 50, // 287: minder.v1.RepositoryService.ListRepositories:output_type -> minder.v1.ListRepositoriesResponse - 42, // 288: minder.v1.RepositoryService.GetRepositoryById:output_type -> minder.v1.GetRepositoryByIdResponse - 46, // 289: minder.v1.RepositoryService.GetRepositoryByName:output_type -> minder.v1.GetRepositoryByNameResponse - 44, // 290: minder.v1.RepositoryService.DeleteRepositoryById:output_type -> minder.v1.DeleteRepositoryByIdResponse - 48, // 291: minder.v1.RepositoryService.DeleteRepositoryByName:output_type -> minder.v1.DeleteRepositoryByNameResponse - 59, // 292: minder.v1.UserService.CreateUser:output_type -> minder.v1.CreateUserResponse - 61, // 293: minder.v1.UserService.DeleteUser:output_type -> minder.v1.DeleteUserResponse - 65, // 294: minder.v1.UserService.GetUser:output_type -> minder.v1.GetUserResponse - 146, // 295: minder.v1.UserService.ListInvitations:output_type -> minder.v1.ListInvitationsResponse - 148, // 296: minder.v1.UserService.ResolveInvitation:output_type -> minder.v1.ResolveInvitationResponse - 67, // 297: minder.v1.ProfileService.CreateProfile:output_type -> minder.v1.CreateProfileResponse - 69, // 298: minder.v1.ProfileService.UpdateProfile:output_type -> minder.v1.UpdateProfileResponse - 71, // 299: minder.v1.ProfileService.PatchProfile:output_type -> minder.v1.PatchProfileResponse - 73, // 300: minder.v1.ProfileService.DeleteProfile:output_type -> minder.v1.DeleteProfileResponse - 75, // 301: minder.v1.ProfileService.ListProfiles:output_type -> minder.v1.ListProfilesResponse - 77, // 302: minder.v1.ProfileService.GetProfileById:output_type -> minder.v1.GetProfileByIdResponse - 83, // 303: minder.v1.ProfileService.GetProfileStatusByName:output_type -> minder.v1.GetProfileStatusByNameResponse - 85, // 304: minder.v1.ProfileService.GetProfileStatusByProject:output_type -> minder.v1.GetProfileStatusByProjectResponse - 97, // 305: minder.v1.ProfileService.ListRuleTypes:output_type -> minder.v1.ListRuleTypesResponse - 99, // 306: minder.v1.ProfileService.GetRuleTypeByName:output_type -> minder.v1.GetRuleTypeByNameResponse - 101, // 307: minder.v1.ProfileService.GetRuleTypeById:output_type -> minder.v1.GetRuleTypeByIdResponse - 103, // 308: minder.v1.ProfileService.CreateRuleType:output_type -> minder.v1.CreateRuleTypeResponse - 105, // 309: minder.v1.ProfileService.UpdateRuleType:output_type -> minder.v1.UpdateRuleTypeResponse - 107, // 310: minder.v1.ProfileService.DeleteRuleType:output_type -> minder.v1.DeleteRuleTypeResponse - 109, // 311: minder.v1.EvalResultsService.ListEvaluationResults:output_type -> minder.v1.ListEvaluationResultsResponse - 171, // 312: minder.v1.EvalResultsService.ListEvaluationHistory:output_type -> minder.v1.ListEvaluationHistoryResponse - 134, // 313: minder.v1.PermissionsService.ListRoles:output_type -> minder.v1.ListRolesResponse - 136, // 314: minder.v1.PermissionsService.ListRoleAssignments:output_type -> minder.v1.ListRoleAssignmentsResponse - 138, // 315: minder.v1.PermissionsService.AssignRole:output_type -> minder.v1.AssignRoleResponse - 140, // 316: minder.v1.PermissionsService.UpdateRole:output_type -> minder.v1.UpdateRoleResponse - 142, // 317: minder.v1.PermissionsService.RemoveRole:output_type -> minder.v1.RemoveRoleResponse - 119, // 318: minder.v1.ProjectsService.ListProjects:output_type -> minder.v1.ListProjectsResponse - 121, // 319: minder.v1.ProjectsService.CreateProject:output_type -> minder.v1.CreateProjectResponse - 130, // 320: minder.v1.ProjectsService.ListChildProjects:output_type -> minder.v1.ListChildProjectsResponse - 123, // 321: minder.v1.ProjectsService.DeleteProject:output_type -> minder.v1.DeleteProjectResponse - 125, // 322: minder.v1.ProjectsService.UpdateProject:output_type -> minder.v1.UpdateProjectResponse - 128, // 323: minder.v1.ProjectsService.PatchProject:output_type -> minder.v1.PatchProjectResponse - 132, // 324: minder.v1.ProjectsService.CreateEntityReconciliationTask:output_type -> minder.v1.CreateEntityReconciliationTaskResponse - 165, // 325: minder.v1.ProvidersService.PatchProvider:output_type -> minder.v1.PatchProviderResponse - 151, // 326: minder.v1.ProvidersService.GetProvider:output_type -> minder.v1.GetProviderResponse - 153, // 327: minder.v1.ProvidersService.ListProviders:output_type -> minder.v1.ListProvidersResponse - 155, // 328: minder.v1.ProvidersService.CreateProvider:output_type -> minder.v1.CreateProviderResponse - 157, // 329: minder.v1.ProvidersService.DeleteProvider:output_type -> minder.v1.DeleteProviderResponse - 159, // 330: minder.v1.ProvidersService.DeleteProviderByID:output_type -> minder.v1.DeleteProviderByIDResponse - 161, // 331: minder.v1.ProvidersService.GetUnclaimedProviders:output_type -> minder.v1.GetUnclaimedProvidersResponse - 163, // 332: minder.v1.ProvidersService.ListProviderClasses:output_type -> minder.v1.ListProviderClassesResponse - 52, // 333: minder.v1.ProvidersService.ReconcileEntityRegistration:output_type -> minder.v1.ReconcileEntityRegistrationResponse - 26, // 334: minder.v1.InviteService.GetInviteDetails:output_type -> minder.v1.GetInviteDetailsResponse - 277, // [277:335] is the sub-list for method output_type - 219, // [219:277] is the sub-list for method input_type - 218, // [218:219] is the sub-list for extension type_name - 216, // [216:218] is the sub-list for extension extendee - 0, // [0:216] is the sub-list for field type_name + 207, // 182: minder.v1.EvaluationHistoryStatus.evaluated_at:type_name -> google.protobuf.Timestamp + 22, // 183: minder.v1.PrDependencies.ContextualDependency.dep:type_name -> minder.v1.Dependency + 179, // 184: minder.v1.PrDependencies.ContextualDependency.file:type_name -> minder.v1.PrDependencies.ContextualDependency.FilePatch + 181, // 185: minder.v1.PrContents.File.patch_lines:type_name -> minder.v1.PrContents.File.Line + 86, // 186: minder.v1.AutoRegistration.EntitiesEntry.value:type_name -> minder.v1.EntityAutoRegistrationConfig + 78, // 187: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults.profile_status:type_name -> minder.v1.ProfileStatus + 80, // 188: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults.results:type_name -> minder.v1.RuleEvaluationStatus + 81, // 189: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults.entity:type_name -> minder.v1.EntityTypedId + 185, // 190: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults.profiles:type_name -> minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults + 208, // 191: minder.v1.RuleType.Definition.rule_schema:type_name -> google.protobuf.Struct + 208, // 192: minder.v1.RuleType.Definition.param_schema:type_name -> google.protobuf.Struct + 190, // 193: minder.v1.RuleType.Definition.ingest:type_name -> minder.v1.RuleType.Definition.Ingest + 191, // 194: minder.v1.RuleType.Definition.eval:type_name -> minder.v1.RuleType.Definition.Eval + 192, // 195: minder.v1.RuleType.Definition.remediate:type_name -> minder.v1.RuleType.Definition.Remediate + 193, // 196: minder.v1.RuleType.Definition.alert:type_name -> minder.v1.RuleType.Definition.Alert + 110, // 197: minder.v1.RuleType.Definition.Ingest.rest:type_name -> minder.v1.RestType + 111, // 198: minder.v1.RuleType.Definition.Ingest.builtin:type_name -> minder.v1.BuiltinType + 112, // 199: minder.v1.RuleType.Definition.Ingest.artifact:type_name -> minder.v1.ArtifactType + 113, // 200: minder.v1.RuleType.Definition.Ingest.git:type_name -> minder.v1.GitType + 114, // 201: minder.v1.RuleType.Definition.Ingest.diff:type_name -> minder.v1.DiffType + 194, // 202: minder.v1.RuleType.Definition.Eval.jq:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison + 195, // 203: minder.v1.RuleType.Definition.Eval.rego:type_name -> minder.v1.RuleType.Definition.Eval.Rego + 196, // 204: minder.v1.RuleType.Definition.Eval.vulncheck:type_name -> minder.v1.RuleType.Definition.Eval.Vulncheck + 197, // 205: minder.v1.RuleType.Definition.Eval.trusty:type_name -> minder.v1.RuleType.Definition.Eval.Trusty + 198, // 206: minder.v1.RuleType.Definition.Eval.homoglyphs:type_name -> minder.v1.RuleType.Definition.Eval.Homoglyphs + 110, // 207: minder.v1.RuleType.Definition.Remediate.rest:type_name -> minder.v1.RestType + 200, // 208: minder.v1.RuleType.Definition.Remediate.gh_branch_protection:type_name -> minder.v1.RuleType.Definition.Remediate.GhBranchProtectionType + 201, // 209: minder.v1.RuleType.Definition.Remediate.pull_request:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation + 204, // 210: minder.v1.RuleType.Definition.Alert.security_advisory:type_name -> minder.v1.RuleType.Definition.Alert.AlertTypeSA + 199, // 211: minder.v1.RuleType.Definition.Eval.JQComparison.ingested:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison.Operator + 199, // 212: minder.v1.RuleType.Definition.Eval.JQComparison.profile:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison.Operator + 202, // 213: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.contents:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.Content + 203, // 214: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.actions_replace_tags_with_sha:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.ActionsReplaceTagsWithSha + 208, // 215: minder.v1.Profile.Rule.params:type_name -> google.protobuf.Struct + 208, // 216: minder.v1.Profile.Rule.def:type_name -> google.protobuf.Struct + 210, // 217: minder.v1.name:extendee -> google.protobuf.EnumValueOptions + 211, // 218: minder.v1.rpc_options:extendee -> google.protobuf.MethodOptions + 10, // 219: minder.v1.rpc_options:type_name -> minder.v1.RpcOptions + 27, // 220: minder.v1.HealthService.CheckHealth:input_type -> minder.v1.CheckHealthRequest + 13, // 221: minder.v1.ArtifactService.ListArtifacts:input_type -> minder.v1.ListArtifactsRequest + 17, // 222: minder.v1.ArtifactService.GetArtifactById:input_type -> minder.v1.GetArtifactByIdRequest + 19, // 223: minder.v1.ArtifactService.GetArtifactByName:input_type -> minder.v1.GetArtifactByNameRequest + 29, // 224: minder.v1.OAuthService.GetAuthorizationURL:input_type -> minder.v1.GetAuthorizationURLRequest + 31, // 225: minder.v1.OAuthService.StoreProviderToken:input_type -> minder.v1.StoreProviderTokenRequest + 53, // 226: minder.v1.OAuthService.VerifyProviderTokenFrom:input_type -> minder.v1.VerifyProviderTokenFromRequest + 55, // 227: minder.v1.OAuthService.VerifyProviderCredential:input_type -> minder.v1.VerifyProviderCredentialRequest + 38, // 228: minder.v1.RepositoryService.RegisterRepository:input_type -> minder.v1.RegisterRepositoryRequest + 34, // 229: minder.v1.RepositoryService.ListRemoteRepositoriesFromProvider:input_type -> minder.v1.ListRemoteRepositoriesFromProviderRequest + 49, // 230: minder.v1.RepositoryService.ListRepositories:input_type -> minder.v1.ListRepositoriesRequest + 41, // 231: minder.v1.RepositoryService.GetRepositoryById:input_type -> minder.v1.GetRepositoryByIdRequest + 45, // 232: minder.v1.RepositoryService.GetRepositoryByName:input_type -> minder.v1.GetRepositoryByNameRequest + 43, // 233: minder.v1.RepositoryService.DeleteRepositoryById:input_type -> minder.v1.DeleteRepositoryByIdRequest + 47, // 234: minder.v1.RepositoryService.DeleteRepositoryByName:input_type -> minder.v1.DeleteRepositoryByNameRequest + 58, // 235: minder.v1.UserService.CreateUser:input_type -> minder.v1.CreateUserRequest + 60, // 236: minder.v1.UserService.DeleteUser:input_type -> minder.v1.DeleteUserRequest + 64, // 237: minder.v1.UserService.GetUser:input_type -> minder.v1.GetUserRequest + 145, // 238: minder.v1.UserService.ListInvitations:input_type -> minder.v1.ListInvitationsRequest + 147, // 239: minder.v1.UserService.ResolveInvitation:input_type -> minder.v1.ResolveInvitationRequest + 66, // 240: minder.v1.ProfileService.CreateProfile:input_type -> minder.v1.CreateProfileRequest + 68, // 241: minder.v1.ProfileService.UpdateProfile:input_type -> minder.v1.UpdateProfileRequest + 70, // 242: minder.v1.ProfileService.PatchProfile:input_type -> minder.v1.PatchProfileRequest + 72, // 243: minder.v1.ProfileService.DeleteProfile:input_type -> minder.v1.DeleteProfileRequest + 74, // 244: minder.v1.ProfileService.ListProfiles:input_type -> minder.v1.ListProfilesRequest + 76, // 245: minder.v1.ProfileService.GetProfileById:input_type -> minder.v1.GetProfileByIdRequest + 82, // 246: minder.v1.ProfileService.GetProfileStatusByName:input_type -> minder.v1.GetProfileStatusByNameRequest + 84, // 247: minder.v1.ProfileService.GetProfileStatusByProject:input_type -> minder.v1.GetProfileStatusByProjectRequest + 96, // 248: minder.v1.ProfileService.ListRuleTypes:input_type -> minder.v1.ListRuleTypesRequest + 98, // 249: minder.v1.ProfileService.GetRuleTypeByName:input_type -> minder.v1.GetRuleTypeByNameRequest + 100, // 250: minder.v1.ProfileService.GetRuleTypeById:input_type -> minder.v1.GetRuleTypeByIdRequest + 102, // 251: minder.v1.ProfileService.CreateRuleType:input_type -> minder.v1.CreateRuleTypeRequest + 104, // 252: minder.v1.ProfileService.UpdateRuleType:input_type -> minder.v1.UpdateRuleTypeRequest + 106, // 253: minder.v1.ProfileService.DeleteRuleType:input_type -> minder.v1.DeleteRuleTypeRequest + 108, // 254: minder.v1.EvalResultsService.ListEvaluationResults:input_type -> minder.v1.ListEvaluationResultsRequest + 170, // 255: minder.v1.EvalResultsService.ListEvaluationHistory:input_type -> minder.v1.ListEvaluationHistoryRequest + 133, // 256: minder.v1.PermissionsService.ListRoles:input_type -> minder.v1.ListRolesRequest + 135, // 257: minder.v1.PermissionsService.ListRoleAssignments:input_type -> minder.v1.ListRoleAssignmentsRequest + 137, // 258: minder.v1.PermissionsService.AssignRole:input_type -> minder.v1.AssignRoleRequest + 139, // 259: minder.v1.PermissionsService.UpdateRole:input_type -> minder.v1.UpdateRoleRequest + 141, // 260: minder.v1.PermissionsService.RemoveRole:input_type -> minder.v1.RemoveRoleRequest + 118, // 261: minder.v1.ProjectsService.ListProjects:input_type -> minder.v1.ListProjectsRequest + 120, // 262: minder.v1.ProjectsService.CreateProject:input_type -> minder.v1.CreateProjectRequest + 129, // 263: minder.v1.ProjectsService.ListChildProjects:input_type -> minder.v1.ListChildProjectsRequest + 122, // 264: minder.v1.ProjectsService.DeleteProject:input_type -> minder.v1.DeleteProjectRequest + 124, // 265: minder.v1.ProjectsService.UpdateProject:input_type -> minder.v1.UpdateProjectRequest + 127, // 266: minder.v1.ProjectsService.PatchProject:input_type -> minder.v1.PatchProjectRequest + 131, // 267: minder.v1.ProjectsService.CreateEntityReconciliationTask:input_type -> minder.v1.CreateEntityReconciliationTaskRequest + 164, // 268: minder.v1.ProvidersService.PatchProvider:input_type -> minder.v1.PatchProviderRequest + 150, // 269: minder.v1.ProvidersService.GetProvider:input_type -> minder.v1.GetProviderRequest + 152, // 270: minder.v1.ProvidersService.ListProviders:input_type -> minder.v1.ListProvidersRequest + 154, // 271: minder.v1.ProvidersService.CreateProvider:input_type -> minder.v1.CreateProviderRequest + 156, // 272: minder.v1.ProvidersService.DeleteProvider:input_type -> minder.v1.DeleteProviderRequest + 158, // 273: minder.v1.ProvidersService.DeleteProviderByID:input_type -> minder.v1.DeleteProviderByIDRequest + 160, // 274: minder.v1.ProvidersService.GetUnclaimedProviders:input_type -> minder.v1.GetUnclaimedProvidersRequest + 162, // 275: minder.v1.ProvidersService.ListProviderClasses:input_type -> minder.v1.ListProviderClassesRequest + 51, // 276: minder.v1.ProvidersService.ReconcileEntityRegistration:input_type -> minder.v1.ReconcileEntityRegistrationRequest + 25, // 277: minder.v1.InviteService.GetInviteDetails:input_type -> minder.v1.GetInviteDetailsRequest + 28, // 278: minder.v1.HealthService.CheckHealth:output_type -> minder.v1.CheckHealthResponse + 14, // 279: minder.v1.ArtifactService.ListArtifacts:output_type -> minder.v1.ListArtifactsResponse + 18, // 280: minder.v1.ArtifactService.GetArtifactById:output_type -> minder.v1.GetArtifactByIdResponse + 20, // 281: minder.v1.ArtifactService.GetArtifactByName:output_type -> minder.v1.GetArtifactByNameResponse + 30, // 282: minder.v1.OAuthService.GetAuthorizationURL:output_type -> minder.v1.GetAuthorizationURLResponse + 32, // 283: minder.v1.OAuthService.StoreProviderToken:output_type -> minder.v1.StoreProviderTokenResponse + 54, // 284: minder.v1.OAuthService.VerifyProviderTokenFrom:output_type -> minder.v1.VerifyProviderTokenFromResponse + 56, // 285: minder.v1.OAuthService.VerifyProviderCredential:output_type -> minder.v1.VerifyProviderCredentialResponse + 40, // 286: minder.v1.RepositoryService.RegisterRepository:output_type -> minder.v1.RegisterRepositoryResponse + 35, // 287: minder.v1.RepositoryService.ListRemoteRepositoriesFromProvider:output_type -> minder.v1.ListRemoteRepositoriesFromProviderResponse + 50, // 288: minder.v1.RepositoryService.ListRepositories:output_type -> minder.v1.ListRepositoriesResponse + 42, // 289: minder.v1.RepositoryService.GetRepositoryById:output_type -> minder.v1.GetRepositoryByIdResponse + 46, // 290: minder.v1.RepositoryService.GetRepositoryByName:output_type -> minder.v1.GetRepositoryByNameResponse + 44, // 291: minder.v1.RepositoryService.DeleteRepositoryById:output_type -> minder.v1.DeleteRepositoryByIdResponse + 48, // 292: minder.v1.RepositoryService.DeleteRepositoryByName:output_type -> minder.v1.DeleteRepositoryByNameResponse + 59, // 293: minder.v1.UserService.CreateUser:output_type -> minder.v1.CreateUserResponse + 61, // 294: minder.v1.UserService.DeleteUser:output_type -> minder.v1.DeleteUserResponse + 65, // 295: minder.v1.UserService.GetUser:output_type -> minder.v1.GetUserResponse + 146, // 296: minder.v1.UserService.ListInvitations:output_type -> minder.v1.ListInvitationsResponse + 148, // 297: minder.v1.UserService.ResolveInvitation:output_type -> minder.v1.ResolveInvitationResponse + 67, // 298: minder.v1.ProfileService.CreateProfile:output_type -> minder.v1.CreateProfileResponse + 69, // 299: minder.v1.ProfileService.UpdateProfile:output_type -> minder.v1.UpdateProfileResponse + 71, // 300: minder.v1.ProfileService.PatchProfile:output_type -> minder.v1.PatchProfileResponse + 73, // 301: minder.v1.ProfileService.DeleteProfile:output_type -> minder.v1.DeleteProfileResponse + 75, // 302: minder.v1.ProfileService.ListProfiles:output_type -> minder.v1.ListProfilesResponse + 77, // 303: minder.v1.ProfileService.GetProfileById:output_type -> minder.v1.GetProfileByIdResponse + 83, // 304: minder.v1.ProfileService.GetProfileStatusByName:output_type -> minder.v1.GetProfileStatusByNameResponse + 85, // 305: minder.v1.ProfileService.GetProfileStatusByProject:output_type -> minder.v1.GetProfileStatusByProjectResponse + 97, // 306: minder.v1.ProfileService.ListRuleTypes:output_type -> minder.v1.ListRuleTypesResponse + 99, // 307: minder.v1.ProfileService.GetRuleTypeByName:output_type -> minder.v1.GetRuleTypeByNameResponse + 101, // 308: minder.v1.ProfileService.GetRuleTypeById:output_type -> minder.v1.GetRuleTypeByIdResponse + 103, // 309: minder.v1.ProfileService.CreateRuleType:output_type -> minder.v1.CreateRuleTypeResponse + 105, // 310: minder.v1.ProfileService.UpdateRuleType:output_type -> minder.v1.UpdateRuleTypeResponse + 107, // 311: minder.v1.ProfileService.DeleteRuleType:output_type -> minder.v1.DeleteRuleTypeResponse + 109, // 312: minder.v1.EvalResultsService.ListEvaluationResults:output_type -> minder.v1.ListEvaluationResultsResponse + 171, // 313: minder.v1.EvalResultsService.ListEvaluationHistory:output_type -> minder.v1.ListEvaluationHistoryResponse + 134, // 314: minder.v1.PermissionsService.ListRoles:output_type -> minder.v1.ListRolesResponse + 136, // 315: minder.v1.PermissionsService.ListRoleAssignments:output_type -> minder.v1.ListRoleAssignmentsResponse + 138, // 316: minder.v1.PermissionsService.AssignRole:output_type -> minder.v1.AssignRoleResponse + 140, // 317: minder.v1.PermissionsService.UpdateRole:output_type -> minder.v1.UpdateRoleResponse + 142, // 318: minder.v1.PermissionsService.RemoveRole:output_type -> minder.v1.RemoveRoleResponse + 119, // 319: minder.v1.ProjectsService.ListProjects:output_type -> minder.v1.ListProjectsResponse + 121, // 320: minder.v1.ProjectsService.CreateProject:output_type -> minder.v1.CreateProjectResponse + 130, // 321: minder.v1.ProjectsService.ListChildProjects:output_type -> minder.v1.ListChildProjectsResponse + 123, // 322: minder.v1.ProjectsService.DeleteProject:output_type -> minder.v1.DeleteProjectResponse + 125, // 323: minder.v1.ProjectsService.UpdateProject:output_type -> minder.v1.UpdateProjectResponse + 128, // 324: minder.v1.ProjectsService.PatchProject:output_type -> minder.v1.PatchProjectResponse + 132, // 325: minder.v1.ProjectsService.CreateEntityReconciliationTask:output_type -> minder.v1.CreateEntityReconciliationTaskResponse + 165, // 326: minder.v1.ProvidersService.PatchProvider:output_type -> minder.v1.PatchProviderResponse + 151, // 327: minder.v1.ProvidersService.GetProvider:output_type -> minder.v1.GetProviderResponse + 153, // 328: minder.v1.ProvidersService.ListProviders:output_type -> minder.v1.ListProvidersResponse + 155, // 329: minder.v1.ProvidersService.CreateProvider:output_type -> minder.v1.CreateProviderResponse + 157, // 330: minder.v1.ProvidersService.DeleteProvider:output_type -> minder.v1.DeleteProviderResponse + 159, // 331: minder.v1.ProvidersService.DeleteProviderByID:output_type -> minder.v1.DeleteProviderByIDResponse + 161, // 332: minder.v1.ProvidersService.GetUnclaimedProviders:output_type -> minder.v1.GetUnclaimedProvidersResponse + 163, // 333: minder.v1.ProvidersService.ListProviderClasses:output_type -> minder.v1.ListProviderClassesResponse + 52, // 334: minder.v1.ProvidersService.ReconcileEntityRegistration:output_type -> minder.v1.ReconcileEntityRegistrationResponse + 26, // 335: minder.v1.InviteService.GetInviteDetails:output_type -> minder.v1.GetInviteDetailsResponse + 278, // [278:336] is the sub-list for method output_type + 220, // [220:278] is the sub-list for method input_type + 219, // [219:220] is the sub-list for extension type_name + 217, // [217:219] is the sub-list for extension extendee + 0, // [0:217] is the sub-list for field type_name } func init() { file_minder_v1_minder_proto_init() } diff --git a/proto/minder/v1/minder.proto b/proto/minder/v1/minder.proto index d7f3ed9380..ca23a07d02 100644 --- a/proto/minder/v1/minder.proto +++ b/proto/minder/v1/minder.proto @@ -2609,6 +2609,9 @@ message EvaluationHistoryStatus { // details contains optional details about the evaluation. // the structure and contents are rule type specific, and are subject to change. string details = 2; + + // created_at is the timestamp of creation of this evaluation + google.protobuf.Timestamp evaluated_at = 3; } message EvaluationHistoryRemediation { From dfbd2d258612ab66a7fd43b0cfaa6de6604eb13a Mon Sep 17 00:00:00 2001 From: Michelangelo Mori Date: Wed, 3 Jul 2024 18:42:44 +0200 Subject: [PATCH 05/13] Added service tests. --- database/query/eval_history.sql | 8 +- internal/db/eval_history.sql.go | 42 ++- internal/history/models.go | 14 +- internal/history/models_test.go | 5 +- internal/history/service.go | 252 ++++++++++++++- internal/history/service_test.go | 510 ++++++++++++++++++++++++++++++- 6 files changed, 780 insertions(+), 51 deletions(-) diff --git a/database/query/eval_history.sql b/database/query/eval_history.sql index 4cff8876e6..5ea5dc29d2 100644 --- a/database/query/eval_history.sql +++ b/database/query/eval_history.sql @@ -137,12 +137,16 @@ SELECT s.id::uuid AS evaluation_id, LEFT JOIN alert_events ae ON ae.evaluation_id = s.id WHERE (sqlc.narg(next)::timestamp without time zone IS NULL OR sqlc.narg(next) > s.most_recent_evaluation) AND (sqlc.narg(prev)::timestamp without time zone IS NULL OR sqlc.narg(prev) < s.most_recent_evaluation) + AND (sqlc.slice(entityTypes)::entities[] IS NULL OR entity_type::entities = ANY(sqlc.slice(entityTypes)::entities[])) AND (sqlc.slice(entityNames)::text[] IS NULL OR ere.repository_id IS NULL OR r.repo_name = ANY(sqlc.slice(entityNames)::text[])) AND (sqlc.slice(entityNames)::text[] IS NULL OR ere.pull_request_id IS NULL OR pr.pr_number::text = ANY(sqlc.slice(entityNames)::text[])) AND (sqlc.slice(entityNames)::text[] IS NULL OR ere.artifact_id IS NULL OR a.artifact_name = ANY(sqlc.slice(entityNames)::text[])) AND (sqlc.slice(profileNames)::text[] IS NULL OR p.name = ANY(sqlc.slice(profileNames)::text[])) - AND (sqlc.slice(remediations)::action_type[] IS NULL OR p.remediate = ANY(sqlc.slice(remediations)::action_type[])) - AND (sqlc.slice(alerts)::action_type[] IS NULL OR p.alert = ANY(sqlc.slice(alerts)::action_type[])) + AND (sqlc.slice(remediations)::remediation_status_types[] IS NULL OR re.status = ANY(sqlc.slice(remediations)::remediation_status_types[])) + AND (sqlc.slice(alerts)::alert_status_types[] IS NULL OR ae.status = ANY(sqlc.slice(alerts)::alert_status_types[])) AND (sqlc.slice(statuses)::eval_status_types[] IS NULL OR s.status = ANY(sqlc.slice(statuses)::eval_status_types[])) + AND (sqlc.narg(fromts)::timestamp without time zone IS NULL + OR sqlc.narg(tots)::timestamp without time zone IS NULL + OR s.most_recent_evaluation BETWEEN sqlc.narg(fromts) AND sqlc.narg(tots)) ORDER BY s.most_recent_evaluation DESC LIMIT sqlc.arg(size)::integer; diff --git a/internal/db/eval_history.sql.go b/internal/db/eval_history.sql.go index 6035d8aed6..4cdef93fde 100644 --- a/internal/db/eval_history.sql.go +++ b/internal/db/eval_history.sql.go @@ -233,26 +233,33 @@ SELECT s.id::uuid AS evaluation_id, LEFT JOIN alert_events ae ON ae.evaluation_id = s.id WHERE ($1::timestamp without time zone IS NULL OR $1 > s.most_recent_evaluation) AND ($2::timestamp without time zone IS NULL OR $2 < s.most_recent_evaluation) - AND ($3::text[] IS NULL OR ere.repository_id IS NULL OR r.repo_name = ANY($3::text[])) - AND ($3::text[] IS NULL OR ere.pull_request_id IS NULL OR pr.pr_number::text = ANY($3::text[])) - AND ($3::text[] IS NULL OR ere.artifact_id IS NULL OR a.artifact_name = ANY($3::text[])) - AND ($4::text[] IS NULL OR p.name = ANY($4::text[])) - AND ($5::action_type[] IS NULL OR p.remediate = ANY($5::action_type[])) - AND ($6::action_type[] IS NULL OR p.alert = ANY($6::action_type[])) - AND ($7::eval_status_types[] IS NULL OR s.status = ANY($7::eval_status_types[])) + AND ($3::entities[] IS NULL OR entity_type::entities = ANY($3::entities[])) + AND ($4::text[] IS NULL OR ere.repository_id IS NULL OR r.repo_name = ANY($4::text[])) + AND ($4::text[] IS NULL OR ere.pull_request_id IS NULL OR pr.pr_number::text = ANY($4::text[])) + AND ($4::text[] IS NULL OR ere.artifact_id IS NULL OR a.artifact_name = ANY($4::text[])) + AND ($5::text[] IS NULL OR p.name = ANY($5::text[])) + AND ($6::remediation_status_types[] IS NULL OR re.status = ANY($6::remediation_status_types[])) + AND ($7::alert_status_types[] IS NULL OR ae.status = ANY($7::alert_status_types[])) + AND ($8::eval_status_types[] IS NULL OR s.status = ANY($8::eval_status_types[])) + AND ($9::timestamp without time zone IS NULL + OR $10::timestamp without time zone IS NULL + OR s.most_recent_evaluation BETWEEN $9 AND $10) ORDER BY s.most_recent_evaluation DESC - LIMIT $8::integer + LIMIT $11::integer ` type ListEvaluationHistoryParams struct { - Next sql.NullTime `json:"next"` - Prev sql.NullTime `json:"prev"` - Entitynames []string `json:"entitynames"` - Profilenames []string `json:"profilenames"` - Remediations []ActionType `json:"remediations"` - Alerts []ActionType `json:"alerts"` - Statuses []EvalStatusTypes `json:"statuses"` - Size int32 `json:"size"` + Next sql.NullTime `json:"next"` + Prev sql.NullTime `json:"prev"` + Entitytypes []Entities `json:"entitytypes"` + Entitynames []string `json:"entitynames"` + Profilenames []string `json:"profilenames"` + Remediations []RemediationStatusTypes `json:"remediations"` + Alerts []AlertStatusTypes `json:"alerts"` + Statuses []EvalStatusTypes `json:"statuses"` + Fromts sql.NullTime `json:"fromts"` + Tots sql.NullTime `json:"tots"` + Size int32 `json:"size"` } type ListEvaluationHistoryRow struct { @@ -276,11 +283,14 @@ func (q *Queries) ListEvaluationHistory(ctx context.Context, arg ListEvaluationH rows, err := q.db.QueryContext(ctx, listEvaluationHistory, arg.Next, arg.Prev, + pq.Array(arg.Entitytypes), pq.Array(arg.Entitynames), pq.Array(arg.Profilenames), pq.Array(arg.Remediations), pq.Array(arg.Alerts), pq.Array(arg.Statuses), + arg.Fromts, + arg.Tots, arg.Size, ) if err != nil { diff --git a/internal/history/models.go b/internal/history/models.go index 8e2aaa9cf4..426ad3f75e 100644 --- a/internal/history/models.go +++ b/internal/history/models.go @@ -57,7 +57,7 @@ var ( // DefaultCursor is a cursor starting from the beginning of // the data set. DefaultCursor = ListEvaluationCursor{ - Time: time.UnixMicro(999999999999999999), + Time: time.UnixMicro(999999999999999999).UTC(), Direction: Next, } ) @@ -247,9 +247,9 @@ type listEvaluationFilter struct { // List of statuses to exclude from the selection excludedStatuses []string // List of remediations to include in the selection - includedRemediation []string + includedRemediations []string // List of remediations to exclude from the selection - excludedRemediation []string + excludedRemediations []string // List of alerts to include in the selection includedAlerts []string // List of alerts to exclude from the selection @@ -327,17 +327,17 @@ func (filter *listEvaluationFilter) ExcludedStatuses() []string { func (filter *listEvaluationFilter) AddRemediation(remediation string) error { if strings.HasPrefix(remediation, "!") { remediation = strings.Split(remediation, "!")[1] // guaranteed to exist - filter.excludedRemediation = append(filter.excludedRemediation, remediation) + filter.excludedRemediations = append(filter.excludedRemediations, remediation) } else { - filter.includedRemediation = append(filter.includedRemediation, remediation) + filter.includedRemediations = append(filter.includedRemediations, remediation) } return nil } func (filter *listEvaluationFilter) IncludedRemediations() []string { - return filter.includedRemediation + return filter.includedRemediations } func (filter *listEvaluationFilter) ExcludedRemediations() []string { - return filter.excludedRemediation + return filter.excludedRemediations } func (filter *listEvaluationFilter) AddAlert(alert string) error { diff --git a/internal/history/models_test.go b/internal/history/models_test.go index 322e519a37..d909955b15 100644 --- a/internal/history/models_test.go +++ b/internal/history/models_test.go @@ -27,7 +27,8 @@ var foo = "foo" func TestListEvaluationCursor(t *testing.T) { t.Parallel() - epoch := time.UnixMicro(0) + epoch := time.UnixMicro(0).UTC() + future := time.UnixMicro(999999999999999999).UTC() tests := []struct { name string @@ -109,7 +110,7 @@ func TestListEvaluationCursor(t *testing.T) { }, check: func(t *testing.T, cursor *ListEvaluationCursor) { t.Helper() - require.Equal(t, epoch, cursor.Time) + require.Equal(t, future, cursor.Time) require.Equal(t, Next, cursor.Direction) }, }, diff --git a/internal/history/service.go b/internal/history/service.go index fd51403f22..7d847bec00 100644 --- a/internal/history/service.go +++ b/internal/history/service.go @@ -215,18 +215,70 @@ func (_ *evaluationHistoryService) ListEvaluationHistory( params := db.ListEvaluationHistoryParams{ Size: int32(size), } - if string(cursor.Direction) == "next" { + + if err := toSQLCursor(cursor, ¶ms); err != nil { + return nil, err + } + if err := toSQLFilter(filter, ¶ms); err != nil { + return nil, err + } + + rows, err := qtx.ListEvaluationHistory(ctx, params) + if err != nil { + return nil, errors.New("internal error") + } + + result := &ListEvaluationHistoryResult{ + Data: rows, + } + if len(rows) > 0 { + newest := rows[0] + oldest := rows[len(rows)-1] + + result.Next = []byte(fmt.Sprintf("+%d", oldest.EvaluatedAt.UnixMicro())) + result.Prev = []byte(fmt.Sprintf("-%d", newest.EvaluatedAt.UnixMicro())) + } + + return result, nil +} + +func toSQLCursor( + cursor *ListEvaluationCursor, + params *db.ListEvaluationHistoryParams, +) error { + if cursor == nil { + return nil + } + + switch cursor.Direction { + case Next: params.Next = sql.NullTime{ Time: cursor.Time, Valid: true, } - } - if string(cursor.Direction) == "prev" { + case Prev: params.Prev = sql.NullTime{ Time: cursor.Time, Valid: true, } + default: + return fmt.Errorf( + "invalid cursor direction: %s", + string(cursor.Direction), + ) + } + + return nil +} + +func toSQLFilter( + filter ListEvaluationFilter, + params *db.ListEvaluationHistoryParams, +) error { + if filter == nil { + return nil } + if len(filter.IncludedEntityNames()) != 0 { params.Entitynames = filter.IncludedEntityNames() } @@ -234,21 +286,193 @@ func (_ *evaluationHistoryService) ListEvaluationHistory( params.Profilenames = filter.IncludedProfileNames() } - rows, err := qtx.ListEvaluationHistory(ctx, params) - if err != nil { - return nil, errors.New("internal error") + if len(filter.IncludedEntityTypes()) != 0 { + entityTypes, err := convertEntities( + filter.IncludedEntityTypes(), + ) + if err != nil { + return errors.New("internal error") + } + params.Entitytypes = entityTypes } - result := &ListEvaluationHistoryResult{ - Data: rows, + if len(filter.IncludedRemediations()) != 0 { + remediations, err := convertRemediationStatusTypes( + filter.IncludedRemediations(), + ) + if err != nil { + return errors.New("internal error") + } + params.Remediations = remediations } - if len(rows) > 0 { - newest := rows[0] - oldest := rows[len(rows)-1] - result.Next = []byte(fmt.Sprintf("+%d", oldest.EvaluatedAt.UnixMicro())) - result.Prev = []byte(fmt.Sprintf("-%d", newest.EvaluatedAt.UnixMicro())) + if len(filter.IncludedAlerts()) != 0 { + alerts, err := convertAlertStatusTypes( + filter.IncludedAlerts(), + ) + if err != nil { + return errors.New("internal error") + } + params.Alerts = alerts } - return result, nil + if len(filter.IncludedStatuses()) != 0 { + statuses, err := convertEvalStatusTypes( + filter.IncludedStatuses(), + ) + if err != nil { + return errors.New("internal error") + } + params.Statuses = statuses + } + + if filter.GetFrom() != nil { + params.Fromts = sql.NullTime{ + Time: *filter.GetFrom(), + Valid: true, + } + } + if filter.GetTo() != nil { + params.Tots = sql.NullTime{ + Time: *filter.GetTo(), + Valid: true, + } + } + + return nil +} + +func convertEntities(values []string) ([]db.Entities, error) { + converted := []db.Entities{} + for _, v := range values { + dbObj, err := mapEntities(v) + if err != nil { + return nil, err + } + converted = append(converted, dbObj) + } + return converted, nil +} + +func mapEntities(value string) (db.Entities, error) { + switch value { + case "repository": + return db.EntitiesRepository, nil + case "build_environment": + return db.EntitiesBuildEnvironment, nil + case "artifact": + return db.EntitiesArtifact, nil + case "pull_request": + return db.EntitiesPullRequest, nil + default: + return db.Entities("invalid"), + fmt.Errorf("invalid entity: %s", value) + } +} + +func convertRemediationStatusTypes( + values []string, +) ([]db.RemediationStatusTypes, error) { + converted := []db.RemediationStatusTypes{} + for _, v := range values { + dbObj, err := mapRemediationStatusTypes(v) + if err != nil { + return nil, err + } + converted = append(converted, dbObj) + } + return converted, nil +} + +//nolint:goconst +func mapRemediationStatusTypes( + value string, +) (db.RemediationStatusTypes, error) { + switch value { + case "success": + return db.RemediationStatusTypesSuccess, nil + case "failure": + return db.RemediationStatusTypesFailure, nil + case "error": + return db.RemediationStatusTypesError, nil + case "skipped": + return db.RemediationStatusTypesSkipped, nil + case "not_available": + return db.RemediationStatusTypesNotAvailable, nil + case "pending": + return db.RemediationStatusTypesPending, nil + default: + return db.RemediationStatusTypes("invalid"), + fmt.Errorf("invalid remediation status: %s", value) + } +} + +func convertAlertStatusTypes( + values []string, +) ([]db.AlertStatusTypes, error) { + converted := []db.AlertStatusTypes{} + for _, v := range values { + dbObj, err := mapAlertStatusTypes(v) + if err != nil { + return nil, err + } + converted = append(converted, dbObj) + } + return converted, nil +} + +//nolint:goconst +func mapAlertStatusTypes( + value string, +) (db.AlertStatusTypes, error) { + switch value { + case "on": + return db.AlertStatusTypesOn, nil + case "off": + return db.AlertStatusTypesOff, nil + case "error": + return db.AlertStatusTypesError, nil + case "skipped": + return db.AlertStatusTypesSkipped, nil + case "not_available": + return db.AlertStatusTypesNotAvailable, nil + default: + return db.AlertStatusTypes("invalid"), + fmt.Errorf("invalid alert status: %s", value) + } +} + +func convertEvalStatusTypes( + values []string, +) ([]db.EvalStatusTypes, error) { + converted := []db.EvalStatusTypes{} + for _, v := range values { + dbObj, err := mapEvalStatusTypes(v) + if err != nil { + return nil, err + } + converted = append(converted, dbObj) + } + return converted, nil +} + +//nolint:goconst +func mapEvalStatusTypes( + value string, +) (db.EvalStatusTypes, error) { + switch value { + case "success": + return db.EvalStatusTypesSuccess, nil + case "failure": + return db.EvalStatusTypesFailure, nil + case "error": + return db.EvalStatusTypesError, nil + case "skipped": + return db.EvalStatusTypesSkipped, nil + case "pending": + return db.EvalStatusTypesPending, nil + default: + return db.EvalStatusTypes("invalid"), + fmt.Errorf("invalid evaluation status: %s", value) + } } diff --git a/internal/history/service_test.go b/internal/history/service_test.go index 5f1c79a166..713b6ebd17 100644 --- a/internal/history/service_test.go +++ b/internal/history/service_test.go @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -package history_test +package history import ( "context" @@ -28,7 +28,6 @@ import ( "github.com/stacklok/minder/internal/db" dbf "github.com/stacklok/minder/internal/db/fixtures" engerr "github.com/stacklok/minder/internal/engine/errors" - "github.com/stacklok/minder/internal/history" ) func TestStoreEvaluationStatus(t *testing.T) { @@ -141,7 +140,7 @@ func TestStoreEvaluationStatus(t *testing.T) { store = scenario.DBSetup(ctrl) } - service := history.NewEvaluationHistoryService() + service := NewEvaluationHistoryService() id, err := service.StoreEvaluationStatus(ctx, store, ruleID, scenario.EntityType, entityID, errTest) if scenario.ExpectedError == "" { require.Equal(t, evaluationID, id) @@ -157,26 +156,498 @@ func TestStoreEvaluationStatus(t *testing.T) { func TestListEvaluationHistory(t *testing.T) { t.Parallel() + uuid1 := uuid.MustParse("00000000-0000-0000-0000-000000000001") + uuid2 := uuid.MustParse("00000000-0000-0000-0000-000000000002") + uuid3 := uuid.MustParse("00000000-0000-0000-0000-000000000003") + + epoch := time.UnixMicro(0).UTC() + evaluatedAt1 := time.Now() + evaluatedAt2 := evaluatedAt1.Add(-1 * time.Second) + evaluatedAt3 := evaluatedAt1.Add(-2 * time.Second) + entityType := []byte("repository") + + remediation := db.NullRemediationStatusTypes{ + RemediationStatusTypes: db.RemediationStatusTypesSuccess, + Valid: true, + } + alert := db.NullAlertStatusTypes{ + AlertStatusTypes: db.AlertStatusTypesOn, + Valid: true, + } + tests := []struct { - name string - entityType db.Entities - dbSetup dbf.DBMockBuilder - err bool + name string + dbSetup dbf.DBMockBuilder + cursor *ListEvaluationCursor + size uint64 + filter ListEvaluationFilter + checkf func(*testing.T, *ListEvaluationHistoryResult) + err bool }{ { - name: "StoreEvaluationStatus rejects invalid entity type", - entityType: "I'm a little teapot", - err: true, + name: "records", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory(nil, nil, + makeHistoryRow( + uuid1, + evaluatedAt1, + entityType, + remediation, + alert, + ), + makeHistoryRow( + uuid2, + evaluatedAt2, + entityType, + remediation, + alert, + ), + makeHistoryRow( + uuid3, + evaluatedAt3, + entityType, + remediation, + alert, + ), + ), + ), + checkf: func(t *testing.T, rows *ListEvaluationHistoryResult) { + t.Helper() + + require.NotNil(t, rows) + require.Len(t, rows.Data, 3) + + // database order is maintained + item1 := rows.Data[0] + require.Equal(t, uuid1, item1.EvaluationID) + require.Equal(t, evaluatedAt1, item1.EvaluatedAt) + require.Equal(t, uuid1, item1.EntityID) + + item2 := rows.Data[1] + require.Equal(t, uuid2, item2.EvaluationID) + require.Equal(t, evaluatedAt2, item2.EvaluatedAt) + require.Equal(t, uuid2, item2.EntityID) + + item3 := rows.Data[2] + require.Equal(t, uuid3, item3.EvaluationID) + require.Equal(t, evaluatedAt3, item3.EvaluatedAt) + require.Equal(t, uuid3, item3.EntityID) + }, + }, + + // cursor + { + name: "cursor next", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 0, + Next: sql.NullTime{ + Time: epoch.Add(1 * time.Hour), + Valid: true, + }, + }, + nil, + ), + ), + cursor: &ListEvaluationCursor{ + Time: epoch.Add(1 * time.Hour), + Direction: Next, + }, + }, + { + name: "cursor prev", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 0, + Prev: sql.NullTime{ + Time: epoch.Add(1 * time.Hour), + Valid: true, + }, + }, + nil, + ), + ), + cursor: &ListEvaluationCursor{ + Time: epoch.Add(1 * time.Hour), + Direction: Prev, + }, + }, + { + name: "cursor size", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 50, + }, + nil, + ), + ), + size: 50, + }, + + // filter entity types + { + name: "included entity types", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Entitytypes: []db.Entities{ + db.EntitiesRepository, + db.EntitiesBuildEnvironment, + db.EntitiesArtifact, + db.EntitiesPullRequest, + }, + }, + nil, + ), + ), + filter: &listEvaluationFilter{ + includedEntityTypes: []string{ + "repository", + "build_environment", + "artifact", + "pull_request", + }, + }, + }, + { + name: "included entity types bad string", + filter: &listEvaluationFilter{ + includedEntityTypes: []string{"foo"}, + }, + err: true, + }, + { + name: "excluded entity types", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory(nil, nil), // currently not implemented + ), + filter: &listEvaluationFilter{ + excludedEntityTypes: []string{"foo"}, + }, + }, + + // filter entity names + { + name: "included entity names", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 0, + Entitynames: []string{"foo"}, + }, + nil, + ), + ), + filter: &listEvaluationFilter{ + includedEntityNames: []string{"foo"}, + }, + }, + { + name: "excluded entity names", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory(nil, nil), // currently not implemented + ), + filter: &listEvaluationFilter{ + excludedEntityNames: []string{"foo"}, + }, + }, + + // filter profile names + { + name: "included profile names", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 0, + Profilenames: []string{"foo"}, + }, + nil, + ), + ), + filter: &listEvaluationFilter{ + includedProfileNames: []string{"foo"}, + }, + }, + { + name: "excluded profile names", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory(nil, nil), // currently not implemented + ), + filter: &listEvaluationFilter{ + excludedProfileNames: []string{"foo"}, + }, + }, + + // filter remediations + { + name: "included remediations", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 0, + Remediations: []db.RemediationStatusTypes{ + db.RemediationStatusTypesSuccess, + db.RemediationStatusTypesFailure, + db.RemediationStatusTypesError, + db.RemediationStatusTypesSkipped, + db.RemediationStatusTypesNotAvailable, + db.RemediationStatusTypesPending, + }, + }, + nil, + ), + ), + filter: &listEvaluationFilter{ + includedRemediations: []string{ + "success", + "failure", + "error", + "skipped", + "not_available", + "pending", + }, + }, + }, + { + name: "included remediations bad string", + filter: &listEvaluationFilter{ + includedRemediations: []string{"foo"}, + }, + err: true, + }, + { + name: "excluded remediations", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory(nil, nil), // currently not implemented + ), + filter: &listEvaluationFilter{ + excludedRemediations: []string{"on"}, + }, + }, + + // filter alerts + { + name: "included alerts", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 0, + Alerts: []db.AlertStatusTypes{ + db.AlertStatusTypesOn, + db.AlertStatusTypesOff, + db.AlertStatusTypesError, + db.AlertStatusTypesSkipped, + db.AlertStatusTypesNotAvailable, + }, + }, + nil, + ), + ), + filter: &listEvaluationFilter{ + includedAlerts: []string{ + "on", + "off", + "error", + "skipped", + "not_available", + }, + }, + }, + { + name: "included alerts bad string", + filter: &listEvaluationFilter{ + includedAlerts: []string{"foo"}, + }, + err: true, + }, + { + name: "excluded alerts", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory(nil, nil), // currently not implemented + ), + filter: &listEvaluationFilter{ + excludedAlerts: []string{"on"}, + }, + }, + + // filter statuses + { + name: "included statuses", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 0, + Statuses: []db.EvalStatusTypes{ + db.EvalStatusTypesSuccess, + db.EvalStatusTypesFailure, + db.EvalStatusTypesError, + db.EvalStatusTypesSkipped, + db.EvalStatusTypesPending, + }, + }, + nil, + ), + ), + filter: &listEvaluationFilter{ + includedStatuses: []string{ + "success", + "failure", + "error", + "skipped", + "pending", + }, + }, + }, + { + name: "included statuses bad string", + filter: &listEvaluationFilter{ + includedStatuses: []string{"foo"}, + }, + err: true, + }, + { + name: "excluded statuses", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory(nil, nil), // currently not implemented + ), + filter: &listEvaluationFilter{ + excludedStatuses: []string{"success"}, + }, + }, + + // filter on time range + { + name: "time range from to", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 0, + Fromts: sql.NullTime{ + Time: epoch, + Valid: true, + }, + Tots: sql.NullTime{ + Time: epoch, + Valid: true, + }, + }, + nil, + ), + ), + filter: &listEvaluationFilter{ + from: &epoch, + to: &epoch, + }, + }, + { + name: "time range from", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 0, + Fromts: sql.NullTime{ + Time: epoch, + Valid: true, + }, + }, + nil, + ), + ), + filter: &listEvaluationFilter{ + from: &epoch, + }, + }, + { + name: "time range from", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 0, + Tots: sql.NullTime{ + Time: epoch, + Valid: true, + }, + }, + nil, + ), + ), + filter: &listEvaluationFilter{ + to: &epoch, + }, + }, + + // errors + { + name: "db failure", + dbSetup: dbf.NewDBMock( + withListEvaluationHistory(nil, errors.New("whoops")), + ), + err: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Parallel() + + ctrl := gomock.NewController(t) + defer ctrl.Finish() + ctx := context.Background() + + var store db.Store + if tt.dbSetup != nil { + store = tt.dbSetup(ctrl) + } + + service := NewEvaluationHistoryService() + res, err := service.ListEvaluationHistory(ctx, store, tt.cursor, tt.size, tt.filter) + if tt.err { + require.Error(t, err) + return + } + + require.NoError(t, err) + if tt.checkf != nil { + tt.checkf(t, res) + } }) } } +func makeHistoryRow( + id uuid.UUID, + evaluatedAt time.Time, + entityType interface{}, + status db.NullRemediationStatusTypes, + alert db.NullAlertStatusTypes, +) db.ListEvaluationHistoryRow { + return db.ListEvaluationHistoryRow{ + EvaluationID: id, + EvaluatedAt: evaluatedAt, + EntityType: entityType, + EntityID: id, + EntityName: "repo1", + RuleType: "rule_type", + RuleName: "rule_name", + ProfileName: "profile_name", + EvaluationStatus: db.EvalStatusTypesSuccess, + EvaluationDetails: "", + RemediationStatus: status, + RemediationDetails: sql.NullString{ + String: "", + Valid: true, + }, + AlertStatus: alert, + AlertDetails: sql.NullString{ + String: "", + Valid: true, + }, + } +} + var ( ruleID = uuid.New() entityID = uuid.New() @@ -247,3 +718,22 @@ func withUpsertLatestEvaluationStatus(err error) func(dbf.DBMock) { Return(err) } } + +func withListEvaluationHistory( + params *db.ListEvaluationHistoryParams, + err error, + records ...db.ListEvaluationHistoryRow, +) func(dbf.DBMock) { + return func(mock dbf.DBMock) { + if params != nil { + mock.EXPECT(). + ListEvaluationHistory(gomock.Any(), *params). + Return(records, err) + return + } + mock.EXPECT(). + ListEvaluationHistory(gomock.Any(), gomock.Any()). + Return(records, err) + + } +} From b7b255b6bc5d1d8ea669ddb8cd3d7e131f2ba8c9 Mon Sep 17 00:00:00 2001 From: Michelangelo Mori Date: Thu, 4 Jul 2024 14:04:04 +0200 Subject: [PATCH 06/13] Prevent filtering for both inclusion and exclusion. --- database/query/eval_history.sql | 11 +++++ internal/db/eval_history.sql.go | 53 ++++++++++++++------ internal/history/models.go | 47 ++++++++++++++++++ internal/history/models_test.go | 68 +++++++++++++++++++++++++ internal/history/service.go | 50 +++++++++++++++++++ internal/history/service_test.go | 85 +++++++++++++++++++++++++++++--- 6 files changed, 292 insertions(+), 22 deletions(-) diff --git a/database/query/eval_history.sql b/database/query/eval_history.sql index 5ea5dc29d2..d2f777cafc 100644 --- a/database/query/eval_history.sql +++ b/database/query/eval_history.sql @@ -137,6 +137,7 @@ SELECT s.id::uuid AS evaluation_id, LEFT JOIN alert_events ae ON ae.evaluation_id = s.id WHERE (sqlc.narg(next)::timestamp without time zone IS NULL OR sqlc.narg(next) > s.most_recent_evaluation) AND (sqlc.narg(prev)::timestamp without time zone IS NULL OR sqlc.narg(prev) < s.most_recent_evaluation) + -- inclusion filters AND (sqlc.slice(entityTypes)::entities[] IS NULL OR entity_type::entities = ANY(sqlc.slice(entityTypes)::entities[])) AND (sqlc.slice(entityNames)::text[] IS NULL OR ere.repository_id IS NULL OR r.repo_name = ANY(sqlc.slice(entityNames)::text[])) AND (sqlc.slice(entityNames)::text[] IS NULL OR ere.pull_request_id IS NULL OR pr.pr_number::text = ANY(sqlc.slice(entityNames)::text[])) @@ -145,6 +146,16 @@ SELECT s.id::uuid AS evaluation_id, AND (sqlc.slice(remediations)::remediation_status_types[] IS NULL OR re.status = ANY(sqlc.slice(remediations)::remediation_status_types[])) AND (sqlc.slice(alerts)::alert_status_types[] IS NULL OR ae.status = ANY(sqlc.slice(alerts)::alert_status_types[])) AND (sqlc.slice(statuses)::eval_status_types[] IS NULL OR s.status = ANY(sqlc.slice(statuses)::eval_status_types[])) + -- exclusion filters + AND (sqlc.slice(notEntityTypes)::entities[] IS NULL OR entity_type::entities != ANY(sqlc.slice(notEntityTypes)::entities[])) + AND (sqlc.slice(notEntityNames)::text[] IS NULL OR ere.repository_id IS NULL OR r.repo_name != ANY(sqlc.slice(notEntityNames)::text[])) + AND (sqlc.slice(notEntityNames)::text[] IS NULL OR ere.pull_request_id IS NULL OR pr.pr_number::text != ANY(sqlc.slice(notEntityNames)::text[])) + AND (sqlc.slice(notEntityNames)::text[] IS NULL OR ere.artifact_id IS NULL OR a.artifact_name != ANY(sqlc.slice(notEntityNames)::text[])) + AND (sqlc.slice(notProfileNames)::text[] IS NULL OR p.name != ANY(sqlc.slice(notProfileNames)::text[])) + AND (sqlc.slice(notRemediations)::remediation_status_types[] IS NULL OR re.status != ANY(sqlc.slice(notRemediations)::remediation_status_types[])) + AND (sqlc.slice(notAlerts)::alert_status_types[] IS NULL OR ae.status != ANY(sqlc.slice(notAlerts)::alert_status_types[])) + AND (sqlc.slice(notStatuses)::eval_status_types[] IS NULL OR s.status != ANY(sqlc.slice(notStatuses)::eval_status_types[])) + -- time range filter AND (sqlc.narg(fromts)::timestamp without time zone IS NULL OR sqlc.narg(tots)::timestamp without time zone IS NULL OR s.most_recent_evaluation BETWEEN sqlc.narg(fromts) AND sqlc.narg(tots)) diff --git a/internal/db/eval_history.sql.go b/internal/db/eval_history.sql.go index 4cdef93fde..5e77b00911 100644 --- a/internal/db/eval_history.sql.go +++ b/internal/db/eval_history.sql.go @@ -233,6 +233,7 @@ SELECT s.id::uuid AS evaluation_id, LEFT JOIN alert_events ae ON ae.evaluation_id = s.id WHERE ($1::timestamp without time zone IS NULL OR $1 > s.most_recent_evaluation) AND ($2::timestamp without time zone IS NULL OR $2 < s.most_recent_evaluation) + -- inclusion filters AND ($3::entities[] IS NULL OR entity_type::entities = ANY($3::entities[])) AND ($4::text[] IS NULL OR ere.repository_id IS NULL OR r.repo_name = ANY($4::text[])) AND ($4::text[] IS NULL OR ere.pull_request_id IS NULL OR pr.pr_number::text = ANY($4::text[])) @@ -241,25 +242,41 @@ SELECT s.id::uuid AS evaluation_id, AND ($6::remediation_status_types[] IS NULL OR re.status = ANY($6::remediation_status_types[])) AND ($7::alert_status_types[] IS NULL OR ae.status = ANY($7::alert_status_types[])) AND ($8::eval_status_types[] IS NULL OR s.status = ANY($8::eval_status_types[])) - AND ($9::timestamp without time zone IS NULL - OR $10::timestamp without time zone IS NULL - OR s.most_recent_evaluation BETWEEN $9 AND $10) + -- exclusion filters + AND ($9::entities[] IS NULL OR entity_type::entities != ANY($9::entities[])) + AND ($10::text[] IS NULL OR ere.repository_id IS NULL OR r.repo_name != ANY($10::text[])) + AND ($10::text[] IS NULL OR ere.pull_request_id IS NULL OR pr.pr_number::text != ANY($10::text[])) + AND ($10::text[] IS NULL OR ere.artifact_id IS NULL OR a.artifact_name != ANY($10::text[])) + AND ($11::text[] IS NULL OR p.name != ANY($11::text[])) + AND ($12::remediation_status_types[] IS NULL OR re.status != ANY($12::remediation_status_types[])) + AND ($13::alert_status_types[] IS NULL OR ae.status != ANY($13::alert_status_types[])) + AND ($14::eval_status_types[] IS NULL OR s.status != ANY($14::eval_status_types[])) + -- time range filter + AND ($15::timestamp without time zone IS NULL + OR $16::timestamp without time zone IS NULL + OR s.most_recent_evaluation BETWEEN $15 AND $16) ORDER BY s.most_recent_evaluation DESC - LIMIT $11::integer + LIMIT $17::integer ` type ListEvaluationHistoryParams struct { - Next sql.NullTime `json:"next"` - Prev sql.NullTime `json:"prev"` - Entitytypes []Entities `json:"entitytypes"` - Entitynames []string `json:"entitynames"` - Profilenames []string `json:"profilenames"` - Remediations []RemediationStatusTypes `json:"remediations"` - Alerts []AlertStatusTypes `json:"alerts"` - Statuses []EvalStatusTypes `json:"statuses"` - Fromts sql.NullTime `json:"fromts"` - Tots sql.NullTime `json:"tots"` - Size int32 `json:"size"` + Next sql.NullTime `json:"next"` + Prev sql.NullTime `json:"prev"` + Entitytypes []Entities `json:"entitytypes"` + Entitynames []string `json:"entitynames"` + Profilenames []string `json:"profilenames"` + Remediations []RemediationStatusTypes `json:"remediations"` + Alerts []AlertStatusTypes `json:"alerts"` + Statuses []EvalStatusTypes `json:"statuses"` + Notentitytypes []Entities `json:"notentitytypes"` + Notentitynames []string `json:"notentitynames"` + Notprofilenames []string `json:"notprofilenames"` + Notremediations []RemediationStatusTypes `json:"notremediations"` + Notalerts []AlertStatusTypes `json:"notalerts"` + Notstatuses []EvalStatusTypes `json:"notstatuses"` + Fromts sql.NullTime `json:"fromts"` + Tots sql.NullTime `json:"tots"` + Size int32 `json:"size"` } type ListEvaluationHistoryRow struct { @@ -289,6 +306,12 @@ func (q *Queries) ListEvaluationHistory(ctx context.Context, arg ListEvaluationH pq.Array(arg.Remediations), pq.Array(arg.Alerts), pq.Array(arg.Statuses), + pq.Array(arg.Notentitytypes), + pq.Array(arg.Notentitynames), + pq.Array(arg.Notprofilenames), + pq.Array(arg.Notremediations), + pq.Array(arg.Notalerts), + pq.Array(arg.Notstatuses), arg.Fromts, arg.Tots, arg.Size, diff --git a/internal/history/models.go b/internal/history/models.go index 426ad3f75e..b9599c66ab 100644 --- a/internal/history/models.go +++ b/internal/history/models.go @@ -31,6 +31,9 @@ var ( // ErrInvalidTimeRange is returned the time range from-to is // either missing one end or from is greater than to. ErrInvalidTimeRange = errors.New("invalid time range") + // ErrInclusionExclusion is returned when both inclusion and + // exclusion filters are specified on the same field. + ErrInclusionExclusion = errors.New("inclusion and exclusion filter specified") // ErrInvalidIdentifier is returned when an identifier // (e.g. entity name) is empty or malformed. ErrInvalidIdentifier = errors.New("invalid identifier") @@ -267,6 +270,13 @@ func (filter *listEvaluationFilter) AddEntityType(entityType string) error { } else { filter.includedEntityTypes = append(filter.includedEntityTypes, entityType) } + + // Prevent filtering for both inclusion and exclusion + if len(filter.includedEntityTypes) > 0 && + len(filter.excludedEntityTypes) > 0 { + return fmt.Errorf("%w: entity type", ErrInclusionExclusion) + } + return nil } func (filter *listEvaluationFilter) IncludedEntityTypes() []string { @@ -283,6 +293,13 @@ func (filter *listEvaluationFilter) AddEntityName(entityName string) error { } else { filter.includedEntityNames = append(filter.includedEntityNames, entityName) } + + // Prevent filtering for both inclusion and exclusion + if len(filter.includedEntityNames) > 0 && + len(filter.excludedEntityNames) > 0 { + return fmt.Errorf("%w: entity name", ErrInclusionExclusion) + } + return nil } func (filter *listEvaluationFilter) IncludedEntityNames() []string { @@ -299,6 +316,13 @@ func (filter *listEvaluationFilter) AddProfileName(profileName string) error { } else { filter.includedProfileNames = append(filter.includedProfileNames, profileName) } + + // Prevent filtering for both inclusion and exclusion + if len(filter.includedProfileNames) > 0 && + len(filter.excludedProfileNames) > 0 { + return fmt.Errorf("%w: profile name", ErrInclusionExclusion) + } + return nil } func (filter *listEvaluationFilter) IncludedProfileNames() []string { @@ -315,6 +339,13 @@ func (filter *listEvaluationFilter) AddStatus(status string) error { } else { filter.includedStatuses = append(filter.includedStatuses, status) } + + // Prevent filtering for both inclusion and exclusion + if len(filter.includedStatuses) > 0 && + len(filter.excludedStatuses) > 0 { + return fmt.Errorf("%w: status", ErrInclusionExclusion) + } + return nil } func (filter *listEvaluationFilter) IncludedStatuses() []string { @@ -331,6 +362,13 @@ func (filter *listEvaluationFilter) AddRemediation(remediation string) error { } else { filter.includedRemediations = append(filter.includedRemediations, remediation) } + + // Prevent filtering for both inclusion and exclusion + if len(filter.includedRemediations) > 0 && + len(filter.excludedRemediations) > 0 { + return fmt.Errorf("%w: remediation", ErrInclusionExclusion) + } + return nil } func (filter *listEvaluationFilter) IncludedRemediations() []string { @@ -347,6 +385,13 @@ func (filter *listEvaluationFilter) AddAlert(alert string) error { } else { filter.includedAlerts = append(filter.includedAlerts, alert) } + + // Prevent filtering for both inclusion and exclusion + if len(filter.includedAlerts) > 0 && + len(filter.excludedAlerts) > 0 { + return fmt.Errorf("%w: alert", ErrInclusionExclusion) + } + return nil } func (filter *listEvaluationFilter) IncludedAlerts() []string { @@ -509,6 +554,8 @@ func NewListEvaluationFilter(opts ...FilterOpt) (ListEvaluationFilter, error) { } } + // Following we check that time range based filtering is + // sound. if filter.to != nil && filter.from == nil { return nil, fmt.Errorf("%w: from is missing", ErrInvalidTimeRange) } diff --git a/internal/history/models_test.go b/internal/history/models_test.go index d909955b15..d5a810058b 100644 --- a/internal/history/models_test.go +++ b/internal/history/models_test.go @@ -230,6 +230,74 @@ func TestListEvaluationFilter(t *testing.T) { }, err: true, }, + + // inclusion-exclusion errors + { + name: "inclusion exclusion entity type", + filter: func(t *testing.T) (ListEvaluationFilter, error) { + t.Helper() + return NewListEvaluationFilter( + WithEntityType("repository"), + WithEntityType("!artifact"), + ) + }, + err: true, + }, + { + name: "inclusion exclusion entity name", + filter: func(t *testing.T) (ListEvaluationFilter, error) { + t.Helper() + return NewListEvaluationFilter( + WithEntityName("foo"), + WithEntityName("!bar"), + ) + }, + err: true, + }, + { + name: "inclusion exclusion profile name", + filter: func(t *testing.T) (ListEvaluationFilter, error) { + t.Helper() + return NewListEvaluationFilter( + WithProfileName("foo"), + WithProfileName("!bar"), + ) + }, + err: true, + }, + { + name: "inclusion exclusion evaluation status", + filter: func(t *testing.T) (ListEvaluationFilter, error) { + t.Helper() + return NewListEvaluationFilter( + WithStatus("success"), + WithStatus("!failure"), + ) + }, + err: true, + }, + { + name: "inclusion exclusion remediation status", + filter: func(t *testing.T) (ListEvaluationFilter, error) { + t.Helper() + return NewListEvaluationFilter( + WithRemediation("success"), + WithRemediation("!failure"), + ) + }, + err: true, + }, + { + name: "inclusion exclusion alert status", + filter: func(t *testing.T) (ListEvaluationFilter, error) { + t.Helper() + return NewListEvaluationFilter( + WithAlert("success"), + WithAlert("!failure"), + ) + }, + err: true, + }, } for _, tt := range tests { diff --git a/internal/history/service.go b/internal/history/service.go index 7d847bec00..bc763b156e 100644 --- a/internal/history/service.go +++ b/internal/history/service.go @@ -279,13 +279,23 @@ func toSQLFilter( return nil } + // filters on entity names if len(filter.IncludedEntityNames()) != 0 { params.Entitynames = filter.IncludedEntityNames() } + if len(filter.ExcludedEntityNames()) != 0 { + params.Notentitynames = filter.ExcludedEntityNames() + } + + // filters on profile names if len(filter.IncludedProfileNames()) != 0 { params.Profilenames = filter.IncludedProfileNames() } + if len(filter.ExcludedProfileNames()) != 0 { + params.Notprofilenames = filter.ExcludedProfileNames() + } + // filters on entity types if len(filter.IncludedEntityTypes()) != 0 { entityTypes, err := convertEntities( filter.IncludedEntityTypes(), @@ -295,7 +305,17 @@ func toSQLFilter( } params.Entitytypes = entityTypes } + if len(filter.ExcludedEntityTypes()) != 0 { + entityTypes, err := convertEntities( + filter.ExcludedEntityTypes(), + ) + if err != nil { + return errors.New("internal error") + } + params.Notentitytypes = entityTypes + } + // filters on remediation status if len(filter.IncludedRemediations()) != 0 { remediations, err := convertRemediationStatusTypes( filter.IncludedRemediations(), @@ -305,7 +325,17 @@ func toSQLFilter( } params.Remediations = remediations } + if len(filter.ExcludedRemediations()) != 0 { + remediations, err := convertRemediationStatusTypes( + filter.ExcludedRemediations(), + ) + if err != nil { + return errors.New("internal error") + } + params.Notremediations = remediations + } + // filters on alert status if len(filter.IncludedAlerts()) != 0 { alerts, err := convertAlertStatusTypes( filter.IncludedAlerts(), @@ -315,7 +345,17 @@ func toSQLFilter( } params.Alerts = alerts } + if len(filter.ExcludedAlerts()) != 0 { + alerts, err := convertAlertStatusTypes( + filter.ExcludedAlerts(), + ) + if err != nil { + return errors.New("internal error") + } + params.Notalerts = alerts + } + // filters on evaluation status if len(filter.IncludedStatuses()) != 0 { statuses, err := convertEvalStatusTypes( filter.IncludedStatuses(), @@ -325,7 +365,17 @@ func toSQLFilter( } params.Statuses = statuses } + if len(filter.ExcludedStatuses()) != 0 { + statuses, err := convertEvalStatusTypes( + filter.ExcludedStatuses(), + ) + if err != nil { + return errors.New("internal error") + } + params.Notstatuses = statuses + } + // filters on time range if filter.GetFrom() != nil { params.Fromts = sql.NullTime{ Time: *filter.GetFrom(), diff --git a/internal/history/service_test.go b/internal/history/service_test.go index 713b6ebd17..9614097556 100644 --- a/internal/history/service_test.go +++ b/internal/history/service_test.go @@ -322,11 +322,25 @@ func TestListEvaluationHistory(t *testing.T) { { name: "excluded entity types", dbSetup: dbf.NewDBMock( - withListEvaluationHistory(nil, nil), // currently not implemented + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Notentitytypes: []db.Entities{ + db.EntitiesRepository, + }, + }, + nil, + ), ), + filter: &listEvaluationFilter{ + excludedEntityTypes: []string{"repository"}, + }, + }, + { + name: "excluded entity types bad string", filter: &listEvaluationFilter{ excludedEntityTypes: []string{"foo"}, }, + err: true, }, // filter entity names @@ -348,7 +362,13 @@ func TestListEvaluationHistory(t *testing.T) { { name: "excluded entity names", dbSetup: dbf.NewDBMock( - withListEvaluationHistory(nil, nil), // currently not implemented + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 0, + Notentitynames: []string{"foo"}, + }, + nil, + ), ), filter: &listEvaluationFilter{ excludedEntityNames: []string{"foo"}, @@ -374,7 +394,13 @@ func TestListEvaluationHistory(t *testing.T) { { name: "excluded profile names", dbSetup: dbf.NewDBMock( - withListEvaluationHistory(nil, nil), // currently not implemented + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 0, + Notprofilenames: []string{"foo"}, + }, + nil, + ), ), filter: &listEvaluationFilter{ excludedProfileNames: []string{"foo"}, @@ -421,12 +447,27 @@ func TestListEvaluationHistory(t *testing.T) { { name: "excluded remediations", dbSetup: dbf.NewDBMock( - withListEvaluationHistory(nil, nil), // currently not implemented + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 0, + Notremediations: []db.RemediationStatusTypes{ + db.RemediationStatusTypesSuccess, + }, + }, + nil, + ), ), filter: &listEvaluationFilter{ - excludedRemediations: []string{"on"}, + excludedRemediations: []string{"success"}, }, }, + { + name: "excluded remediations bad string", + filter: &listEvaluationFilter{ + excludedRemediations: []string{"foo"}, + }, + err: true, + }, // filter alerts { @@ -466,12 +507,27 @@ func TestListEvaluationHistory(t *testing.T) { { name: "excluded alerts", dbSetup: dbf.NewDBMock( - withListEvaluationHistory(nil, nil), // currently not implemented + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 0, + Notalerts: []db.AlertStatusTypes{ + db.AlertStatusTypesOn, + }, + }, + nil, + ), ), filter: &listEvaluationFilter{ excludedAlerts: []string{"on"}, }, }, + { + name: "excluded alerts bad string", + filter: &listEvaluationFilter{ + excludedAlerts: []string{"foo"}, + }, + err: true, + }, // filter statuses { @@ -511,12 +567,27 @@ func TestListEvaluationHistory(t *testing.T) { { name: "excluded statuses", dbSetup: dbf.NewDBMock( - withListEvaluationHistory(nil, nil), // currently not implemented + withListEvaluationHistory( + &db.ListEvaluationHistoryParams{ + Size: 0, + Notstatuses: []db.EvalStatusTypes{ + db.EvalStatusTypesSuccess, + }, + }, + nil, + ), ), filter: &listEvaluationFilter{ excludedStatuses: []string{"success"}, }, }, + { + name: "excluded statuses bad string", + filter: &listEvaluationFilter{ + excludedStatuses: []string{"foo"}, + }, + err: true, + }, // filter on time range { From fd073f23043ff292416d31eb1866e90a04c6b156 Mon Sep 17 00:00:00 2001 From: Michelangelo Mori Date: Thu, 4 Jul 2024 14:44:07 +0200 Subject: [PATCH 07/13] Revert changes to feature flag check. This was necessary for local testing because of the following issue. https://github.com/stacklok/minder/issues/3775 --- internal/engine/eval_status.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/engine/eval_status.go b/internal/engine/eval_status.go index 55a3d5e67c..d9cbf9ec76 100644 --- a/internal/engine/eval_status.go +++ b/internal/engine/eval_status.go @@ -201,7 +201,7 @@ func (e *executor) createOrUpdateEvalStatus( logger.Err(err).Msg("error upserting rule alert details") } - if flags.Bool(ctx, e.featureFlags, flags.EvalHistory) || true { + if flags.Bool(ctx, e.featureFlags, flags.EvalHistory) { // Log in the evaluation history tables _, err = db.WithTransaction(e.querier, func(qtx db.ExtendQuerier) (uuid.UUID, error) { evalID, err := e.historyService.StoreEvaluationStatus( From 280dd88f0e489f78d10be2036cb8af8bbea1d58c Mon Sep 17 00:00:00 2001 From: Michelangelo Mori Date: Thu, 4 Jul 2024 15:35:01 +0200 Subject: [PATCH 08/13] Setting query params in a more readable fashion. --- internal/history/service.go | 179 +++++++++++++++++++++--------------- 1 file changed, 103 insertions(+), 76 deletions(-) diff --git a/internal/history/service.go b/internal/history/service.go index bc763b156e..4801185852 100644 --- a/internal/history/service.go +++ b/internal/history/service.go @@ -279,66 +279,115 @@ func toSQLFilter( return nil } - // filters on entity names - if len(filter.IncludedEntityNames()) != 0 { - params.Entitynames = filter.IncludedEntityNames() + if err := paramsFromEntityTypeFilter(filter, params); err != nil { + return err } - if len(filter.ExcludedEntityNames()) != 0 { - params.Notentitynames = filter.ExcludedEntityNames() + if err := paramsFromEntityNameFilter(filter, params); err != nil { + return err } - - // filters on profile names - if len(filter.IncludedProfileNames()) != 0 { - params.Profilenames = filter.IncludedProfileNames() + if err := paramsFromProfileNameFilter(filter, params); err != nil { + return err } - if len(filter.ExcludedProfileNames()) != 0 { - params.Notprofilenames = filter.ExcludedProfileNames() + if err := paramsFromRemediationFilter(filter, params); err != nil { + return err } + if err := paramsFromAlertFilter(filter, params); err != nil { + return err + } + if err := paramsFromStatusFilter(filter, params); err != nil { + return err + } + return paramsFromTimeRangeFilter(filter, params) +} - // filters on entity types +func paramsFromEntityTypeFilter( + filter EntityTypeFilter, + params *db.ListEvaluationHistoryParams, +) error { if len(filter.IncludedEntityTypes()) != 0 { - entityTypes, err := convertEntities( + entityTypes, err := convert( filter.IncludedEntityTypes(), + mapEntities, ) if err != nil { - return errors.New("internal error") + return err } params.Entitytypes = entityTypes } if len(filter.ExcludedEntityTypes()) != 0 { - entityTypes, err := convertEntities( + entityTypes, err := convert( filter.ExcludedEntityTypes(), + mapEntities, ) if err != nil { return errors.New("internal error") } params.Notentitytypes = entityTypes } + return nil +} - // filters on remediation status +func paramsFromEntityNameFilter( + filter EntityNameFilter, + params *db.ListEvaluationHistoryParams, +) error { + if len(filter.IncludedEntityNames()) != 0 { + params.Entitynames = filter.IncludedEntityNames() + } + if len(filter.ExcludedEntityNames()) != 0 { + params.Notentitynames = filter.ExcludedEntityNames() + } + return nil +} + +func paramsFromProfileNameFilter( + filter ProfileNameFilter, + params *db.ListEvaluationHistoryParams, +) error { + if len(filter.IncludedProfileNames()) != 0 { + params.Profilenames = filter.IncludedProfileNames() + } + if len(filter.ExcludedProfileNames()) != 0 { + params.Notprofilenames = filter.ExcludedProfileNames() + } + return nil +} + +func paramsFromRemediationFilter( + filter RemediationFilter, + params *db.ListEvaluationHistoryParams, +) error { if len(filter.IncludedRemediations()) != 0 { - remediations, err := convertRemediationStatusTypes( + remediations, err := convert( filter.IncludedRemediations(), + mapRemediationStatusTypes, ) if err != nil { - return errors.New("internal error") + return err } params.Remediations = remediations } if len(filter.ExcludedRemediations()) != 0 { - remediations, err := convertRemediationStatusTypes( + remediations, err := convert( filter.ExcludedRemediations(), + mapRemediationStatusTypes, ) if err != nil { - return errors.New("internal error") + return err } params.Notremediations = remediations } + return nil +} - // filters on alert status +func paramsFromAlertFilter( + filter AlertFilter, + params *db.ListEvaluationHistoryParams, +) error { if len(filter.IncludedAlerts()) != 0 { - alerts, err := convertAlertStatusTypes( + alerts, err := convert( filter.IncludedAlerts(), + mapAlertStatusTypes, ) if err != nil { return errors.New("internal error") @@ -346,36 +395,49 @@ func toSQLFilter( params.Alerts = alerts } if len(filter.ExcludedAlerts()) != 0 { - alerts, err := convertAlertStatusTypes( + alerts, err := convert( filter.ExcludedAlerts(), + mapAlertStatusTypes, ) if err != nil { - return errors.New("internal error") + return err } params.Notalerts = alerts } + return nil +} - // filters on evaluation status +func paramsFromStatusFilter( + filter StatusFilter, + params *db.ListEvaluationHistoryParams, +) error { if len(filter.IncludedStatuses()) != 0 { - statuses, err := convertEvalStatusTypes( + statuses, err := convert( filter.IncludedStatuses(), + mapEvalStatusTypes, ) if err != nil { - return errors.New("internal error") + return err } params.Statuses = statuses } if len(filter.ExcludedStatuses()) != 0 { - statuses, err := convertEvalStatusTypes( + statuses, err := convert( filter.ExcludedStatuses(), + mapEvalStatusTypes, ) if err != nil { - return errors.New("internal error") + return err } params.Notstatuses = statuses } + return nil +} - // filters on time range +func paramsFromTimeRangeFilter( + filter TimeRangeFilter, + params *db.ListEvaluationHistoryParams, +) error { if filter.GetFrom() != nil { params.Fromts = sql.NullTime{ Time: *filter.GetFrom(), @@ -388,14 +450,21 @@ func toSQLFilter( Valid: true, } } - return nil } -func convertEntities(values []string) ([]db.Entities, error) { - converted := []db.Entities{} +func convert[ + T db.Entities | + db.RemediationStatusTypes | + db.AlertStatusTypes | + db.EvalStatusTypes, +]( + values []string, + mapf func(string) (T, error), +) ([]T, error) { + converted := []T{} for _, v := range values { - dbObj, err := mapEntities(v) + dbObj, err := mapf(v) if err != nil { return nil, err } @@ -420,20 +489,6 @@ func mapEntities(value string) (db.Entities, error) { } } -func convertRemediationStatusTypes( - values []string, -) ([]db.RemediationStatusTypes, error) { - converted := []db.RemediationStatusTypes{} - for _, v := range values { - dbObj, err := mapRemediationStatusTypes(v) - if err != nil { - return nil, err - } - converted = append(converted, dbObj) - } - return converted, nil -} - //nolint:goconst func mapRemediationStatusTypes( value string, @@ -457,20 +512,6 @@ func mapRemediationStatusTypes( } } -func convertAlertStatusTypes( - values []string, -) ([]db.AlertStatusTypes, error) { - converted := []db.AlertStatusTypes{} - for _, v := range values { - dbObj, err := mapAlertStatusTypes(v) - if err != nil { - return nil, err - } - converted = append(converted, dbObj) - } - return converted, nil -} - //nolint:goconst func mapAlertStatusTypes( value string, @@ -492,20 +533,6 @@ func mapAlertStatusTypes( } } -func convertEvalStatusTypes( - values []string, -) ([]db.EvalStatusTypes, error) { - converted := []db.EvalStatusTypes{} - for _, v := range values { - dbObj, err := mapEvalStatusTypes(v) - if err != nil { - return nil, err - } - converted = append(converted, dbObj) - } - return converted, nil -} - //nolint:goconst func mapEvalStatusTypes( value string, From dc7e1c9a72dee6ebe71705636e824062d1a1dd3a Mon Sep 17 00:00:00 2001 From: Michelangelo Mori Date: Mon, 8 Jul 2024 14:19:44 +0200 Subject: [PATCH 09/13] Refactoring cursor parser for better readability. --- internal/history/models.go | 60 +++++++++++++++++-------------------- internal/history/service.go | 2 +- 2 files changed, 29 insertions(+), 33 deletions(-) diff --git a/internal/history/models.go b/internal/history/models.go index b9599c66ab..f7cc659f9a 100644 --- a/internal/history/models.go +++ b/internal/history/models.go @@ -69,54 +69,50 @@ var ( // a ListEvaluationCursor. The opaque paylaod is expected to be of one // of the following forms // -// - `"+1257894000000000"` meaning the next page -// of data starting from the given UUID excluded +// - `"+1257894000000000"` meaning the next page of data starting +// from the given timestamp excluded // -// - `"-1257894000000000"` meaning the previous -// page of data starting from the given UUID excluded +// - `"-1257894000000000"` meaning the previous page of data +// starting from the given timestamp excluded // -// - `"1257894000000000"` meaning the next page -// of data (default) starting from the given UUID excluded +// - `"1257894000000000"` meaning the next page of data (default) +// starting from the given timestamp excluded func ParseListEvaluationCursor(payload string) (*ListEvaluationCursor, error) { decoded, err := base64.StdEncoding.DecodeString(payload) if err != nil { return nil, fmt.Errorf("%w: %s", ErrMalformedCursor, err) } - switch { - case string(decoded) == "": + if len(decoded) == 0 { return &DefaultCursor, nil + } + + var usecsStr string + var direction Direction + switch { case strings.HasPrefix(string(decoded), "+"): // +1257894000000000 - usecs, err := strconv.ParseInt(string(decoded[1:]), 10, 64) - if err != nil { - return nil, fmt.Errorf("%w: %s", ErrMalformedCursor, err) - } - return &ListEvaluationCursor{ - Time: time.UnixMicro(usecs).UTC(), - Direction: Next, - }, nil + usecsStr = string(decoded[1:]) + direction = Next case strings.HasPrefix(string(decoded), "-"): // -1257894000000000 - usecs, err := strconv.ParseInt(string(decoded[1:]), 10, 64) - if err != nil { - return nil, fmt.Errorf("%w: %s", ErrMalformedCursor, err) - } - return &ListEvaluationCursor{ - Time: time.UnixMicro(usecs).UTC(), - Direction: Prev, - }, nil + usecsStr = string(decoded[1:]) + direction = Prev default: // 1257894000000000 - usecs, err := strconv.ParseInt(string(decoded), 10, 64) - if err != nil { - return nil, fmt.Errorf("%w: %s", ErrMalformedCursor, err) - } - return &ListEvaluationCursor{ - Time: time.UnixMicro(usecs).UTC(), - Direction: Next, - }, nil + usecsStr = string(decoded) + direction = Next + } + + usecs, err := strconv.ParseInt(usecsStr, 10, 64) + if err != nil { + return nil, fmt.Errorf("%w: %s", ErrMalformedCursor, err) } + + return &ListEvaluationCursor{ + Time: time.UnixMicro(usecs).UTC(), + Direction: direction, + }, nil } // Filter is an empty interface to be implemented by structs diff --git a/internal/history/service.go b/internal/history/service.go index 4801185852..f9f44edfd5 100644 --- a/internal/history/service.go +++ b/internal/history/service.go @@ -462,7 +462,7 @@ func convert[ values []string, mapf func(string) (T, error), ) ([]T, error) { - converted := []T{} + converted := make([]T, 0, len(values)) for _, v := range values { dbObj, err := mapf(v) if err != nil { From f332e1d771ee0d619ffbdb7b02820e151cba9a7e Mon Sep 17 00:00:00 2001 From: Michelangelo Mori Date: Mon, 8 Jul 2024 14:31:01 +0200 Subject: [PATCH 10/13] Embed proto messages specific to EvaluationHistory. --- docs/docs/ref/proto.md | 20 +- internal/controlplane/handlers_evalstatus.go | 14 +- pkg/api/openapi/minder/v1/minder.swagger.json | 132 +- pkg/api/protobuf/go/minder/v1/minder.pb.go | 3485 ++++++++--------- proto/minder/v1/minder.proto | 104 +- 5 files changed, 1875 insertions(+), 1880 deletions(-) diff --git a/docs/docs/ref/proto.md b/docs/docs/ref/proto.md index b269f6ec09..3134e077e9 100644 --- a/docs/docs/ref/proto.md +++ b/docs/docs/ref/proto.md @@ -798,15 +798,15 @@ EvalResultAlert holds the alert details for a given rule evaluation | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | -| entity | EvaluationHistoryEntity | | entity contains details of the entity which was evaluated. | -| rule | EvaluationHistoryRule | | rule contains details of the rule which the entity was evaluated against. | -| status | EvaluationHistoryStatus | | status contains the evaluation status. | -| alert | EvaluationHistoryAlert | | alert contains details of the alerts for this evaluation. | -| remediation | EvaluationHistoryRemediation | | remediation contains details of the remediation for this evaluation. | +| entity | EvaluationHistory.Entity | | entity contains details of the entity which was evaluated. | +| rule | EvaluationHistory.Rule | | rule contains details of the rule which the entity was evaluated against. | +| status | EvaluationHistory.Status | | status contains the evaluation status. | +| alert | EvaluationHistory.Alert | | alert contains details of the alerts for this evaluation. | +| remediation | EvaluationHistory.Remediation | | remediation contains details of the remediation for this evaluation. | -EvaluationHistoryAlert +EvaluationHistory.Alert @@ -818,7 +818,7 @@ EvalResultAlert holds the alert details for a given rule evaluation -EvaluationHistoryEntity +EvaluationHistory.Entity @@ -831,7 +831,7 @@ EvalResultAlert holds the alert details for a given rule evaluation -EvaluationHistoryRemediation +EvaluationHistory.Remediation @@ -843,7 +843,7 @@ EvalResultAlert holds the alert details for a given rule evaluation -EvaluationHistoryRule +EvaluationHistory.Rule @@ -856,7 +856,7 @@ EvalResultAlert holds the alert details for a given rule evaluation -EvaluationHistoryStatus +EvaluationHistory.Status diff --git a/internal/controlplane/handlers_evalstatus.go b/internal/controlplane/handlers_evalstatus.go index 18278f3d76..7359a3833d 100644 --- a/internal/controlplane/handlers_evalstatus.go +++ b/internal/controlplane/handlers_evalstatus.go @@ -144,33 +144,33 @@ func fromEvaluationHistoryRow( return nil, errors.New("internal error") } - var alert *minderv1.EvaluationHistoryAlert + var alert *minderv1.EvaluationHistory_Alert if row.AlertStatus.Valid { - alert = &minderv1.EvaluationHistoryAlert{ + alert = &minderv1.EvaluationHistory_Alert{ Status: string(row.AlertStatus.AlertStatusTypes), Details: row.AlertDetails.String, } } - var remediation *minderv1.EvaluationHistoryRemediation + var remediation *minderv1.EvaluationHistory_Remediation if row.RemediationStatus.Valid { - remediation = &minderv1.EvaluationHistoryRemediation{ + remediation = &minderv1.EvaluationHistory_Remediation{ Status: string(row.RemediationStatus.RemediationStatusTypes), Details: row.RemediationDetails.String, } } res = append(res, &minderv1.EvaluationHistory{ - Entity: &minderv1.EvaluationHistoryEntity{ + Entity: &minderv1.EvaluationHistory_Entity{ Id: row.EvaluationID.String(), Type: entityType, Name: entityName, }, - Rule: &minderv1.EvaluationHistoryRule{ + Rule: &minderv1.EvaluationHistory_Rule{ Name: row.RuleName, Type: row.RuleType, Profile: row.ProfileName, }, - Status: &minderv1.EvaluationHistoryStatus{ + Status: &minderv1.EvaluationHistory_Status{ Status: string(row.EvaluationStatus), Details: row.EvaluationDetails, EvaluatedAt: timestamppb.New(row.EvaluatedAt), diff --git a/pkg/api/openapi/minder/v1/minder.swagger.json b/pkg/api/openapi/minder/v1/minder.swagger.json index c0fdecfbb9..a06a79eedd 100644 --- a/pkg/api/openapi/minder/v1/minder.swagger.json +++ b/pkg/api/openapi/minder/v1/minder.swagger.json @@ -2784,17 +2784,6 @@ } } }, - "DefinitionAlert": { - "type": "object", - "properties": { - "type": { - "type": "string" - }, - "securityAdvisory": { - "$ref": "#/definitions/AlertAlertTypeSA" - } - } - }, "DefinitionEval": { "type": "object", "properties": { @@ -2940,6 +2929,19 @@ "type": "object", "title": "no configuration for now" }, + "EvaluationHistoryRemediation": { + "type": "object", + "properties": { + "status": { + "type": "string", + "description": "status is one of (success, error, failure, skipped, not available)\nnot using enums to mirror the behaviour of the existing API contracts." + }, + "details": { + "type": "string", + "description": "details contains optional details about the remediation.\nthe structure and contents are remediation specific, and are subject to change." + } + } + }, "JQComparisonOperator": { "type": "object", "properties": { @@ -2994,28 +2996,6 @@ } } }, - "ProfileRule": { - "type": "object", - "properties": { - "type": { - "type": "string", - "description": "type is the type of the rule to be instantiated." - }, - "params": { - "type": "object", - "description": "params are the parameters that are passed to the rule.\nThis is optional and depends on the rule type." - }, - "def": { - "type": "object", - "description": "def is the definition of the rule.\nThis depends on the rule type." - }, - "name": { - "type": "string", - "title": "name is the descriptive name of the rule, not to be confused with type" - } - }, - "description": "Rule defines the individual call of a certain rule type." - }, "ProfileSelector": { "type": "object", "properties": { @@ -3155,11 +3135,34 @@ "$ref": "#/definitions/DefinitionRemediate" }, "alert": { - "$ref": "#/definitions/DefinitionAlert" + "$ref": "#/definitions/RuleTypeDefinitionAlert" } }, "description": "Definition defines the rule type. It encompases the schema and the data evaluation." }, + "RuleTypeDefinitionAlert": { + "type": "object", + "properties": { + "type": { + "type": "string" + }, + "securityAdvisory": { + "$ref": "#/definitions/AlertAlertTypeSA" + } + } + }, + "minderv1Entity": { + "type": "string", + "enum": [ + "ENTITY_UNSPECIFIED", + "ENTITY_REPOSITORIES", + "ENTITY_BUILD_ENVIRONMENTS", + "ENTITY_ARTIFACTS", + "ENTITY_PULL_REQUESTS" + ], + "default": "ENTITY_UNSPECIFIED", + "description": "Entity defines the entity that is supported by the provider." + }, "protobufNullValue": { "type": "string", "enum": [ @@ -3566,23 +3569,11 @@ }, "description": "DiffType defines the diff data ingester." }, - "v1Entity": { - "type": "string", - "enum": [ - "ENTITY_UNSPECIFIED", - "ENTITY_REPOSITORIES", - "ENTITY_BUILD_ENVIRONMENTS", - "ENTITY_ARTIFACTS", - "ENTITY_PULL_REQUESTS" - ], - "default": "ENTITY_UNSPECIFIED", - "description": "Entity defines the entity that is supported by the provider." - }, "v1EntityTypedId": { "type": "object", "properties": { "type": { - "$ref": "#/definitions/v1Entity", + "$ref": "#/definitions/minderv1Entity", "title": "entity is the entity to get status for. Incompatible with `all`" }, "id": { @@ -3635,7 +3626,7 @@ "description": "alert contains details of the alerts for this evaluation." }, "remediation": { - "$ref": "#/definitions/v1EvaluationHistoryRemediation", + "$ref": "#/definitions/EvaluationHistoryRemediation", "description": "remediation contains details of the remediation for this evaluation." } } @@ -3661,7 +3652,7 @@ "description": "id is the ID of the entity." }, "type": { - "$ref": "#/definitions/v1Entity", + "$ref": "#/definitions/minderv1Entity", "description": "type is the entity type." }, "name": { @@ -3670,19 +3661,6 @@ } } }, - "v1EvaluationHistoryRemediation": { - "type": "object", - "properties": { - "status": { - "type": "string", - "description": "status is one of (success, error, failure, skipped, not available)\nnot using enums to mirror the behaviour of the existing API contracts." - }, - "details": { - "type": "string", - "description": "details contains optional details about the remediation.\nthe structure and contents are remediation specific, and are subject to change." - } - } - }, "v1EvaluationHistoryRule": { "type": "object", "properties": { @@ -4230,7 +4208,7 @@ "type": "array", "items": { "type": "object", - "$ref": "#/definitions/ProfileRule" + "$ref": "#/definitions/v1ProfileRule" }, "description": "These are the entities that one could set in the profile." }, @@ -4238,21 +4216,21 @@ "type": "array", "items": { "type": "object", - "$ref": "#/definitions/ProfileRule" + "$ref": "#/definitions/v1ProfileRule" } }, "artifact": { "type": "array", "items": { "type": "object", - "$ref": "#/definitions/ProfileRule" + "$ref": "#/definitions/v1ProfileRule" } }, "pullRequest": { "type": "array", "items": { "type": "object", - "$ref": "#/definitions/ProfileRule" + "$ref": "#/definitions/v1ProfileRule" } }, "selection": { @@ -4285,6 +4263,28 @@ }, "description": "Profile defines a profile that is user defined." }, + "v1ProfileRule": { + "type": "object", + "properties": { + "type": { + "type": "string", + "description": "type is the type of the rule to be instantiated." + }, + "params": { + "type": "object", + "description": "params are the parameters that are passed to the rule.\nThis is optional and depends on the rule type." + }, + "def": { + "type": "object", + "description": "def is the definition of the rule.\nThis depends on the rule type." + }, + "name": { + "type": "string", + "title": "name is the descriptive name of the rule, not to be confused with type" + } + }, + "description": "Rule defines the individual call of a certain rule type." + }, "v1ProfileStatus": { "type": "object", "properties": { diff --git a/pkg/api/protobuf/go/minder/v1/minder.pb.go b/pkg/api/protobuf/go/minder/v1/minder.pb.go index e53749f9b9..02cc42200b 100644 --- a/pkg/api/protobuf/go/minder/v1/minder.pb.go +++ b/pkg/api/protobuf/go/minder/v1/minder.pb.go @@ -10667,15 +10667,15 @@ type EvaluationHistory struct { unknownFields protoimpl.UnknownFields // entity contains details of the entity which was evaluated. - Entity *EvaluationHistoryEntity `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"` + Entity *EvaluationHistory_Entity `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"` // rule contains details of the rule which the entity was evaluated against. - Rule *EvaluationHistoryRule `protobuf:"bytes,2,opt,name=rule,proto3" json:"rule,omitempty"` + Rule *EvaluationHistory_Rule `protobuf:"bytes,2,opt,name=rule,proto3" json:"rule,omitempty"` // status contains the evaluation status. - Status *EvaluationHistoryStatus `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"` + Status *EvaluationHistory_Status `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"` // alert contains details of the alerts for this evaluation. - Alert *EvaluationHistoryAlert `protobuf:"bytes,4,opt,name=alert,proto3" json:"alert,omitempty"` + Alert *EvaluationHistory_Alert `protobuf:"bytes,4,opt,name=alert,proto3" json:"alert,omitempty"` // remediation contains details of the remediation for this evaluation. - Remediation *EvaluationHistoryRemediation `protobuf:"bytes,5,opt,name=remediation,proto3" json:"remediation,omitempty"` + Remediation *EvaluationHistory_Remediation `protobuf:"bytes,5,opt,name=remediation,proto3" json:"remediation,omitempty"` } func (x *EvaluationHistory) Reset() { @@ -10710,56 +10710,52 @@ func (*EvaluationHistory) Descriptor() ([]byte, []int) { return file_minder_v1_minder_proto_rawDescGZIP(), []int{162} } -func (x *EvaluationHistory) GetEntity() *EvaluationHistoryEntity { +func (x *EvaluationHistory) GetEntity() *EvaluationHistory_Entity { if x != nil { return x.Entity } return nil } -func (x *EvaluationHistory) GetRule() *EvaluationHistoryRule { +func (x *EvaluationHistory) GetRule() *EvaluationHistory_Rule { if x != nil { return x.Rule } return nil } -func (x *EvaluationHistory) GetStatus() *EvaluationHistoryStatus { +func (x *EvaluationHistory) GetStatus() *EvaluationHistory_Status { if x != nil { return x.Status } return nil } -func (x *EvaluationHistory) GetAlert() *EvaluationHistoryAlert { +func (x *EvaluationHistory) GetAlert() *EvaluationHistory_Alert { if x != nil { return x.Alert } return nil } -func (x *EvaluationHistory) GetRemediation() *EvaluationHistoryRemediation { +func (x *EvaluationHistory) GetRemediation() *EvaluationHistory_Remediation { if x != nil { return x.Remediation } return nil } -type EvaluationHistoryEntity struct { +type PrDependencies_ContextualDependency struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // id is the ID of the entity. - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - // type is the entity type. - Type Entity `protobuf:"varint,2,opt,name=type,proto3,enum=minder.v1.Entity" json:"type,omitempty"` - // name is the entity name. - Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` + Dep *Dependency `protobuf:"bytes,1,opt,name=dep,proto3" json:"dep,omitempty"` + File *PrDependencies_ContextualDependency_FilePatch `protobuf:"bytes,2,opt,name=file,proto3" json:"file,omitempty"` } -func (x *EvaluationHistoryEntity) Reset() { - *x = EvaluationHistoryEntity{} +func (x *PrDependencies_ContextualDependency) Reset() { + *x = PrDependencies_ContextualDependency{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[163] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10767,13 +10763,13 @@ func (x *EvaluationHistoryEntity) Reset() { } } -func (x *EvaluationHistoryEntity) String() string { +func (x *PrDependencies_ContextualDependency) String() string { return protoimpl.X.MessageStringOf(x) } -func (*EvaluationHistoryEntity) ProtoMessage() {} +func (*PrDependencies_ContextualDependency) ProtoMessage() {} -func (x *EvaluationHistoryEntity) ProtoReflect() protoreflect.Message { +func (x *PrDependencies_ContextualDependency) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[163] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10785,47 +10781,36 @@ func (x *EvaluationHistoryEntity) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use EvaluationHistoryEntity.ProtoReflect.Descriptor instead. -func (*EvaluationHistoryEntity) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{163} -} - -func (x *EvaluationHistoryEntity) GetId() string { - if x != nil { - return x.Id - } - return "" +// Deprecated: Use PrDependencies_ContextualDependency.ProtoReflect.Descriptor instead. +func (*PrDependencies_ContextualDependency) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{13, 0} } -func (x *EvaluationHistoryEntity) GetType() Entity { +func (x *PrDependencies_ContextualDependency) GetDep() *Dependency { if x != nil { - return x.Type + return x.Dep } - return Entity_ENTITY_UNSPECIFIED + return nil } -func (x *EvaluationHistoryEntity) GetName() string { +func (x *PrDependencies_ContextualDependency) GetFile() *PrDependencies_ContextualDependency_FilePatch { if x != nil { - return x.Name + return x.File } - return "" + return nil } -type EvaluationHistoryRule struct { +type PrDependencies_ContextualDependency_FilePatch struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // name is the name of the rule instance. - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - // type is the name of the rule type. - Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"` - // profile is the name of the profile which contains the rule. - Profile string `protobuf:"bytes,3,opt,name=profile,proto3" json:"profile,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // file changed, e.g. package-lock.json + PatchUrl string `protobuf:"bytes,2,opt,name=patch_url,json=patchUrl,proto3" json:"patch_url,omitempty"` // points to the the raw patchfile } -func (x *EvaluationHistoryRule) Reset() { - *x = EvaluationHistoryRule{} +func (x *PrDependencies_ContextualDependency_FilePatch) Reset() { + *x = PrDependencies_ContextualDependency_FilePatch{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[164] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10833,13 +10818,13 @@ func (x *EvaluationHistoryRule) Reset() { } } -func (x *EvaluationHistoryRule) String() string { +func (x *PrDependencies_ContextualDependency_FilePatch) String() string { return protoimpl.X.MessageStringOf(x) } -func (*EvaluationHistoryRule) ProtoMessage() {} +func (*PrDependencies_ContextualDependency_FilePatch) ProtoMessage() {} -func (x *EvaluationHistoryRule) ProtoReflect() protoreflect.Message { +func (x *PrDependencies_ContextualDependency_FilePatch) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[164] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10851,49 +10836,37 @@ func (x *EvaluationHistoryRule) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use EvaluationHistoryRule.ProtoReflect.Descriptor instead. -func (*EvaluationHistoryRule) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{164} +// Deprecated: Use PrDependencies_ContextualDependency_FilePatch.ProtoReflect.Descriptor instead. +func (*PrDependencies_ContextualDependency_FilePatch) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{13, 0, 0} } -func (x *EvaluationHistoryRule) GetName() string { +func (x *PrDependencies_ContextualDependency_FilePatch) GetName() string { if x != nil { return x.Name } return "" } -func (x *EvaluationHistoryRule) GetType() string { - if x != nil { - return x.Type - } - return "" -} - -func (x *EvaluationHistoryRule) GetProfile() string { +func (x *PrDependencies_ContextualDependency_FilePatch) GetPatchUrl() string { if x != nil { - return x.Profile + return x.PatchUrl } return "" } -type EvaluationHistoryStatus struct { +type PrContents_File struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // status is one of (success, error, failure, skipped) - // not using enums to mirror the behaviour of the existing API contracts. - Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` - // details contains optional details about the evaluation. - // the structure and contents are rule type specific, and are subject to change. - Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"` - // created_at is the timestamp of creation of this evaluation - EvaluatedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=evaluated_at,json=evaluatedAt,proto3" json:"evaluated_at,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + FilePatchUrl string `protobuf:"bytes,2,opt,name=file_patch_url,json=filePatchUrl,proto3" json:"file_patch_url,omitempty"` + PatchLines []*PrContents_File_Line `protobuf:"bytes,3,rep,name=patch_lines,json=patchLines,proto3" json:"patch_lines,omitempty"` } -func (x *EvaluationHistoryStatus) Reset() { - *x = EvaluationHistoryStatus{} +func (x *PrContents_File) Reset() { + *x = PrContents_File{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[165] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10901,13 +10874,13 @@ func (x *EvaluationHistoryStatus) Reset() { } } -func (x *EvaluationHistoryStatus) String() string { +func (x *PrContents_File) String() string { return protoimpl.X.MessageStringOf(x) } -func (*EvaluationHistoryStatus) ProtoMessage() {} +func (*PrContents_File) ProtoMessage() {} -func (x *EvaluationHistoryStatus) ProtoReflect() protoreflect.Message { +func (x *PrContents_File) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[165] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10919,47 +10892,45 @@ func (x *EvaluationHistoryStatus) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use EvaluationHistoryStatus.ProtoReflect.Descriptor instead. -func (*EvaluationHistoryStatus) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{165} +// Deprecated: Use PrContents_File.ProtoReflect.Descriptor instead. +func (*PrContents_File) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{14, 0} } -func (x *EvaluationHistoryStatus) GetStatus() string { +func (x *PrContents_File) GetName() string { if x != nil { - return x.Status + return x.Name } return "" } -func (x *EvaluationHistoryStatus) GetDetails() string { +func (x *PrContents_File) GetFilePatchUrl() string { if x != nil { - return x.Details + return x.FilePatchUrl } return "" } -func (x *EvaluationHistoryStatus) GetEvaluatedAt() *timestamppb.Timestamp { +func (x *PrContents_File) GetPatchLines() []*PrContents_File_Line { if x != nil { - return x.EvaluatedAt + return x.PatchLines } return nil } -type EvaluationHistoryRemediation struct { +type PrContents_File_Line struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // status is one of (success, error, failure, skipped, not available) - // not using enums to mirror the behaviour of the existing API contracts. - Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` - // details contains optional details about the remediation. - // the structure and contents are remediation specific, and are subject to change. - Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"` + // Deliberately left as an int32: a diff with more than 2^31 lines + // could lead to various problems while processing. + LineNumber int32 `protobuf:"varint,1,opt,name=line_number,json=lineNumber,proto3" json:"line_number,omitempty"` + Content string `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"` } -func (x *EvaluationHistoryRemediation) Reset() { - *x = EvaluationHistoryRemediation{} +func (x *PrContents_File_Line) Reset() { + *x = PrContents_File_Line{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[166] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10967,13 +10938,13 @@ func (x *EvaluationHistoryRemediation) Reset() { } } -func (x *EvaluationHistoryRemediation) String() string { +func (x *PrContents_File_Line) String() string { return protoimpl.X.MessageStringOf(x) } -func (*EvaluationHistoryRemediation) ProtoMessage() {} +func (*PrContents_File_Line) ProtoMessage() {} -func (x *EvaluationHistoryRemediation) ProtoReflect() protoreflect.Message { +func (x *PrContents_File_Line) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[166] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10985,40 +10956,36 @@ func (x *EvaluationHistoryRemediation) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use EvaluationHistoryRemediation.ProtoReflect.Descriptor instead. -func (*EvaluationHistoryRemediation) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{166} +// Deprecated: Use PrContents_File_Line.ProtoReflect.Descriptor instead. +func (*PrContents_File_Line) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{14, 0, 0} } -func (x *EvaluationHistoryRemediation) GetStatus() string { +func (x *PrContents_File_Line) GetLineNumber() int32 { if x != nil { - return x.Status + return x.LineNumber } - return "" + return 0 } -func (x *EvaluationHistoryRemediation) GetDetails() string { +func (x *PrContents_File_Line) GetContent() string { if x != nil { - return x.Details + return x.Content } return "" } -type EvaluationHistoryAlert struct { +type RegisterRepoResult_Status struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // status is one of (on, off, error, skipped, not available) - // not using enums to mirror the behaviour of the existing API contracts. - Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` - // details contains optional details about the alert. - // the structure and contents are alert specific, and are subject to change. - Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"` + Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` + Error *string `protobuf:"bytes,2,opt,name=error,proto3,oneof" json:"error,omitempty"` } -func (x *EvaluationHistoryAlert) Reset() { - *x = EvaluationHistoryAlert{} +func (x *RegisterRepoResult_Status) Reset() { + *x = RegisterRepoResult_Status{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[167] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11026,13 +10993,13 @@ func (x *EvaluationHistoryAlert) Reset() { } } -func (x *EvaluationHistoryAlert) String() string { +func (x *RegisterRepoResult_Status) String() string { return protoimpl.X.MessageStringOf(x) } -func (*EvaluationHistoryAlert) ProtoMessage() {} +func (*RegisterRepoResult_Status) ProtoMessage() {} -func (x *EvaluationHistoryAlert) ProtoReflect() protoreflect.Message { +func (x *RegisterRepoResult_Status) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[167] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11044,51 +11011,54 @@ func (x *EvaluationHistoryAlert) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use EvaluationHistoryAlert.ProtoReflect.Descriptor instead. -func (*EvaluationHistoryAlert) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{167} +// Deprecated: Use RegisterRepoResult_Status.ProtoReflect.Descriptor instead. +func (*RegisterRepoResult_Status) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{29, 0} } -func (x *EvaluationHistoryAlert) GetStatus() string { +func (x *RegisterRepoResult_Status) GetSuccess() bool { if x != nil { - return x.Status + return x.Success } - return "" + return false } -func (x *EvaluationHistoryAlert) GetDetails() string { - if x != nil { - return x.Details +func (x *RegisterRepoResult_Status) GetError() string { + if x != nil && x.Error != nil { + return *x.Error } return "" } -type PrDependencies_ContextualDependency struct { +type ListEvaluationResultsResponse_EntityProfileEvaluationResults struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Dep *Dependency `protobuf:"bytes,1,opt,name=dep,proto3" json:"dep,omitempty"` - File *PrDependencies_ContextualDependency_FilePatch `protobuf:"bytes,2,opt,name=file,proto3" json:"file,omitempty"` + // profile_status is the status of the profile - id, name, status, last_updated + ProfileStatus *ProfileStatus `protobuf:"bytes,1,opt,name=profile_status,json=profileStatus,proto3" json:"profile_status,omitempty"` + // Note that some fields like profile_id and entity might be empty + // Eventually we might replace this type with another one that fits the API better + Results []*RuleEvaluationStatus `protobuf:"bytes,2,rep,name=results,proto3" json:"results,omitempty"` } -func (x *PrDependencies_ContextualDependency) Reset() { - *x = PrDependencies_ContextualDependency{} +func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) Reset() { + *x = ListEvaluationResultsResponse_EntityProfileEvaluationResults{} if protoimpl.UnsafeEnabled { - mi := &file_minder_v1_minder_proto_msgTypes[168] + mi := &file_minder_v1_minder_proto_msgTypes[170] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *PrDependencies_ContextualDependency) String() string { +func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) String() string { return protoimpl.X.MessageStringOf(x) } -func (*PrDependencies_ContextualDependency) ProtoMessage() {} +func (*ListEvaluationResultsResponse_EntityProfileEvaluationResults) ProtoMessage() {} -func (x *PrDependencies_ContextualDependency) ProtoReflect() protoreflect.Message { - mi := &file_minder_v1_minder_proto_msgTypes[168] +func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) ProtoReflect() protoreflect.Message { + mi := &file_minder_v1_minder_proto_msgTypes[170] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11099,51 +11069,51 @@ func (x *PrDependencies_ContextualDependency) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use PrDependencies_ContextualDependency.ProtoReflect.Descriptor instead. -func (*PrDependencies_ContextualDependency) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{13, 0} +// Deprecated: Use ListEvaluationResultsResponse_EntityProfileEvaluationResults.ProtoReflect.Descriptor instead. +func (*ListEvaluationResultsResponse_EntityProfileEvaluationResults) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{99, 0} } -func (x *PrDependencies_ContextualDependency) GetDep() *Dependency { +func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) GetProfileStatus() *ProfileStatus { if x != nil { - return x.Dep + return x.ProfileStatus } return nil } -func (x *PrDependencies_ContextualDependency) GetFile() *PrDependencies_ContextualDependency_FilePatch { +func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) GetResults() []*RuleEvaluationStatus { if x != nil { - return x.File + return x.Results } return nil } -type PrDependencies_ContextualDependency_FilePatch struct { +type ListEvaluationResultsResponse_EntityEvaluationResults struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // file changed, e.g. package-lock.json - PatchUrl string `protobuf:"bytes,2,opt,name=patch_url,json=patchUrl,proto3" json:"patch_url,omitempty"` // points to the the raw patchfile + Entity *EntityTypedId `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"` + Profiles []*ListEvaluationResultsResponse_EntityProfileEvaluationResults `protobuf:"bytes,2,rep,name=profiles,proto3" json:"profiles,omitempty"` } -func (x *PrDependencies_ContextualDependency_FilePatch) Reset() { - *x = PrDependencies_ContextualDependency_FilePatch{} +func (x *ListEvaluationResultsResponse_EntityEvaluationResults) Reset() { + *x = ListEvaluationResultsResponse_EntityEvaluationResults{} if protoimpl.UnsafeEnabled { - mi := &file_minder_v1_minder_proto_msgTypes[169] + mi := &file_minder_v1_minder_proto_msgTypes[171] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *PrDependencies_ContextualDependency_FilePatch) String() string { +func (x *ListEvaluationResultsResponse_EntityEvaluationResults) String() string { return protoimpl.X.MessageStringOf(x) } -func (*PrDependencies_ContextualDependency_FilePatch) ProtoMessage() {} +func (*ListEvaluationResultsResponse_EntityEvaluationResults) ProtoMessage() {} -func (x *PrDependencies_ContextualDependency_FilePatch) ProtoReflect() protoreflect.Message { - mi := &file_minder_v1_minder_proto_msgTypes[169] +func (x *ListEvaluationResultsResponse_EntityEvaluationResults) ProtoReflect() protoreflect.Message { + mi := &file_minder_v1_minder_proto_msgTypes[171] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11154,52 +11124,51 @@ func (x *PrDependencies_ContextualDependency_FilePatch) ProtoReflect() protorefl return mi.MessageOf(x) } -// Deprecated: Use PrDependencies_ContextualDependency_FilePatch.ProtoReflect.Descriptor instead. -func (*PrDependencies_ContextualDependency_FilePatch) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{13, 0, 0} +// Deprecated: Use ListEvaluationResultsResponse_EntityEvaluationResults.ProtoReflect.Descriptor instead. +func (*ListEvaluationResultsResponse_EntityEvaluationResults) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{99, 1} } -func (x *PrDependencies_ContextualDependency_FilePatch) GetName() string { +func (x *ListEvaluationResultsResponse_EntityEvaluationResults) GetEntity() *EntityTypedId { if x != nil { - return x.Name + return x.Entity } - return "" + return nil } -func (x *PrDependencies_ContextualDependency_FilePatch) GetPatchUrl() string { +func (x *ListEvaluationResultsResponse_EntityEvaluationResults) GetProfiles() []*ListEvaluationResultsResponse_EntityProfileEvaluationResults { if x != nil { - return x.PatchUrl + return x.Profiles } - return "" + return nil } -type PrContents_File struct { +type RestType_Fallback struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - FilePatchUrl string `protobuf:"bytes,2,opt,name=file_patch_url,json=filePatchUrl,proto3" json:"file_patch_url,omitempty"` - PatchLines []*PrContents_File_Line `protobuf:"bytes,3,rep,name=patch_lines,json=patchLines,proto3" json:"patch_lines,omitempty"` + HttpCode int32 `protobuf:"varint,1,opt,name=http_code,json=httpCode,proto3" json:"http_code,omitempty"` + Body string `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"` } -func (x *PrContents_File) Reset() { - *x = PrContents_File{} +func (x *RestType_Fallback) Reset() { + *x = RestType_Fallback{} if protoimpl.UnsafeEnabled { - mi := &file_minder_v1_minder_proto_msgTypes[170] + mi := &file_minder_v1_minder_proto_msgTypes[172] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *PrContents_File) String() string { +func (x *RestType_Fallback) String() string { return protoimpl.X.MessageStringOf(x) } -func (*PrContents_File) ProtoMessage() {} +func (*RestType_Fallback) ProtoMessage() {} -func (x *PrContents_File) ProtoReflect() protoreflect.Message { - mi := &file_minder_v1_minder_proto_msgTypes[170] +func (x *RestType_Fallback) ProtoReflect() protoreflect.Message { + mi := &file_minder_v1_minder_proto_msgTypes[172] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11210,60 +11179,53 @@ func (x *PrContents_File) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use PrContents_File.ProtoReflect.Descriptor instead. -func (*PrContents_File) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{14, 0} +// Deprecated: Use RestType_Fallback.ProtoReflect.Descriptor instead. +func (*RestType_Fallback) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{100, 0} } -func (x *PrContents_File) GetName() string { +func (x *RestType_Fallback) GetHttpCode() int32 { if x != nil { - return x.Name + return x.HttpCode } - return "" + return 0 } -func (x *PrContents_File) GetFilePatchUrl() string { +func (x *RestType_Fallback) GetBody() string { if x != nil { - return x.FilePatchUrl + return x.Body } return "" } -func (x *PrContents_File) GetPatchLines() []*PrContents_File_Line { - if x != nil { - return x.PatchLines - } - return nil -} - -type PrContents_File_Line struct { +type DiffType_Ecosystem struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // Deliberately left as an int32: a diff with more than 2^31 lines - // could lead to various problems while processing. - LineNumber int32 `protobuf:"varint,1,opt,name=line_number,json=lineNumber,proto3" json:"line_number,omitempty"` - Content string `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"` + // name is the name of the ecosystem. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // depfile is the file that contains the dependencies for this ecosystem + Depfile string `protobuf:"bytes,2,opt,name=depfile,proto3" json:"depfile,omitempty"` } -func (x *PrContents_File_Line) Reset() { - *x = PrContents_File_Line{} +func (x *DiffType_Ecosystem) Reset() { + *x = DiffType_Ecosystem{} if protoimpl.UnsafeEnabled { - mi := &file_minder_v1_minder_proto_msgTypes[171] + mi := &file_minder_v1_minder_proto_msgTypes[173] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *PrContents_File_Line) String() string { +func (x *DiffType_Ecosystem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*PrContents_File_Line) ProtoMessage() {} +func (*DiffType_Ecosystem) ProtoMessage() {} -func (x *PrContents_File_Line) ProtoReflect() protoreflect.Message { - mi := &file_minder_v1_minder_proto_msgTypes[171] +func (x *DiffType_Ecosystem) ProtoReflect() protoreflect.Message { + mi := &file_minder_v1_minder_proto_msgTypes[173] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11274,51 +11236,62 @@ func (x *PrContents_File_Line) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use PrContents_File_Line.ProtoReflect.Descriptor instead. -func (*PrContents_File_Line) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{14, 0, 0} +// Deprecated: Use DiffType_Ecosystem.ProtoReflect.Descriptor instead. +func (*DiffType_Ecosystem) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{104, 0} } -func (x *PrContents_File_Line) GetLineNumber() int32 { +func (x *DiffType_Ecosystem) GetName() string { if x != nil { - return x.LineNumber + return x.Name } - return 0 + return "" } -func (x *PrContents_File_Line) GetContent() string { +func (x *DiffType_Ecosystem) GetDepfile() string { if x != nil { - return x.Content + return x.Depfile } return "" } -type RegisterRepoResult_Status struct { +// Definition defines the rule type. It encompases the schema and the data evaluation. +type RuleType_Definition struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` - Error *string `protobuf:"bytes,2,opt,name=error,proto3,oneof" json:"error,omitempty"` + // in_entity is the entity in which the rule is evaluated. + // This can be repository, build_environment or artifact. + InEntity string `protobuf:"bytes,1,opt,name=in_entity,json=inEntity,proto3" json:"in_entity,omitempty"` + // rule_schema is the schema of the rule. This is expressed in JSON Schema. + RuleSchema *structpb.Struct `protobuf:"bytes,2,opt,name=rule_schema,json=ruleSchema,proto3" json:"rule_schema,omitempty"` + // param_schema is the schema of the parameters that are passed to the rule. + // This is expressed in JSON Schema. + ParamSchema *structpb.Struct `protobuf:"bytes,3,opt,name=param_schema,json=paramSchema,proto3,oneof" json:"param_schema,omitempty"` + Ingest *RuleType_Definition_Ingest `protobuf:"bytes,4,opt,name=ingest,proto3" json:"ingest,omitempty"` + Eval *RuleType_Definition_Eval `protobuf:"bytes,5,opt,name=eval,proto3" json:"eval,omitempty"` + Remediate *RuleType_Definition_Remediate `protobuf:"bytes,6,opt,name=remediate,proto3" json:"remediate,omitempty"` + Alert *RuleType_Definition_Alert `protobuf:"bytes,7,opt,name=alert,proto3" json:"alert,omitempty"` } -func (x *RegisterRepoResult_Status) Reset() { - *x = RegisterRepoResult_Status{} +func (x *RuleType_Definition) Reset() { + *x = RuleType_Definition{} if protoimpl.UnsafeEnabled { - mi := &file_minder_v1_minder_proto_msgTypes[172] + mi := &file_minder_v1_minder_proto_msgTypes[174] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *RegisterRepoResult_Status) String() string { +func (x *RuleType_Definition) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RegisterRepoResult_Status) ProtoMessage() {} +func (*RuleType_Definition) ProtoMessage() {} -func (x *RegisterRepoResult_Status) ProtoReflect() protoreflect.Message { - mi := &file_minder_v1_minder_proto_msgTypes[172] +func (x *RuleType_Definition) ProtoReflect() protoreflect.Message { + mi := &file_minder_v1_minder_proto_msgTypes[174] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11329,39 +11302,84 @@ func (x *RegisterRepoResult_Status) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RegisterRepoResult_Status.ProtoReflect.Descriptor instead. -func (*RegisterRepoResult_Status) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{29, 0} +// Deprecated: Use RuleType_Definition.ProtoReflect.Descriptor instead. +func (*RuleType_Definition) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0} } -func (x *RegisterRepoResult_Status) GetSuccess() bool { +func (x *RuleType_Definition) GetInEntity() string { if x != nil { - return x.Success + return x.InEntity } - return false + return "" } -func (x *RegisterRepoResult_Status) GetError() string { - if x != nil && x.Error != nil { - return *x.Error +func (x *RuleType_Definition) GetRuleSchema() *structpb.Struct { + if x != nil { + return x.RuleSchema } - return "" + return nil } -type ListEvaluationResultsResponse_EntityProfileEvaluationResults struct { +func (x *RuleType_Definition) GetParamSchema() *structpb.Struct { + if x != nil { + return x.ParamSchema + } + return nil +} + +func (x *RuleType_Definition) GetIngest() *RuleType_Definition_Ingest { + if x != nil { + return x.Ingest + } + return nil +} + +func (x *RuleType_Definition) GetEval() *RuleType_Definition_Eval { + if x != nil { + return x.Eval + } + return nil +} + +func (x *RuleType_Definition) GetRemediate() *RuleType_Definition_Remediate { + if x != nil { + return x.Remediate + } + return nil +} + +func (x *RuleType_Definition) GetAlert() *RuleType_Definition_Alert { + if x != nil { + return x.Alert + } + return nil +} + +// Ingest defines how the data is ingested. +type RuleType_Definition_Ingest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // profile_status is the status of the profile - id, name, status, last_updated - ProfileStatus *ProfileStatus `protobuf:"bytes,1,opt,name=profile_status,json=profileStatus,proto3" json:"profile_status,omitempty"` - // Note that some fields like profile_id and entity might be empty - // Eventually we might replace this type with another one that fits the API better - Results []*RuleEvaluationStatus `protobuf:"bytes,2,rep,name=results,proto3" json:"results,omitempty"` + // type is the type of the data ingestion. + // we currently support rest, artifact and builtin. + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + // rest is the rest data ingestion. + // this is only used if the type is rest. + Rest *RestType `protobuf:"bytes,3,opt,name=rest,proto3,oneof" json:"rest,omitempty"` + // builtin is the builtin data ingestion. + Builtin *BuiltinType `protobuf:"bytes,4,opt,name=builtin,proto3,oneof" json:"builtin,omitempty"` + // artifact is the artifact data ingestion. + Artifact *ArtifactType `protobuf:"bytes,5,opt,name=artifact,proto3,oneof" json:"artifact,omitempty"` + // git is the git data ingestion. + Git *GitType `protobuf:"bytes,6,opt,name=git,proto3,oneof" json:"git,omitempty"` + // diff is the diff data ingestion. + Diff *DiffType `protobuf:"bytes,7,opt,name=diff,proto3,oneof" json:"diff,omitempty"` } -func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) Reset() { - *x = ListEvaluationResultsResponse_EntityProfileEvaluationResults{} +func (x *RuleType_Definition_Ingest) Reset() { + *x = RuleType_Definition_Ingest{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[175] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11369,13 +11387,13 @@ func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) Reset() { } } -func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) String() string { +func (x *RuleType_Definition_Ingest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListEvaluationResultsResponse_EntityProfileEvaluationResults) ProtoMessage() {} +func (*RuleType_Definition_Ingest) ProtoMessage() {} -func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Ingest) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[175] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11387,36 +11405,81 @@ func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) ProtoRefl return mi.MessageOf(x) } -// Deprecated: Use ListEvaluationResultsResponse_EntityProfileEvaluationResults.ProtoReflect.Descriptor instead. -func (*ListEvaluationResultsResponse_EntityProfileEvaluationResults) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{99, 0} +// Deprecated: Use RuleType_Definition_Ingest.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Ingest) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 0} } -func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) GetProfileStatus() *ProfileStatus { +func (x *RuleType_Definition_Ingest) GetType() string { if x != nil { - return x.ProfileStatus + return x.Type + } + return "" +} + +func (x *RuleType_Definition_Ingest) GetRest() *RestType { + if x != nil { + return x.Rest } return nil } -func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) GetResults() []*RuleEvaluationStatus { +func (x *RuleType_Definition_Ingest) GetBuiltin() *BuiltinType { if x != nil { - return x.Results + return x.Builtin } return nil } -type ListEvaluationResultsResponse_EntityEvaluationResults struct { +func (x *RuleType_Definition_Ingest) GetArtifact() *ArtifactType { + if x != nil { + return x.Artifact + } + return nil +} + +func (x *RuleType_Definition_Ingest) GetGit() *GitType { + if x != nil { + return x.Git + } + return nil +} + +func (x *RuleType_Definition_Ingest) GetDiff() *DiffType { + if x != nil { + return x.Diff + } + return nil +} + +// Eval defines the data evaluation definition. +// This pertains to the way we traverse data from the upstream +// endpoint and how we compare it to the rule. +type RuleType_Definition_Eval struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Entity *EntityTypedId `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"` - Profiles []*ListEvaluationResultsResponse_EntityProfileEvaluationResults `protobuf:"bytes,2,rep,name=profiles,proto3" json:"profiles,omitempty"` + // type is the type of the data evaluation. + // Right now only `jq` is supported as a driver + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + // jq is only used if the `jq` type is selected. + // It defines the comparisons that are made between + // the ingested data and the profile rule. + Jq []*RuleType_Definition_Eval_JQComparison `protobuf:"bytes,2,rep,name=jq,proto3" json:"jq,omitempty"` + // rego is only used if the `rego` type is selected. + Rego *RuleType_Definition_Eval_Rego `protobuf:"bytes,3,opt,name=rego,proto3,oneof" json:"rego,omitempty"` + // vulncheck is only used if the `vulncheck` type is selected. + Vulncheck *RuleType_Definition_Eval_Vulncheck `protobuf:"bytes,4,opt,name=vulncheck,proto3,oneof" json:"vulncheck,omitempty"` + // The trusty type is no longer used, but is still here for backwards + // compatibility with existing stored rules + Trusty *RuleType_Definition_Eval_Trusty `protobuf:"bytes,5,opt,name=trusty,proto3,oneof" json:"trusty,omitempty"` + // homoglyphs is only used if the `homoglyphs` type is selected. + Homoglyphs *RuleType_Definition_Eval_Homoglyphs `protobuf:"bytes,6,opt,name=homoglyphs,proto3,oneof" json:"homoglyphs,omitempty"` } -func (x *ListEvaluationResultsResponse_EntityEvaluationResults) Reset() { - *x = ListEvaluationResultsResponse_EntityEvaluationResults{} +func (x *RuleType_Definition_Eval) Reset() { + *x = RuleType_Definition_Eval{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[176] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11424,13 +11487,13 @@ func (x *ListEvaluationResultsResponse_EntityEvaluationResults) Reset() { } } -func (x *ListEvaluationResultsResponse_EntityEvaluationResults) String() string { +func (x *RuleType_Definition_Eval) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListEvaluationResultsResponse_EntityEvaluationResults) ProtoMessage() {} +func (*RuleType_Definition_Eval) ProtoMessage() {} -func (x *ListEvaluationResultsResponse_EntityEvaluationResults) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Eval) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[176] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11442,36 +11505,66 @@ func (x *ListEvaluationResultsResponse_EntityEvaluationResults) ProtoReflect() p return mi.MessageOf(x) } -// Deprecated: Use ListEvaluationResultsResponse_EntityEvaluationResults.ProtoReflect.Descriptor instead. -func (*ListEvaluationResultsResponse_EntityEvaluationResults) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{99, 1} +// Deprecated: Use RuleType_Definition_Eval.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Eval) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1} } -func (x *ListEvaluationResultsResponse_EntityEvaluationResults) GetEntity() *EntityTypedId { +func (x *RuleType_Definition_Eval) GetType() string { if x != nil { - return x.Entity + return x.Type + } + return "" +} + +func (x *RuleType_Definition_Eval) GetJq() []*RuleType_Definition_Eval_JQComparison { + if x != nil { + return x.Jq } return nil } -func (x *ListEvaluationResultsResponse_EntityEvaluationResults) GetProfiles() []*ListEvaluationResultsResponse_EntityProfileEvaluationResults { +func (x *RuleType_Definition_Eval) GetRego() *RuleType_Definition_Eval_Rego { if x != nil { - return x.Profiles + return x.Rego } return nil } -type RestType_Fallback struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields +func (x *RuleType_Definition_Eval) GetVulncheck() *RuleType_Definition_Eval_Vulncheck { + if x != nil { + return x.Vulncheck + } + return nil +} - HttpCode int32 `protobuf:"varint,1,opt,name=http_code,json=httpCode,proto3" json:"http_code,omitempty"` - Body string `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"` +func (x *RuleType_Definition_Eval) GetTrusty() *RuleType_Definition_Eval_Trusty { + if x != nil { + return x.Trusty + } + return nil } -func (x *RestType_Fallback) Reset() { - *x = RestType_Fallback{} +func (x *RuleType_Definition_Eval) GetHomoglyphs() *RuleType_Definition_Eval_Homoglyphs { + if x != nil { + return x.Homoglyphs + } + return nil +} + +type RuleType_Definition_Remediate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + Rest *RestType `protobuf:"bytes,2,opt,name=rest,proto3,oneof" json:"rest,omitempty"` + GhBranchProtection *RuleType_Definition_Remediate_GhBranchProtectionType `protobuf:"bytes,3,opt,name=gh_branch_protection,json=ghBranchProtection,proto3,oneof" json:"gh_branch_protection,omitempty"` + PullRequest *RuleType_Definition_Remediate_PullRequestRemediation `protobuf:"bytes,4,opt,name=pull_request,json=pullRequest,proto3,oneof" json:"pull_request,omitempty"` +} + +func (x *RuleType_Definition_Remediate) Reset() { + *x = RuleType_Definition_Remediate{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11479,13 +11572,13 @@ func (x *RestType_Fallback) Reset() { } } -func (x *RestType_Fallback) String() string { +func (x *RuleType_Definition_Remediate) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RestType_Fallback) ProtoMessage() {} +func (*RuleType_Definition_Remediate) ProtoMessage() {} -func (x *RestType_Fallback) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Remediate) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[177] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11497,38 +11590,50 @@ func (x *RestType_Fallback) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RestType_Fallback.ProtoReflect.Descriptor instead. -func (*RestType_Fallback) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{100, 0} +// Deprecated: Use RuleType_Definition_Remediate.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Remediate) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2} } -func (x *RestType_Fallback) GetHttpCode() int32 { +func (x *RuleType_Definition_Remediate) GetType() string { if x != nil { - return x.HttpCode + return x.Type } - return 0 + return "" } -func (x *RestType_Fallback) GetBody() string { +func (x *RuleType_Definition_Remediate) GetRest() *RestType { if x != nil { - return x.Body + return x.Rest } - return "" + return nil } -type DiffType_Ecosystem struct { +func (x *RuleType_Definition_Remediate) GetGhBranchProtection() *RuleType_Definition_Remediate_GhBranchProtectionType { + if x != nil { + return x.GhBranchProtection + } + return nil +} + +func (x *RuleType_Definition_Remediate) GetPullRequest() *RuleType_Definition_Remediate_PullRequestRemediation { + if x != nil { + return x.PullRequest + } + return nil +} + +type RuleType_Definition_Alert struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // name is the name of the ecosystem. - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - // depfile is the file that contains the dependencies for this ecosystem - Depfile string `protobuf:"bytes,2,opt,name=depfile,proto3" json:"depfile,omitempty"` + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + SecurityAdvisory *RuleType_Definition_Alert_AlertTypeSA `protobuf:"bytes,2,opt,name=security_advisory,json=securityAdvisory,proto3,oneof" json:"security_advisory,omitempty"` } -func (x *DiffType_Ecosystem) Reset() { - *x = DiffType_Ecosystem{} +func (x *RuleType_Definition_Alert) Reset() { + *x = RuleType_Definition_Alert{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11536,13 +11641,13 @@ func (x *DiffType_Ecosystem) Reset() { } } -func (x *DiffType_Ecosystem) String() string { +func (x *RuleType_Definition_Alert) String() string { return protoimpl.X.MessageStringOf(x) } -func (*DiffType_Ecosystem) ProtoMessage() {} +func (*RuleType_Definition_Alert) ProtoMessage() {} -func (x *DiffType_Ecosystem) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Alert) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[178] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11554,47 +11659,38 @@ func (x *DiffType_Ecosystem) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use DiffType_Ecosystem.ProtoReflect.Descriptor instead. -func (*DiffType_Ecosystem) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{104, 0} +// Deprecated: Use RuleType_Definition_Alert.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Alert) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 3} } -func (x *DiffType_Ecosystem) GetName() string { +func (x *RuleType_Definition_Alert) GetType() string { if x != nil { - return x.Name + return x.Type } return "" } -func (x *DiffType_Ecosystem) GetDepfile() string { +func (x *RuleType_Definition_Alert) GetSecurityAdvisory() *RuleType_Definition_Alert_AlertTypeSA { if x != nil { - return x.Depfile + return x.SecurityAdvisory } - return "" + return nil } -// Definition defines the rule type. It encompases the schema and the data evaluation. -type RuleType_Definition struct { +type RuleType_Definition_Eval_JQComparison struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // in_entity is the entity in which the rule is evaluated. - // This can be repository, build_environment or artifact. - InEntity string `protobuf:"bytes,1,opt,name=in_entity,json=inEntity,proto3" json:"in_entity,omitempty"` - // rule_schema is the schema of the rule. This is expressed in JSON Schema. - RuleSchema *structpb.Struct `protobuf:"bytes,2,opt,name=rule_schema,json=ruleSchema,proto3" json:"rule_schema,omitempty"` - // param_schema is the schema of the parameters that are passed to the rule. - // This is expressed in JSON Schema. - ParamSchema *structpb.Struct `protobuf:"bytes,3,opt,name=param_schema,json=paramSchema,proto3,oneof" json:"param_schema,omitempty"` - Ingest *RuleType_Definition_Ingest `protobuf:"bytes,4,opt,name=ingest,proto3" json:"ingest,omitempty"` - Eval *RuleType_Definition_Eval `protobuf:"bytes,5,opt,name=eval,proto3" json:"eval,omitempty"` - Remediate *RuleType_Definition_Remediate `protobuf:"bytes,6,opt,name=remediate,proto3" json:"remediate,omitempty"` - Alert *RuleType_Definition_Alert `protobuf:"bytes,7,opt,name=alert,proto3" json:"alert,omitempty"` + // Ingested points to the data retrieved in the `ingest` section + Ingested *RuleType_Definition_Eval_JQComparison_Operator `protobuf:"bytes,1,opt,name=ingested,proto3" json:"ingested,omitempty"` + // Profile points to the profile itself. + Profile *RuleType_Definition_Eval_JQComparison_Operator `protobuf:"bytes,2,opt,name=profile,proto3" json:"profile,omitempty"` } -func (x *RuleType_Definition) Reset() { - *x = RuleType_Definition{} +func (x *RuleType_Definition_Eval_JQComparison) Reset() { + *x = RuleType_Definition_Eval_JQComparison{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11602,13 +11698,13 @@ func (x *RuleType_Definition) Reset() { } } -func (x *RuleType_Definition) String() string { +func (x *RuleType_Definition_Eval_JQComparison) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition) ProtoMessage() {} +func (*RuleType_Definition_Eval_JQComparison) ProtoMessage() {} -func (x *RuleType_Definition) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Eval_JQComparison) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[179] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11620,84 +11716,52 @@ func (x *RuleType_Definition) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition.ProtoReflect.Descriptor instead. -func (*RuleType_Definition) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0} -} - -func (x *RuleType_Definition) GetInEntity() string { - if x != nil { - return x.InEntity - } - return "" -} - -func (x *RuleType_Definition) GetRuleSchema() *structpb.Struct { - if x != nil { - return x.RuleSchema - } - return nil -} - -func (x *RuleType_Definition) GetParamSchema() *structpb.Struct { - if x != nil { - return x.ParamSchema - } - return nil -} - -func (x *RuleType_Definition) GetIngest() *RuleType_Definition_Ingest { - if x != nil { - return x.Ingest - } - return nil -} - -func (x *RuleType_Definition) GetEval() *RuleType_Definition_Eval { - if x != nil { - return x.Eval - } - return nil +// Deprecated: Use RuleType_Definition_Eval_JQComparison.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Eval_JQComparison) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 0} } -func (x *RuleType_Definition) GetRemediate() *RuleType_Definition_Remediate { +func (x *RuleType_Definition_Eval_JQComparison) GetIngested() *RuleType_Definition_Eval_JQComparison_Operator { if x != nil { - return x.Remediate + return x.Ingested } return nil } -func (x *RuleType_Definition) GetAlert() *RuleType_Definition_Alert { +func (x *RuleType_Definition_Eval_JQComparison) GetProfile() *RuleType_Definition_Eval_JQComparison_Operator { if x != nil { - return x.Alert + return x.Profile } return nil } -// Ingest defines how the data is ingested. -type RuleType_Definition_Ingest struct { +type RuleType_Definition_Eval_Rego struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // type is the type of the data ingestion. - // we currently support rest, artifact and builtin. + // type is the type of evaluation engine to use + // for rego. We currently have two modes of operation: + // - deny-by-default: this is the default mode of operation + // where we deny access by default and allow access only + // if the profile explicitly allows it. It expects the + // profile to set an `allow` variable to true or false. + // - constraints: this is the mode of operation where we + // allow access by default and deny access only if a + // violation is found. It expects the profile to set a + // `violations` variable with a "msg" field. Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - // rest is the rest data ingestion. - // this is only used if the type is rest. - Rest *RestType `protobuf:"bytes,3,opt,name=rest,proto3,oneof" json:"rest,omitempty"` - // builtin is the builtin data ingestion. - Builtin *BuiltinType `protobuf:"bytes,4,opt,name=builtin,proto3,oneof" json:"builtin,omitempty"` - // artifact is the artifact data ingestion. - Artifact *ArtifactType `protobuf:"bytes,5,opt,name=artifact,proto3,oneof" json:"artifact,omitempty"` - // git is the git data ingestion. - Git *GitType `protobuf:"bytes,6,opt,name=git,proto3,oneof" json:"git,omitempty"` - // diff is the diff data ingestion. - Diff *DiffType `protobuf:"bytes,7,opt,name=diff,proto3,oneof" json:"diff,omitempty"` + // def is the definition of the rego profile. + Def string `protobuf:"bytes,2,opt,name=def,proto3" json:"def,omitempty"` + // how are violations reported. This is only used if the + // `constraints` type is selected. The default is `text` + // which returns human-readable text. The other option is + // `json` which returns a JSON array containing the violations. + ViolationFormat *string `protobuf:"bytes,3,opt,name=violation_format,json=violationFormat,proto3,oneof" json:"violation_format,omitempty"` } -func (x *RuleType_Definition_Ingest) Reset() { - *x = RuleType_Definition_Ingest{} +func (x *RuleType_Definition_Eval_Rego) Reset() { + *x = RuleType_Definition_Eval_Rego{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11705,13 +11769,13 @@ func (x *RuleType_Definition_Ingest) Reset() { } } -func (x *RuleType_Definition_Ingest) String() string { +func (x *RuleType_Definition_Eval_Rego) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Ingest) ProtoMessage() {} +func (*RuleType_Definition_Eval_Rego) ProtoMessage() {} -func (x *RuleType_Definition_Ingest) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Eval_Rego) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[180] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11723,81 +11787,40 @@ func (x *RuleType_Definition_Ingest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Ingest.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Ingest) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 0} +// Deprecated: Use RuleType_Definition_Eval_Rego.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Eval_Rego) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 1} } -func (x *RuleType_Definition_Ingest) GetType() string { +func (x *RuleType_Definition_Eval_Rego) GetType() string { if x != nil { return x.Type } return "" } -func (x *RuleType_Definition_Ingest) GetRest() *RestType { - if x != nil { - return x.Rest - } - return nil -} - -func (x *RuleType_Definition_Ingest) GetBuiltin() *BuiltinType { - if x != nil { - return x.Builtin - } - return nil -} - -func (x *RuleType_Definition_Ingest) GetArtifact() *ArtifactType { - if x != nil { - return x.Artifact - } - return nil -} - -func (x *RuleType_Definition_Ingest) GetGit() *GitType { +func (x *RuleType_Definition_Eval_Rego) GetDef() string { if x != nil { - return x.Git + return x.Def } - return nil + return "" } -func (x *RuleType_Definition_Ingest) GetDiff() *DiffType { - if x != nil { - return x.Diff +func (x *RuleType_Definition_Eval_Rego) GetViolationFormat() string { + if x != nil && x.ViolationFormat != nil { + return *x.ViolationFormat } - return nil + return "" } -// Eval defines the data evaluation definition. -// This pertains to the way we traverse data from the upstream -// endpoint and how we compare it to the rule. -type RuleType_Definition_Eval struct { +type RuleType_Definition_Eval_Vulncheck struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - - // type is the type of the data evaluation. - // Right now only `jq` is supported as a driver - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - // jq is only used if the `jq` type is selected. - // It defines the comparisons that are made between - // the ingested data and the profile rule. - Jq []*RuleType_Definition_Eval_JQComparison `protobuf:"bytes,2,rep,name=jq,proto3" json:"jq,omitempty"` - // rego is only used if the `rego` type is selected. - Rego *RuleType_Definition_Eval_Rego `protobuf:"bytes,3,opt,name=rego,proto3,oneof" json:"rego,omitempty"` - // vulncheck is only used if the `vulncheck` type is selected. - Vulncheck *RuleType_Definition_Eval_Vulncheck `protobuf:"bytes,4,opt,name=vulncheck,proto3,oneof" json:"vulncheck,omitempty"` - // The trusty type is no longer used, but is still here for backwards - // compatibility with existing stored rules - Trusty *RuleType_Definition_Eval_Trusty `protobuf:"bytes,5,opt,name=trusty,proto3,oneof" json:"trusty,omitempty"` - // homoglyphs is only used if the `homoglyphs` type is selected. - Homoglyphs *RuleType_Definition_Eval_Homoglyphs `protobuf:"bytes,6,opt,name=homoglyphs,proto3,oneof" json:"homoglyphs,omitempty"` } -func (x *RuleType_Definition_Eval) Reset() { - *x = RuleType_Definition_Eval{} +func (x *RuleType_Definition_Eval_Vulncheck) Reset() { + *x = RuleType_Definition_Eval_Vulncheck{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11805,13 +11828,13 @@ func (x *RuleType_Definition_Eval) Reset() { } } -func (x *RuleType_Definition_Eval) String() string { +func (x *RuleType_Definition_Eval_Vulncheck) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Eval) ProtoMessage() {} +func (*RuleType_Definition_Eval_Vulncheck) ProtoMessage() {} -func (x *RuleType_Definition_Eval) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Eval_Vulncheck) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[181] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11823,66 +11846,23 @@ func (x *RuleType_Definition_Eval) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Eval.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Eval) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1} -} - -func (x *RuleType_Definition_Eval) GetType() string { - if x != nil { - return x.Type - } - return "" -} - -func (x *RuleType_Definition_Eval) GetJq() []*RuleType_Definition_Eval_JQComparison { - if x != nil { - return x.Jq - } - return nil -} - -func (x *RuleType_Definition_Eval) GetRego() *RuleType_Definition_Eval_Rego { - if x != nil { - return x.Rego - } - return nil -} - -func (x *RuleType_Definition_Eval) GetVulncheck() *RuleType_Definition_Eval_Vulncheck { - if x != nil { - return x.Vulncheck - } - return nil -} - -func (x *RuleType_Definition_Eval) GetTrusty() *RuleType_Definition_Eval_Trusty { - if x != nil { - return x.Trusty - } - return nil -} - -func (x *RuleType_Definition_Eval) GetHomoglyphs() *RuleType_Definition_Eval_Homoglyphs { - if x != nil { - return x.Homoglyphs - } - return nil +// Deprecated: Use RuleType_Definition_Eval_Vulncheck.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Eval_Vulncheck) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 2} } -type RuleType_Definition_Remediate struct { +type RuleType_Definition_Eval_Trusty struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - Rest *RestType `protobuf:"bytes,2,opt,name=rest,proto3,oneof" json:"rest,omitempty"` - GhBranchProtection *RuleType_Definition_Remediate_GhBranchProtectionType `protobuf:"bytes,3,opt,name=gh_branch_protection,json=ghBranchProtection,proto3,oneof" json:"gh_branch_protection,omitempty"` - PullRequest *RuleType_Definition_Remediate_PullRequestRemediation `protobuf:"bytes,4,opt,name=pull_request,json=pullRequest,proto3,oneof" json:"pull_request,omitempty"` + // This is no longer used, but is still here for backwards + // compatibility with existing stored rules + Endpoint string `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"` } -func (x *RuleType_Definition_Remediate) Reset() { - *x = RuleType_Definition_Remediate{} +func (x *RuleType_Definition_Eval_Trusty) Reset() { + *x = RuleType_Definition_Eval_Trusty{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11890,13 +11870,13 @@ func (x *RuleType_Definition_Remediate) Reset() { } } -func (x *RuleType_Definition_Remediate) String() string { +func (x *RuleType_Definition_Eval_Trusty) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Remediate) ProtoMessage() {} +func (*RuleType_Definition_Eval_Trusty) ProtoMessage() {} -func (x *RuleType_Definition_Remediate) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Eval_Trusty) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[182] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11908,50 +11888,28 @@ func (x *RuleType_Definition_Remediate) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Remediate.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Remediate) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2} +// Deprecated: Use RuleType_Definition_Eval_Trusty.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Eval_Trusty) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 3} } -func (x *RuleType_Definition_Remediate) GetType() string { +func (x *RuleType_Definition_Eval_Trusty) GetEndpoint() string { if x != nil { - return x.Type + return x.Endpoint } return "" } -func (x *RuleType_Definition_Remediate) GetRest() *RestType { - if x != nil { - return x.Rest - } - return nil -} - -func (x *RuleType_Definition_Remediate) GetGhBranchProtection() *RuleType_Definition_Remediate_GhBranchProtectionType { - if x != nil { - return x.GhBranchProtection - } - return nil -} - -func (x *RuleType_Definition_Remediate) GetPullRequest() *RuleType_Definition_Remediate_PullRequestRemediation { - if x != nil { - return x.PullRequest - } - return nil -} - -type RuleType_Definition_Alert struct { +type RuleType_Definition_Eval_Homoglyphs struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - SecurityAdvisory *RuleType_Definition_Alert_AlertTypeSA `protobuf:"bytes,2,opt,name=security_advisory,json=securityAdvisory,proto3,oneof" json:"security_advisory,omitempty"` + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` } -func (x *RuleType_Definition_Alert) Reset() { - *x = RuleType_Definition_Alert{} +func (x *RuleType_Definition_Eval_Homoglyphs) Reset() { + *x = RuleType_Definition_Eval_Homoglyphs{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11959,13 +11917,13 @@ func (x *RuleType_Definition_Alert) Reset() { } } -func (x *RuleType_Definition_Alert) String() string { +func (x *RuleType_Definition_Eval_Homoglyphs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Alert) ProtoMessage() {} +func (*RuleType_Definition_Eval_Homoglyphs) ProtoMessage() {} -func (x *RuleType_Definition_Alert) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Eval_Homoglyphs) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[183] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11977,38 +11935,28 @@ func (x *RuleType_Definition_Alert) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Alert.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Alert) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 3} +// Deprecated: Use RuleType_Definition_Eval_Homoglyphs.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Eval_Homoglyphs) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 4} } -func (x *RuleType_Definition_Alert) GetType() string { +func (x *RuleType_Definition_Eval_Homoglyphs) GetType() string { if x != nil { return x.Type } return "" } -func (x *RuleType_Definition_Alert) GetSecurityAdvisory() *RuleType_Definition_Alert_AlertTypeSA { - if x != nil { - return x.SecurityAdvisory - } - return nil -} - -type RuleType_Definition_Eval_JQComparison struct { +type RuleType_Definition_Eval_JQComparison_Operator struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // Ingested points to the data retrieved in the `ingest` section - Ingested *RuleType_Definition_Eval_JQComparison_Operator `protobuf:"bytes,1,opt,name=ingested,proto3" json:"ingested,omitempty"` - // Profile points to the profile itself. - Profile *RuleType_Definition_Eval_JQComparison_Operator `protobuf:"bytes,2,opt,name=profile,proto3" json:"profile,omitempty"` + Def string `protobuf:"bytes,1,opt,name=def,proto3" json:"def,omitempty"` } -func (x *RuleType_Definition_Eval_JQComparison) Reset() { - *x = RuleType_Definition_Eval_JQComparison{} +func (x *RuleType_Definition_Eval_JQComparison_Operator) Reset() { + *x = RuleType_Definition_Eval_JQComparison_Operator{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12016,13 +11964,13 @@ func (x *RuleType_Definition_Eval_JQComparison) Reset() { } } -func (x *RuleType_Definition_Eval_JQComparison) String() string { +func (x *RuleType_Definition_Eval_JQComparison_Operator) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Eval_JQComparison) ProtoMessage() {} +func (*RuleType_Definition_Eval_JQComparison_Operator) ProtoMessage() {} -func (x *RuleType_Definition_Eval_JQComparison) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Eval_JQComparison_Operator) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[184] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12034,52 +11982,28 @@ func (x *RuleType_Definition_Eval_JQComparison) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Eval_JQComparison.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Eval_JQComparison) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 0} -} - -func (x *RuleType_Definition_Eval_JQComparison) GetIngested() *RuleType_Definition_Eval_JQComparison_Operator { - if x != nil { - return x.Ingested - } - return nil +// Deprecated: Use RuleType_Definition_Eval_JQComparison_Operator.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Eval_JQComparison_Operator) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 0, 0} } -func (x *RuleType_Definition_Eval_JQComparison) GetProfile() *RuleType_Definition_Eval_JQComparison_Operator { +func (x *RuleType_Definition_Eval_JQComparison_Operator) GetDef() string { if x != nil { - return x.Profile + return x.Def } - return nil + return "" } -type RuleType_Definition_Eval_Rego struct { +type RuleType_Definition_Remediate_GhBranchProtectionType struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // type is the type of evaluation engine to use - // for rego. We currently have two modes of operation: - // - deny-by-default: this is the default mode of operation - // where we deny access by default and allow access only - // if the profile explicitly allows it. It expects the - // profile to set an `allow` variable to true or false. - // - constraints: this is the mode of operation where we - // allow access by default and deny access only if a - // violation is found. It expects the profile to set a - // `violations` variable with a "msg" field. - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - // def is the definition of the rego profile. - Def string `protobuf:"bytes,2,opt,name=def,proto3" json:"def,omitempty"` - // how are violations reported. This is only used if the - // `constraints` type is selected. The default is `text` - // which returns human-readable text. The other option is - // `json` which returns a JSON array containing the violations. - ViolationFormat *string `protobuf:"bytes,3,opt,name=violation_format,json=violationFormat,proto3,oneof" json:"violation_format,omitempty"` + Patch string `protobuf:"bytes,1,opt,name=patch,proto3" json:"patch,omitempty"` } -func (x *RuleType_Definition_Eval_Rego) Reset() { - *x = RuleType_Definition_Eval_Rego{} +func (x *RuleType_Definition_Remediate_GhBranchProtectionType) Reset() { + *x = RuleType_Definition_Remediate_GhBranchProtectionType{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[185] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12087,13 +12011,13 @@ func (x *RuleType_Definition_Eval_Rego) Reset() { } } -func (x *RuleType_Definition_Eval_Rego) String() string { +func (x *RuleType_Definition_Remediate_GhBranchProtectionType) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Eval_Rego) ProtoMessage() {} +func (*RuleType_Definition_Remediate_GhBranchProtectionType) ProtoMessage() {} -func (x *RuleType_Definition_Eval_Rego) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Remediate_GhBranchProtectionType) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[185] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12105,40 +12029,45 @@ func (x *RuleType_Definition_Eval_Rego) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Eval_Rego.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Eval_Rego) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 1} -} - -func (x *RuleType_Definition_Eval_Rego) GetType() string { - if x != nil { - return x.Type - } - return "" +// Deprecated: Use RuleType_Definition_Remediate_GhBranchProtectionType.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Remediate_GhBranchProtectionType) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 0} } -func (x *RuleType_Definition_Eval_Rego) GetDef() string { +func (x *RuleType_Definition_Remediate_GhBranchProtectionType) GetPatch() string { if x != nil { - return x.Def - } - return "" -} - -func (x *RuleType_Definition_Eval_Rego) GetViolationFormat() string { - if x != nil && x.ViolationFormat != nil { - return *x.ViolationFormat + return x.Patch } return "" } -type RuleType_Definition_Eval_Vulncheck struct { +// the name stutters a bit but we already use a PullRequest message for handling PR entities +type RuleType_Definition_Remediate_PullRequestRemediation struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields + + // the title of the PR + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + // the body of the PR + Body string `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"` + Contents []*RuleType_Definition_Remediate_PullRequestRemediation_Content `protobuf:"bytes,3,rep,name=contents,proto3" json:"contents,omitempty"` + // the method to use to create the PR. For now, these are supported: + // -- minder.content - ensures that the content of the file is exactly as specified + // + // refer to the Content message for more details + // + // -- minder.actions.replace_tags_with_sha - finds any github actions within a workflow + // + // file and replaces the tag with the SHA + Method string `protobuf:"bytes,4,opt,name=method,proto3" json:"method,omitempty"` + // If the method is minder.actions.replace_tags_with_sha, this is the configuration + // for that method + ActionsReplaceTagsWithSha *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha `protobuf:"bytes,5,opt,name=actions_replace_tags_with_sha,json=actionsReplaceTagsWithSha,proto3,oneof" json:"actions_replace_tags_with_sha,omitempty"` } -func (x *RuleType_Definition_Eval_Vulncheck) Reset() { - *x = RuleType_Definition_Eval_Vulncheck{} +func (x *RuleType_Definition_Remediate_PullRequestRemediation) Reset() { + *x = RuleType_Definition_Remediate_PullRequestRemediation{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[186] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12146,13 +12075,13 @@ func (x *RuleType_Definition_Eval_Vulncheck) Reset() { } } -func (x *RuleType_Definition_Eval_Vulncheck) String() string { +func (x *RuleType_Definition_Remediate_PullRequestRemediation) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Eval_Vulncheck) ProtoMessage() {} +func (*RuleType_Definition_Remediate_PullRequestRemediation) ProtoMessage() {} -func (x *RuleType_Definition_Eval_Vulncheck) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Remediate_PullRequestRemediation) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[186] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12164,23 +12093,66 @@ func (x *RuleType_Definition_Eval_Vulncheck) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Eval_Vulncheck.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Eval_Vulncheck) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 2} +// Deprecated: Use RuleType_Definition_Remediate_PullRequestRemediation.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Remediate_PullRequestRemediation) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 1} } -type RuleType_Definition_Eval_Trusty struct { +func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetBody() string { + if x != nil { + return x.Body + } + return "" +} + +func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetContents() []*RuleType_Definition_Remediate_PullRequestRemediation_Content { + if x != nil { + return x.Contents + } + return nil +} + +func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetMethod() string { + if x != nil { + return x.Method + } + return "" +} + +func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetActionsReplaceTagsWithSha() *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha { + if x != nil { + return x.ActionsReplaceTagsWithSha + } + return nil +} + +type RuleType_Definition_Remediate_PullRequestRemediation_Content struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // This is no longer used, but is still here for backwards - // compatibility with existing stored rules - Endpoint string `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"` + // the file to patch + Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + // how to patch the file. For now, only replace is supported + Action string `protobuf:"bytes,2,opt,name=action,proto3" json:"action,omitempty"` + // the content of the file + Content string `protobuf:"bytes,4,opt,name=content,proto3" json:"content,omitempty"` + // the GIT mode of the file. Not UNIX mode! String because the GH API also uses strings + // the usual modes are: 100644 for regular files, 100755 for executable files and + // 040000 for submodules (which we don't use but now you know the meaning of the 1 in 100644) + // see e.g. https://github.com/go-git/go-git/blob/32e0172851c35ae2fac495069c923330040903d2/plumbing/filemode/filemode.go#L16 + Mode *string `protobuf:"bytes,3,opt,name=mode,proto3,oneof" json:"mode,omitempty"` } -func (x *RuleType_Definition_Eval_Trusty) Reset() { - *x = RuleType_Definition_Eval_Trusty{} +func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) Reset() { + *x = RuleType_Definition_Remediate_PullRequestRemediation_Content{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[187] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12188,13 +12160,13 @@ func (x *RuleType_Definition_Eval_Trusty) Reset() { } } -func (x *RuleType_Definition_Eval_Trusty) String() string { +func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Eval_Trusty) ProtoMessage() {} +func (*RuleType_Definition_Remediate_PullRequestRemediation_Content) ProtoMessage() {} -func (x *RuleType_Definition_Eval_Trusty) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[187] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12206,28 +12178,50 @@ func (x *RuleType_Definition_Eval_Trusty) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Eval_Trusty.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Eval_Trusty) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 3} +// Deprecated: Use RuleType_Definition_Remediate_PullRequestRemediation_Content.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Remediate_PullRequestRemediation_Content) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 1, 0} } -func (x *RuleType_Definition_Eval_Trusty) GetEndpoint() string { +func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetPath() string { if x != nil { - return x.Endpoint + return x.Path } return "" } -type RuleType_Definition_Eval_Homoglyphs struct { +func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetAction() string { + if x != nil { + return x.Action + } + return "" +} + +func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetContent() string { + if x != nil { + return x.Content + } + return "" +} + +func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetMode() string { + if x != nil && x.Mode != nil { + return *x.Mode + } + return "" +} + +type RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + // List of actions to exclude from the replacement + Exclude []string `protobuf:"bytes,1,rep,name=exclude,proto3" json:"exclude,omitempty"` } -func (x *RuleType_Definition_Eval_Homoglyphs) Reset() { - *x = RuleType_Definition_Eval_Homoglyphs{} +func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) Reset() { + *x = RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[188] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12235,13 +12229,14 @@ func (x *RuleType_Definition_Eval_Homoglyphs) Reset() { } } -func (x *RuleType_Definition_Eval_Homoglyphs) String() string { +func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Eval_Homoglyphs) ProtoMessage() {} +func (*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) ProtoMessage() { +} -func (x *RuleType_Definition_Eval_Homoglyphs) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[188] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12253,28 +12248,28 @@ func (x *RuleType_Definition_Eval_Homoglyphs) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Eval_Homoglyphs.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Eval_Homoglyphs) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 4} +// Deprecated: Use RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 1, 1} } -func (x *RuleType_Definition_Eval_Homoglyphs) GetType() string { +func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) GetExclude() []string { if x != nil { - return x.Type + return x.Exclude } - return "" + return nil } -type RuleType_Definition_Eval_JQComparison_Operator struct { +type RuleType_Definition_Alert_AlertTypeSA struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Def string `protobuf:"bytes,1,opt,name=def,proto3" json:"def,omitempty"` + Severity string `protobuf:"bytes,1,opt,name=severity,proto3" json:"severity,omitempty"` } -func (x *RuleType_Definition_Eval_JQComparison_Operator) Reset() { - *x = RuleType_Definition_Eval_JQComparison_Operator{} +func (x *RuleType_Definition_Alert_AlertTypeSA) Reset() { + *x = RuleType_Definition_Alert_AlertTypeSA{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[189] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12282,13 +12277,13 @@ func (x *RuleType_Definition_Eval_JQComparison_Operator) Reset() { } } -func (x *RuleType_Definition_Eval_JQComparison_Operator) String() string { +func (x *RuleType_Definition_Alert_AlertTypeSA) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Eval_JQComparison_Operator) ProtoMessage() {} +func (*RuleType_Definition_Alert_AlertTypeSA) ProtoMessage() {} -func (x *RuleType_Definition_Eval_JQComparison_Operator) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Alert_AlertTypeSA) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[189] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12300,28 +12295,38 @@ func (x *RuleType_Definition_Eval_JQComparison_Operator) ProtoReflect() protoref return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Eval_JQComparison_Operator.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Eval_JQComparison_Operator) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 0, 0} +// Deprecated: Use RuleType_Definition_Alert_AlertTypeSA.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Alert_AlertTypeSA) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 3, 0} } -func (x *RuleType_Definition_Eval_JQComparison_Operator) GetDef() string { +func (x *RuleType_Definition_Alert_AlertTypeSA) GetSeverity() string { if x != nil { - return x.Def + return x.Severity } return "" } -type RuleType_Definition_Remediate_GhBranchProtectionType struct { +// Rule defines the individual call of a certain rule type. +type Profile_Rule struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Patch string `protobuf:"bytes,1,opt,name=patch,proto3" json:"patch,omitempty"` + // type is the type of the rule to be instantiated. + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + // params are the parameters that are passed to the rule. + // This is optional and depends on the rule type. + Params *structpb.Struct `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"` + // def is the definition of the rule. + // This depends on the rule type. + Def *structpb.Struct `protobuf:"bytes,3,opt,name=def,proto3" json:"def,omitempty"` + // name is the descriptive name of the rule, not to be confused with type + Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` } -func (x *RuleType_Definition_Remediate_GhBranchProtectionType) Reset() { - *x = RuleType_Definition_Remediate_GhBranchProtectionType{} +func (x *Profile_Rule) Reset() { + *x = Profile_Rule{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[190] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12329,13 +12334,13 @@ func (x *RuleType_Definition_Remediate_GhBranchProtectionType) Reset() { } } -func (x *RuleType_Definition_Remediate_GhBranchProtectionType) String() string { +func (x *Profile_Rule) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Remediate_GhBranchProtectionType) ProtoMessage() {} +func (*Profile_Rule) ProtoMessage() {} -func (x *RuleType_Definition_Remediate_GhBranchProtectionType) ProtoReflect() protoreflect.Message { +func (x *Profile_Rule) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[190] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12347,45 +12352,56 @@ func (x *RuleType_Definition_Remediate_GhBranchProtectionType) ProtoReflect() pr return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Remediate_GhBranchProtectionType.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Remediate_GhBranchProtectionType) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 0} +// Deprecated: Use Profile_Rule.ProtoReflect.Descriptor instead. +func (*Profile_Rule) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{107, 0} } -func (x *RuleType_Definition_Remediate_GhBranchProtectionType) GetPatch() string { +func (x *Profile_Rule) GetType() string { if x != nil { - return x.Patch + return x.Type } return "" } -// the name stutters a bit but we already use a PullRequest message for handling PR entities -type RuleType_Definition_Remediate_PullRequestRemediation struct { +func (x *Profile_Rule) GetParams() *structpb.Struct { + if x != nil { + return x.Params + } + return nil +} + +func (x *Profile_Rule) GetDef() *structpb.Struct { + if x != nil { + return x.Def + } + return nil +} + +func (x *Profile_Rule) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type Profile_Selector struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // the title of the PR - Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` - // the body of the PR - Body string `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"` - Contents []*RuleType_Definition_Remediate_PullRequestRemediation_Content `protobuf:"bytes,3,rep,name=contents,proto3" json:"contents,omitempty"` - // the method to use to create the PR. For now, these are supported: - // -- minder.content - ensures that the content of the file is exactly as specified - // - // refer to the Content message for more details - // - // -- minder.actions.replace_tags_with_sha - finds any github actions within a workflow - // - // file and replaces the tag with the SHA - Method string `protobuf:"bytes,4,opt,name=method,proto3" json:"method,omitempty"` - // If the method is minder.actions.replace_tags_with_sha, this is the configuration - // for that method - ActionsReplaceTagsWithSha *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha `protobuf:"bytes,5,opt,name=actions_replace_tags_with_sha,json=actionsReplaceTagsWithSha,proto3,oneof" json:"actions_replace_tags_with_sha,omitempty"` + // id is optional and use for updates to match upserts as well as read operations. It is ignored for creates. + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // entity is the entity to select. + Entity string `protobuf:"bytes,2,opt,name=entity,proto3" json:"entity,omitempty"` + // expr is the expression to select the entity. + Selector string `protobuf:"bytes,4,opt,name=selector,proto3" json:"selector,omitempty"` + // description is the human-readable description of the selector. + Comment string `protobuf:"bytes,5,opt,name=comment,proto3" json:"comment,omitempty"` } -func (x *RuleType_Definition_Remediate_PullRequestRemediation) Reset() { - *x = RuleType_Definition_Remediate_PullRequestRemediation{} +func (x *Profile_Selector) Reset() { + *x = Profile_Selector{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[191] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12393,13 +12409,13 @@ func (x *RuleType_Definition_Remediate_PullRequestRemediation) Reset() { } } -func (x *RuleType_Definition_Remediate_PullRequestRemediation) String() string { +func (x *Profile_Selector) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Remediate_PullRequestRemediation) ProtoMessage() {} +func (*Profile_Selector) ProtoMessage() {} -func (x *RuleType_Definition_Remediate_PullRequestRemediation) ProtoReflect() protoreflect.Message { +func (x *Profile_Selector) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[191] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12411,66 +12427,54 @@ func (x *RuleType_Definition_Remediate_PullRequestRemediation) ProtoReflect() pr return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Remediate_PullRequestRemediation.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Remediate_PullRequestRemediation) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 1} +// Deprecated: Use Profile_Selector.ProtoReflect.Descriptor instead. +func (*Profile_Selector) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{107, 1} } -func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetTitle() string { +func (x *Profile_Selector) GetId() string { if x != nil { - return x.Title + return x.Id } return "" } -func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetBody() string { +func (x *Profile_Selector) GetEntity() string { if x != nil { - return x.Body + return x.Entity } return "" } -func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetContents() []*RuleType_Definition_Remediate_PullRequestRemediation_Content { - if x != nil { - return x.Contents - } - return nil -} - -func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetMethod() string { +func (x *Profile_Selector) GetSelector() string { if x != nil { - return x.Method + return x.Selector } return "" } -func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetActionsReplaceTagsWithSha() *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha { +func (x *Profile_Selector) GetComment() string { if x != nil { - return x.ActionsReplaceTagsWithSha + return x.Comment } - return nil + return "" } -type RuleType_Definition_Remediate_PullRequestRemediation_Content struct { +type EvaluationHistory_Entity struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // the file to patch - Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` - // how to patch the file. For now, only replace is supported - Action string `protobuf:"bytes,2,opt,name=action,proto3" json:"action,omitempty"` - // the content of the file - Content string `protobuf:"bytes,4,opt,name=content,proto3" json:"content,omitempty"` - // the GIT mode of the file. Not UNIX mode! String because the GH API also uses strings - // the usual modes are: 100644 for regular files, 100755 for executable files and - // 040000 for submodules (which we don't use but now you know the meaning of the 1 in 100644) - // see e.g. https://github.com/go-git/go-git/blob/32e0172851c35ae2fac495069c923330040903d2/plumbing/filemode/filemode.go#L16 - Mode *string `protobuf:"bytes,3,opt,name=mode,proto3,oneof" json:"mode,omitempty"` + // id is the ID of the entity. + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // type is the entity type. + Type Entity `protobuf:"varint,2,opt,name=type,proto3,enum=minder.v1.Entity" json:"type,omitempty"` + // name is the entity name. + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` } -func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) Reset() { - *x = RuleType_Definition_Remediate_PullRequestRemediation_Content{} +func (x *EvaluationHistory_Entity) Reset() { + *x = EvaluationHistory_Entity{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[192] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12478,13 +12482,13 @@ func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) Reset() { } } -func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) String() string { +func (x *EvaluationHistory_Entity) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Remediate_PullRequestRemediation_Content) ProtoMessage() {} +func (*EvaluationHistory_Entity) ProtoMessage() {} -func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) ProtoReflect() protoreflect.Message { +func (x *EvaluationHistory_Entity) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[192] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12496,50 +12500,47 @@ func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) ProtoRefl return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Remediate_PullRequestRemediation_Content.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Remediate_PullRequestRemediation_Content) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 1, 0} +// Deprecated: Use EvaluationHistory_Entity.ProtoReflect.Descriptor instead. +func (*EvaluationHistory_Entity) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{162, 0} } -func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetPath() string { +func (x *EvaluationHistory_Entity) GetId() string { if x != nil { - return x.Path + return x.Id } return "" } -func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetAction() string { +func (x *EvaluationHistory_Entity) GetType() Entity { if x != nil { - return x.Action + return x.Type } - return "" + return Entity_ENTITY_UNSPECIFIED } -func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetContent() string { +func (x *EvaluationHistory_Entity) GetName() string { if x != nil { - return x.Content - } - return "" -} - -func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetMode() string { - if x != nil && x.Mode != nil { - return *x.Mode + return x.Name } return "" } -type RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha struct { +type EvaluationHistory_Rule struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // List of actions to exclude from the replacement - Exclude []string `protobuf:"bytes,1,rep,name=exclude,proto3" json:"exclude,omitempty"` + // name is the name of the rule instance. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // type is the name of the rule type. + Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"` + // profile is the name of the profile which contains the rule. + Profile string `protobuf:"bytes,3,opt,name=profile,proto3" json:"profile,omitempty"` } -func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) Reset() { - *x = RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha{} +func (x *EvaluationHistory_Rule) Reset() { + *x = EvaluationHistory_Rule{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[193] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12547,14 +12548,13 @@ func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTags } } -func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) String() string { +func (x *EvaluationHistory_Rule) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) ProtoMessage() { -} +func (*EvaluationHistory_Rule) ProtoMessage() {} -func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) ProtoReflect() protoreflect.Message { +func (x *EvaluationHistory_Rule) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[193] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12566,28 +12566,49 @@ func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTags return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 1, 1} +// Deprecated: Use EvaluationHistory_Rule.ProtoReflect.Descriptor instead. +func (*EvaluationHistory_Rule) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{162, 1} } -func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) GetExclude() []string { +func (x *EvaluationHistory_Rule) GetName() string { if x != nil { - return x.Exclude + return x.Name } - return nil + return "" } -type RuleType_Definition_Alert_AlertTypeSA struct { +func (x *EvaluationHistory_Rule) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *EvaluationHistory_Rule) GetProfile() string { + if x != nil { + return x.Profile + } + return "" +} + +type EvaluationHistory_Status struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Severity string `protobuf:"bytes,1,opt,name=severity,proto3" json:"severity,omitempty"` + // status is one of (success, error, failure, skipped) + // not using enums to mirror the behaviour of the existing API contracts. + Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + // details contains optional details about the evaluation. + // the structure and contents are rule type specific, and are subject to change. + Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"` + // created_at is the timestamp of creation of this evaluation + EvaluatedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=evaluated_at,json=evaluatedAt,proto3" json:"evaluated_at,omitempty"` } -func (x *RuleType_Definition_Alert_AlertTypeSA) Reset() { - *x = RuleType_Definition_Alert_AlertTypeSA{} +func (x *EvaluationHistory_Status) Reset() { + *x = EvaluationHistory_Status{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[194] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12595,13 +12616,13 @@ func (x *RuleType_Definition_Alert_AlertTypeSA) Reset() { } } -func (x *RuleType_Definition_Alert_AlertTypeSA) String() string { +func (x *EvaluationHistory_Status) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Alert_AlertTypeSA) ProtoMessage() {} +func (*EvaluationHistory_Status) ProtoMessage() {} -func (x *RuleType_Definition_Alert_AlertTypeSA) ProtoReflect() protoreflect.Message { +func (x *EvaluationHistory_Status) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[194] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12613,38 +12634,47 @@ func (x *RuleType_Definition_Alert_AlertTypeSA) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Alert_AlertTypeSA.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Alert_AlertTypeSA) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 3, 0} +// Deprecated: Use EvaluationHistory_Status.ProtoReflect.Descriptor instead. +func (*EvaluationHistory_Status) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{162, 2} } -func (x *RuleType_Definition_Alert_AlertTypeSA) GetSeverity() string { +func (x *EvaluationHistory_Status) GetStatus() string { if x != nil { - return x.Severity + return x.Status } return "" } -// Rule defines the individual call of a certain rule type. -type Profile_Rule struct { +func (x *EvaluationHistory_Status) GetDetails() string { + if x != nil { + return x.Details + } + return "" +} + +func (x *EvaluationHistory_Status) GetEvaluatedAt() *timestamppb.Timestamp { + if x != nil { + return x.EvaluatedAt + } + return nil +} + +type EvaluationHistory_Remediation struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // type is the type of the rule to be instantiated. - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - // params are the parameters that are passed to the rule. - // This is optional and depends on the rule type. - Params *structpb.Struct `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"` - // def is the definition of the rule. - // This depends on the rule type. - Def *structpb.Struct `protobuf:"bytes,3,opt,name=def,proto3" json:"def,omitempty"` - // name is the descriptive name of the rule, not to be confused with type - Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` + // status is one of (success, error, failure, skipped, not available) + // not using enums to mirror the behaviour of the existing API contracts. + Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + // details contains optional details about the remediation. + // the structure and contents are remediation specific, and are subject to change. + Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"` } -func (x *Profile_Rule) Reset() { - *x = Profile_Rule{} +func (x *EvaluationHistory_Remediation) Reset() { + *x = EvaluationHistory_Remediation{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[195] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12652,13 +12682,13 @@ func (x *Profile_Rule) Reset() { } } -func (x *Profile_Rule) String() string { +func (x *EvaluationHistory_Remediation) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Profile_Rule) ProtoMessage() {} +func (*EvaluationHistory_Remediation) ProtoMessage() {} -func (x *Profile_Rule) ProtoReflect() protoreflect.Message { +func (x *EvaluationHistory_Remediation) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[195] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12670,56 +12700,40 @@ func (x *Profile_Rule) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Profile_Rule.ProtoReflect.Descriptor instead. -func (*Profile_Rule) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{107, 0} +// Deprecated: Use EvaluationHistory_Remediation.ProtoReflect.Descriptor instead. +func (*EvaluationHistory_Remediation) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{162, 3} } -func (x *Profile_Rule) GetType() string { +func (x *EvaluationHistory_Remediation) GetStatus() string { if x != nil { - return x.Type + return x.Status } return "" } -func (x *Profile_Rule) GetParams() *structpb.Struct { - if x != nil { - return x.Params - } - return nil -} - -func (x *Profile_Rule) GetDef() *structpb.Struct { - if x != nil { - return x.Def - } - return nil -} - -func (x *Profile_Rule) GetName() string { +func (x *EvaluationHistory_Remediation) GetDetails() string { if x != nil { - return x.Name + return x.Details } return "" } -type Profile_Selector struct { +type EvaluationHistory_Alert struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // id is optional and use for updates to match upserts as well as read operations. It is ignored for creates. - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - // entity is the entity to select. - Entity string `protobuf:"bytes,2,opt,name=entity,proto3" json:"entity,omitempty"` - // expr is the expression to select the entity. - Selector string `protobuf:"bytes,4,opt,name=selector,proto3" json:"selector,omitempty"` - // description is the human-readable description of the selector. - Comment string `protobuf:"bytes,5,opt,name=comment,proto3" json:"comment,omitempty"` + // status is one of (on, off, error, skipped, not available) + // not using enums to mirror the behaviour of the existing API contracts. + Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + // details contains optional details about the alert. + // the structure and contents are alert specific, and are subject to change. + Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"` } -func (x *Profile_Selector) Reset() { - *x = Profile_Selector{} +func (x *EvaluationHistory_Alert) Reset() { + *x = EvaluationHistory_Alert{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[196] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12727,13 +12741,13 @@ func (x *Profile_Selector) Reset() { } } -func (x *Profile_Selector) String() string { +func (x *EvaluationHistory_Alert) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Profile_Selector) ProtoMessage() {} +func (*EvaluationHistory_Alert) ProtoMessage() {} -func (x *Profile_Selector) ProtoReflect() protoreflect.Message { +func (x *EvaluationHistory_Alert) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[196] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12745,35 +12759,21 @@ func (x *Profile_Selector) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Profile_Selector.ProtoReflect.Descriptor instead. -func (*Profile_Selector) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{107, 1} -} - -func (x *Profile_Selector) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *Profile_Selector) GetEntity() string { - if x != nil { - return x.Entity - } - return "" +// Deprecated: Use EvaluationHistory_Alert.ProtoReflect.Descriptor instead. +func (*EvaluationHistory_Alert) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{162, 4} } -func (x *Profile_Selector) GetSelector() string { +func (x *EvaluationHistory_Alert) GetStatus() string { if x != nil { - return x.Selector + return x.Status } return "" } -func (x *Profile_Selector) GetComment() string { +func (x *EvaluationHistory_Alert) GetDetails() string { if x != nil { - return x.Comment + return x.Details } return "" } @@ -14371,804 +14371,799 @@ var file_minder_v1_minder_proto_rawDesc = []byte{ 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x29, 0x0a, 0x04, 0x70, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x75, - 0x72, 0x73, 0x6f, 0x72, 0x50, 0x61, 0x67, 0x65, 0x52, 0x04, 0x70, 0x61, 0x67, 0x65, 0x22, 0xc5, - 0x02, 0x0a, 0x11, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, - 0x74, 0x6f, 0x72, 0x79, 0x12, 0x3a, 0x0a, 0x06, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x18, 0x01, + 0x72, 0x73, 0x6f, 0x72, 0x50, 0x61, 0x67, 0x65, 0x52, 0x04, 0x70, 0x61, 0x67, 0x65, 0x22, 0xe0, + 0x05, 0x0a, 0x11, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, + 0x74, 0x6f, 0x72, 0x79, 0x12, 0x3b, 0x0a, 0x06, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, + 0x72, 0x79, 0x2e, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x06, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x12, 0x35, 0x0a, 0x04, 0x72, 0x75, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x61, 0x6c, + 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x2e, 0x52, 0x75, + 0x6c, 0x65, 0x52, 0x04, 0x72, 0x75, 0x6c, 0x65, 0x12, 0x3b, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, + 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x38, 0x0a, 0x05, 0x61, 0x6c, 0x65, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, - 0x72, 0x79, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x06, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, - 0x12, 0x34, 0x0a, 0x04, 0x72, 0x75, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, - 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x61, 0x6c, 0x75, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x75, 0x6c, 0x65, - 0x52, 0x04, 0x72, 0x75, 0x6c, 0x65, 0x12, 0x3a, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, - 0x74, 0x6f, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x12, 0x37, 0x0a, 0x05, 0x61, 0x6c, 0x65, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, - 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x41, - 0x6c, 0x65, 0x72, 0x74, 0x52, 0x05, 0x61, 0x6c, 0x65, 0x72, 0x74, 0x12, 0x49, 0x0a, 0x0b, 0x72, - 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x61, - 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, - 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x72, 0x65, 0x6d, 0x65, 0x64, - 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x64, 0x0a, 0x17, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x45, 0x6e, 0x74, 0x69, 0x74, - 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, - 0x64, 0x12, 0x25, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, - 0x11, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x74, 0x69, - 0x74, 0x79, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x59, 0x0a, 0x15, - 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, - 0x79, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, - 0x07, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, - 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x22, 0x8a, 0x01, 0x0a, 0x17, 0x45, 0x76, 0x61, 0x6c, - 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x53, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x64, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, - 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x3d, 0x0a, 0x0c, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, - 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, - 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, - 0x65, 0x64, 0x41, 0x74, 0x22, 0x50, 0x0a, 0x1c, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, + 0x72, 0x79, 0x2e, 0x41, 0x6c, 0x65, 0x72, 0x74, 0x52, 0x05, 0x61, 0x6c, 0x65, 0x72, 0x74, 0x12, + 0x4a, 0x0a, 0x0b, 0x72, 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, + 0x72, 0x79, 0x2e, 0x52, 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, + 0x72, 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x53, 0x0a, 0x06, 0x45, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x25, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x1a, 0x48, 0x0a, 0x04, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, + 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, + 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x1a, 0x79, 0x0a, 0x06, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, + 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x3d, 0x0a, 0x0c, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, + 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, + 0x74, 0x65, 0x64, 0x41, 0x74, 0x1a, 0x3f, 0x0a, 0x0b, 0x52, 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x4a, 0x0a, 0x16, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x41, 0x6c, 0x65, 0x72, 0x74, - 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, - 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, - 0x6c, 0x73, 0x2a, 0x62, 0x0a, 0x0b, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4f, 0x77, 0x6e, 0x65, - 0x72, 0x12, 0x1c, 0x0a, 0x18, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, - 0x52, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, - 0x18, 0x0a, 0x14, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, 0x52, 0x5f, - 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x10, 0x02, 0x12, 0x15, 0x0a, 0x11, 0x4f, 0x42, 0x4a, - 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, 0x52, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x10, 0x03, - 0x22, 0x04, 0x08, 0x01, 0x10, 0x01, 0x2a, 0x95, 0x0e, 0x0a, 0x08, 0x52, 0x65, 0x6c, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, - 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1f, 0x0a, - 0x0f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, - 0x10, 0x01, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x19, - 0x0a, 0x0c, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x02, - 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x67, 0x65, 0x74, 0x12, 0x1f, 0x0a, 0x0f, 0x52, 0x45, 0x4c, - 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x03, 0x1a, 0x0a, - 0xea, 0xdc, 0x14, 0x06, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0f, 0x52, 0x45, - 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x04, 0x1a, - 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, 0x52, - 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x4c, 0x49, 0x53, - 0x54, 0x10, 0x05, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6c, 0x69, - 0x73, 0x74, 0x12, 0x3b, 0x0a, 0x1d, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, - 0x4f, 0x4c, 0x45, 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x4c, - 0x49, 0x53, 0x54, 0x10, 0x06, 0x1a, 0x18, 0xea, 0xdc, 0x14, 0x14, 0x72, 0x6f, 0x6c, 0x65, 0x5f, - 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x12, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x1a, 0x39, 0x0a, 0x05, 0x41, 0x6c, 0x65, 0x72, 0x74, 0x12, + 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x2a, 0x62, 0x0a, 0x0b, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4f, 0x77, 0x6e, 0x65, 0x72, + 0x12, 0x1c, 0x0a, 0x18, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, 0x52, + 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x18, + 0x0a, 0x14, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, 0x52, 0x5f, 0x50, + 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x10, 0x02, 0x12, 0x15, 0x0a, 0x11, 0x4f, 0x42, 0x4a, 0x45, + 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, 0x52, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x10, 0x03, 0x22, + 0x04, 0x08, 0x01, 0x10, 0x01, 0x2a, 0x95, 0x0e, 0x0a, 0x08, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, + 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1f, 0x0a, 0x0f, + 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, + 0x01, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, + 0x0c, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x02, 0x1a, + 0x07, 0xea, 0xdc, 0x14, 0x03, 0x67, 0x65, 0x74, 0x12, 0x1f, 0x0a, 0x0f, 0x52, 0x45, 0x4c, 0x41, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x03, 0x1a, 0x0a, 0xea, + 0xdc, 0x14, 0x06, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0f, 0x52, 0x45, 0x4c, + 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x04, 0x1a, 0x0a, + 0xea, 0xdc, 0x14, 0x06, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, 0x52, 0x45, + 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x4c, 0x49, 0x53, 0x54, + 0x10, 0x05, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6c, 0x69, 0x73, + 0x74, 0x12, 0x3b, 0x0a, 0x1d, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, + 0x4c, 0x45, 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x4c, 0x49, + 0x53, 0x54, 0x10, 0x06, 0x1a, 0x18, 0xea, 0xdc, 0x14, 0x14, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, + 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x12, 0x3f, + 0x0a, 0x1f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, + 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, + 0x45, 0x10, 0x07, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, 0x73, + 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x3f, 0x0a, 0x1f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, - 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x41, - 0x54, 0x45, 0x10, 0x07, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, - 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, - 0x12, 0x3f, 0x0a, 0x1f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, - 0x45, 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x52, 0x45, 0x4d, - 0x4f, 0x56, 0x45, 0x10, 0x08, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, - 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x6d, 0x6f, 0x76, - 0x65, 0x12, 0x23, 0x0a, 0x11, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, - 0x50, 0x4f, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x09, 0x1a, 0x0c, 0xea, 0xdc, 0x14, 0x08, 0x72, 0x65, - 0x70, 0x6f, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, - 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x0a, - 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, - 0x65, 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, - 0x50, 0x4f, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x0b, 0x1a, 0x0f, 0xea, 0xdc, 0x14, - 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x14, - 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x44, 0x45, - 0x4c, 0x45, 0x54, 0x45, 0x10, 0x0c, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, 0x70, 0x6f, - 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x15, 0x52, 0x45, 0x4c, 0x41, 0x54, - 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x47, 0x45, 0x54, - 0x10, 0x0d, 0x1a, 0x10, 0xea, 0xdc, 0x14, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, - 0x5f, 0x67, 0x65, 0x74, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, - 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, - 0x10, 0x0e, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, - 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, - 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x55, 0x50, 0x44, - 0x41, 0x54, 0x45, 0x10, 0x0f, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, 0x74, 0x69, 0x66, - 0x61, 0x63, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, - 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, - 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x10, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, - 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1f, 0x0a, - 0x0f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x47, 0x45, 0x54, - 0x10, 0x11, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x70, 0x72, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x25, - 0x0a, 0x12, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x43, 0x52, - 0x45, 0x41, 0x54, 0x45, 0x10, 0x12, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x70, 0x72, 0x5f, 0x63, - 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, - 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x13, 0x1a, 0x0d, 0xea, - 0xdc, 0x14, 0x09, 0x70, 0x72, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, - 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x44, 0x45, 0x4c, 0x45, - 0x54, 0x45, 0x10, 0x14, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x70, 0x72, 0x5f, 0x64, 0x65, 0x6c, - 0x65, 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x15, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, - 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x15, 0x1a, 0x10, - 0xea, 0xdc, 0x14, 0x0c, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x67, 0x65, 0x74, - 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, - 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x16, 0x1a, 0x13, - 0xea, 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x72, 0x65, - 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, - 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, - 0x17, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, - 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, - 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x44, 0x45, 0x4c, 0x45, - 0x54, 0x45, 0x10, 0x18, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x2d, 0x0a, 0x16, 0x52, 0x45, 0x4c, - 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, - 0x47, 0x45, 0x54, 0x10, 0x19, 0x1a, 0x11, 0xea, 0xdc, 0x14, 0x0d, 0x72, 0x75, 0x6c, 0x65, 0x5f, - 0x74, 0x79, 0x70, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, - 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, - 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x1a, 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x72, 0x75, 0x6c, - 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x33, 0x0a, - 0x19, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, - 0x59, 0x50, 0x45, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x1b, 0x1a, 0x14, 0xea, 0xdc, - 0x14, 0x10, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x70, 0x64, 0x61, - 0x74, 0x65, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, - 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, - 0x1c, 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, - 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, - 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x47, 0x45, 0x54, 0x10, - 0x1d, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x67, - 0x65, 0x74, 0x12, 0x2f, 0x0a, 0x17, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, - 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x1e, 0x1a, - 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x63, 0x72, 0x65, + 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x52, 0x45, 0x4d, 0x4f, + 0x56, 0x45, 0x10, 0x08, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, + 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, + 0x12, 0x23, 0x0a, 0x11, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x50, + 0x4f, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x09, 0x1a, 0x0c, 0xea, 0xdc, 0x14, 0x08, 0x72, 0x65, 0x70, + 0x6f, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, + 0x4e, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x0a, 0x1a, + 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x50, + 0x4f, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x0b, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, + 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x14, 0x52, + 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x44, 0x45, 0x4c, + 0x45, 0x54, 0x45, 0x10, 0x0c, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x5f, + 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x15, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x47, 0x45, 0x54, 0x10, + 0x0d, 0x1a, 0x10, 0xea, 0xdc, 0x14, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, + 0x67, 0x65, 0x74, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, + 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, + 0x0e, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x55, 0x50, 0x44, 0x41, + 0x54, 0x45, 0x10, 0x0f, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, + 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x44, + 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x10, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0f, + 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x47, 0x45, 0x54, 0x10, + 0x11, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x70, 0x72, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x25, 0x0a, + 0x12, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x43, 0x52, 0x45, + 0x41, 0x54, 0x45, 0x10, 0x12, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x70, 0x72, 0x5f, 0x63, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, + 0x5f, 0x50, 0x52, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x13, 0x1a, 0x0d, 0xea, 0xdc, + 0x14, 0x09, 0x70, 0x72, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, 0x52, + 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, + 0x45, 0x10, 0x14, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x70, 0x72, 0x5f, 0x64, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x15, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, + 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x15, 0x1a, 0x10, 0xea, + 0xdc, 0x14, 0x0c, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x67, 0x65, 0x74, 0x12, + 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x56, + 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x16, 0x1a, 0x13, 0xea, + 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, + 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x17, + 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, + 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, + 0x45, 0x10, 0x18, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x72, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x2d, 0x0a, 0x16, 0x52, 0x45, 0x4c, 0x41, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x47, + 0x45, 0x54, 0x10, 0x19, 0x1a, 0x11, 0xea, 0xdc, 0x14, 0x0d, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, 0x54, + 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x52, + 0x45, 0x41, 0x54, 0x45, 0x10, 0x1a, 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x72, 0x75, 0x6c, 0x65, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x33, 0x0a, 0x19, + 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, + 0x50, 0x45, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x1b, 0x1a, 0x14, 0xea, 0xdc, 0x14, + 0x10, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, + 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x1c, + 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, + 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x1d, + 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x67, 0x65, + 0x74, 0x12, 0x2f, 0x0a, 0x17, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, + 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x1e, 0x1a, 0x12, + 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x12, 0x2f, 0x0a, 0x17, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, + 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x1f, 0x1a, + 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x2f, 0x0a, 0x17, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, - 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x1f, - 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x75, 0x70, - 0x64, 0x61, 0x74, 0x65, 0x12, 0x2f, 0x0a, 0x17, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, - 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, - 0x20, 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x64, - 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x37, 0x0a, 0x1b, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, - 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, - 0x5f, 0x47, 0x45, 0x54, 0x10, 0x21, 0x1a, 0x16, 0xea, 0xdc, 0x14, 0x12, 0x70, 0x72, 0x6f, 0x66, - 0x69, 0x6c, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x31, - 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x4d, 0x4f, 0x54, - 0x45, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x22, 0x1a, 0x13, 0xea, 0xdc, - 0x14, 0x0f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x67, 0x65, - 0x74, 0x12, 0x55, 0x0a, 0x2a, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x4e, - 0x54, 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x43, 0x4f, 0x4e, 0x43, 0x49, 0x4c, 0x49, 0x41, 0x54, - 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x41, 0x53, 0x4b, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, - 0x23, 0x1a, 0x25, 0xea, 0xdc, 0x14, 0x21, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x72, 0x65, - 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x61, 0x73, - 0x6b, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, - 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x43, 0x4f, - 0x4e, 0x43, 0x49, 0x4c, 0x45, 0x10, 0x24, 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x65, 0x6e, 0x74, - 0x69, 0x74, 0x79, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x12, 0x3f, 0x0a, - 0x1f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x41, - 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, - 0x10, 0x25, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, 0x73, 0x73, - 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2a, 0x82, - 0x01, 0x0a, 0x0e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x12, 0x1f, 0x0a, 0x1b, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, 0x4f, - 0x55, 0x52, 0x43, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, - 0x10, 0x00, 0x12, 0x18, 0x0a, 0x14, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, - 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x01, 0x12, 0x18, 0x0a, 0x14, - 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, - 0x55, 0x53, 0x45, 0x52, 0x10, 0x02, 0x12, 0x1b, 0x0a, 0x17, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, - 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, - 0x54, 0x10, 0x03, 0x2a, 0x72, 0x0a, 0x0c, 0x44, 0x65, 0x70, 0x45, 0x63, 0x6f, 0x73, 0x79, 0x73, - 0x74, 0x65, 0x6d, 0x12, 0x1d, 0x0a, 0x19, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, - 0x53, 0x54, 0x45, 0x4d, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, - 0x10, 0x00, 0x12, 0x15, 0x0a, 0x11, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, - 0x54, 0x45, 0x4d, 0x5f, 0x4e, 0x50, 0x4d, 0x10, 0x01, 0x12, 0x14, 0x0a, 0x10, 0x44, 0x45, 0x50, - 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x5f, 0x47, 0x4f, 0x10, 0x02, 0x12, - 0x16, 0x0a, 0x12, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, - 0x5f, 0x50, 0x59, 0x50, 0x49, 0x10, 0x03, 0x2a, 0x88, 0x01, 0x0a, 0x06, 0x45, 0x6e, 0x74, 0x69, - 0x74, 0x79, 0x12, 0x16, 0x0a, 0x12, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x55, 0x4e, 0x53, - 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x45, 0x4e, - 0x54, 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x53, 0x49, 0x54, 0x4f, 0x52, 0x49, 0x45, - 0x53, 0x10, 0x01, 0x12, 0x1d, 0x0a, 0x19, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x42, 0x55, - 0x49, 0x4c, 0x44, 0x5f, 0x45, 0x4e, 0x56, 0x49, 0x52, 0x4f, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x53, - 0x10, 0x02, 0x12, 0x14, 0x0a, 0x10, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x41, 0x52, 0x54, - 0x49, 0x46, 0x41, 0x43, 0x54, 0x53, 0x10, 0x03, 0x12, 0x18, 0x0a, 0x14, 0x45, 0x4e, 0x54, 0x49, - 0x54, 0x59, 0x5f, 0x50, 0x55, 0x4c, 0x4c, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x45, 0x53, 0x54, 0x53, - 0x10, 0x04, 0x2a, 0x97, 0x02, 0x0a, 0x0c, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, - 0x79, 0x70, 0x65, 0x12, 0x1d, 0x0a, 0x19, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, - 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, - 0x10, 0x00, 0x12, 0x24, 0x0a, 0x14, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, - 0x59, 0x50, 0x45, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x10, 0x01, 0x1a, 0x0a, 0xea, 0xdc, - 0x14, 0x06, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x12, 0x20, 0x0a, 0x12, 0x50, 0x52, 0x4f, 0x56, - 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x52, 0x45, 0x53, 0x54, 0x10, 0x02, - 0x1a, 0x08, 0xea, 0xdc, 0x14, 0x04, 0x72, 0x65, 0x73, 0x74, 0x12, 0x1e, 0x0a, 0x11, 0x50, 0x52, - 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x47, 0x49, 0x54, 0x10, - 0x03, 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x67, 0x69, 0x74, 0x12, 0x1e, 0x0a, 0x11, 0x50, 0x52, - 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4f, 0x43, 0x49, 0x10, - 0x04, 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x6f, 0x63, 0x69, 0x12, 0x2e, 0x0a, 0x19, 0x50, 0x52, - 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x52, 0x45, 0x50, 0x4f, - 0x5f, 0x4c, 0x49, 0x53, 0x54, 0x45, 0x52, 0x10, 0x05, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, - 0x65, 0x70, 0x6f, 0x2d, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x72, 0x12, 0x30, 0x0a, 0x1a, 0x50, 0x52, - 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4d, 0x41, 0x47, - 0x45, 0x5f, 0x4c, 0x49, 0x53, 0x54, 0x45, 0x52, 0x10, 0x06, 0x1a, 0x10, 0xea, 0xdc, 0x14, 0x0c, - 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2d, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x72, 0x2a, 0xd5, 0x01, 0x0a, - 0x0d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x1e, - 0x0a, 0x1a, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, - 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x25, - 0x0a, 0x15, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, - 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x10, 0x01, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x67, - 0x69, 0x74, 0x68, 0x75, 0x62, 0x12, 0x2d, 0x0a, 0x19, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, - 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x5f, 0x41, - 0x50, 0x50, 0x10, 0x02, 0x1a, 0x0e, 0xea, 0xdc, 0x14, 0x0a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, - 0x2d, 0x61, 0x70, 0x70, 0x12, 0x21, 0x0a, 0x13, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, - 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x47, 0x48, 0x43, 0x52, 0x10, 0x03, 0x1a, 0x08, 0xea, - 0xdc, 0x14, 0x04, 0x67, 0x68, 0x63, 0x72, 0x12, 0x2b, 0x0a, 0x18, 0x50, 0x52, 0x4f, 0x56, 0x49, - 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x44, 0x4f, 0x43, 0x4b, 0x45, 0x52, - 0x48, 0x55, 0x42, 0x10, 0x04, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x64, 0x6f, 0x63, 0x6b, 0x65, - 0x72, 0x68, 0x75, 0x62, 0x2a, 0xa9, 0x02, 0x0a, 0x11, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, - 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x6c, 0x6f, 0x77, 0x12, 0x22, 0x0a, 0x1e, 0x41, 0x55, - 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, - 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x25, - 0x0a, 0x17, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, - 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x01, 0x1a, 0x08, 0xea, 0xdc, 0x14, - 0x04, 0x6e, 0x6f, 0x6e, 0x65, 0x12, 0x31, 0x0a, 0x1d, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, - 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x55, 0x53, 0x45, 0x52, - 0x5f, 0x49, 0x4e, 0x50, 0x55, 0x54, 0x10, 0x02, 0x1a, 0x0e, 0xea, 0xdc, 0x14, 0x0a, 0x75, 0x73, - 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x12, 0x59, 0x0a, 0x31, 0x41, 0x55, 0x54, 0x48, - 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x4f, - 0x41, 0x55, 0x54, 0x48, 0x32, 0x5f, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, - 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x10, 0x03, 0x1a, - 0x22, 0xea, 0xdc, 0x14, 0x1e, 0x6f, 0x61, 0x75, 0x74, 0x68, 0x32, 0x5f, 0x61, 0x75, 0x74, 0x68, - 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x66, - 0x6c, 0x6f, 0x77, 0x12, 0x3b, 0x0a, 0x22, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, - 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, - 0x5f, 0x41, 0x50, 0x50, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x10, 0x04, 0x1a, 0x13, 0xea, 0xdc, 0x14, - 0x0f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x5f, 0x61, 0x70, 0x70, 0x5f, 0x66, 0x6c, 0x6f, 0x77, - 0x2a, 0xbb, 0x01, 0x0a, 0x10, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, - 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x21, 0x0a, 0x1d, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, - 0x49, 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, - 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x22, 0x0a, 0x15, 0x43, 0x52, 0x45, 0x44, - 0x45, 0x4e, 0x54, 0x49, 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x45, - 0x54, 0x10, 0x01, 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x73, 0x65, 0x74, 0x12, 0x26, 0x0a, 0x17, - 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, - 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x45, 0x54, 0x10, 0x02, 0x1a, 0x09, 0xea, 0xdc, 0x14, 0x05, 0x75, - 0x6e, 0x73, 0x65, 0x74, 0x12, 0x38, 0x0a, 0x20, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, - 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x41, 0x50, - 0x50, 0x4c, 0x49, 0x43, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x03, 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, - 0x6e, 0x6f, 0x74, 0x5f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x7d, - 0x0a, 0x0d, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, - 0x6c, 0x0a, 0x0b, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x1d, - 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, - 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, + 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x20, + 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x64, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x12, 0x37, 0x0a, 0x1b, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, + 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, + 0x47, 0x45, 0x54, 0x10, 0x21, 0x1a, 0x16, 0xea, 0xdc, 0x14, 0x12, 0x70, 0x72, 0x6f, 0x66, 0x69, + 0x6c, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x31, 0x0a, + 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x4d, 0x4f, 0x54, 0x45, + 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x22, 0x1a, 0x13, 0xea, 0xdc, 0x14, + 0x0f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x67, 0x65, 0x74, + 0x12, 0x55, 0x0a, 0x2a, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x4e, 0x54, + 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x43, 0x4f, 0x4e, 0x43, 0x49, 0x4c, 0x49, 0x41, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x54, 0x41, 0x53, 0x4b, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x23, + 0x1a, 0x25, 0xea, 0xdc, 0x14, 0x21, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x72, 0x65, 0x63, + 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x61, 0x73, 0x6b, + 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, 0x54, + 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x43, 0x4f, 0x4e, + 0x43, 0x49, 0x4c, 0x45, 0x10, 0x24, 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x12, 0x3f, 0x0a, 0x1f, + 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x41, 0x53, + 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, + 0x25, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x69, + 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2a, 0x82, 0x01, + 0x0a, 0x0e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x12, 0x1f, 0x0a, 0x1b, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, + 0x52, 0x43, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, + 0x00, 0x12, 0x18, 0x0a, 0x14, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, 0x4f, + 0x55, 0x52, 0x43, 0x45, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x01, 0x12, 0x18, 0x0a, 0x14, 0x54, + 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x55, + 0x53, 0x45, 0x52, 0x10, 0x02, 0x12, 0x1b, 0x0a, 0x17, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, + 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, + 0x10, 0x03, 0x2a, 0x72, 0x0a, 0x0c, 0x44, 0x65, 0x70, 0x45, 0x63, 0x6f, 0x73, 0x79, 0x73, 0x74, + 0x65, 0x6d, 0x12, 0x1d, 0x0a, 0x19, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, + 0x54, 0x45, 0x4d, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, + 0x00, 0x12, 0x15, 0x0a, 0x11, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, + 0x45, 0x4d, 0x5f, 0x4e, 0x50, 0x4d, 0x10, 0x01, 0x12, 0x14, 0x0a, 0x10, 0x44, 0x45, 0x50, 0x5f, + 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x5f, 0x47, 0x4f, 0x10, 0x02, 0x12, 0x16, + 0x0a, 0x12, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x5f, + 0x50, 0x59, 0x50, 0x49, 0x10, 0x03, 0x2a, 0x88, 0x01, 0x0a, 0x06, 0x45, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x12, 0x16, 0x0a, 0x12, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x55, 0x4e, 0x53, 0x50, + 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x45, 0x4e, 0x54, + 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x53, 0x49, 0x54, 0x4f, 0x52, 0x49, 0x45, 0x53, + 0x10, 0x01, 0x12, 0x1d, 0x0a, 0x19, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x42, 0x55, 0x49, + 0x4c, 0x44, 0x5f, 0x45, 0x4e, 0x56, 0x49, 0x52, 0x4f, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x53, 0x10, + 0x02, 0x12, 0x14, 0x0a, 0x10, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x41, 0x52, 0x54, 0x49, + 0x46, 0x41, 0x43, 0x54, 0x53, 0x10, 0x03, 0x12, 0x18, 0x0a, 0x14, 0x45, 0x4e, 0x54, 0x49, 0x54, + 0x59, 0x5f, 0x50, 0x55, 0x4c, 0x4c, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x45, 0x53, 0x54, 0x53, 0x10, + 0x04, 0x2a, 0x97, 0x02, 0x0a, 0x0c, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x1d, 0x0a, 0x19, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, + 0x00, 0x12, 0x24, 0x0a, 0x14, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, + 0x50, 0x45, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x10, 0x01, 0x1a, 0x0a, 0xea, 0xdc, 0x14, + 0x06, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x12, 0x20, 0x0a, 0x12, 0x50, 0x52, 0x4f, 0x56, 0x49, + 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x52, 0x45, 0x53, 0x54, 0x10, 0x02, 0x1a, + 0x08, 0xea, 0xdc, 0x14, 0x04, 0x72, 0x65, 0x73, 0x74, 0x12, 0x1e, 0x0a, 0x11, 0x50, 0x52, 0x4f, + 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x47, 0x49, 0x54, 0x10, 0x03, + 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x67, 0x69, 0x74, 0x12, 0x1e, 0x0a, 0x11, 0x50, 0x52, 0x4f, + 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4f, 0x43, 0x49, 0x10, 0x04, + 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x6f, 0x63, 0x69, 0x12, 0x2e, 0x0a, 0x19, 0x50, 0x52, 0x4f, + 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, + 0x4c, 0x49, 0x53, 0x54, 0x45, 0x52, 0x10, 0x05, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, + 0x70, 0x6f, 0x2d, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x72, 0x12, 0x30, 0x0a, 0x1a, 0x50, 0x52, 0x4f, + 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4d, 0x41, 0x47, 0x45, + 0x5f, 0x4c, 0x49, 0x53, 0x54, 0x45, 0x52, 0x10, 0x06, 0x1a, 0x10, 0xea, 0xdc, 0x14, 0x0c, 0x69, + 0x6d, 0x61, 0x67, 0x65, 0x2d, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x72, 0x2a, 0xd5, 0x01, 0x0a, 0x0d, + 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x1e, 0x0a, + 0x1a, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, + 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x25, 0x0a, + 0x15, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, + 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x10, 0x01, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x12, 0x2d, 0x0a, 0x19, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, + 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x5f, 0x41, 0x50, + 0x50, 0x10, 0x02, 0x1a, 0x0e, 0xea, 0xdc, 0x14, 0x0a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2d, + 0x61, 0x70, 0x70, 0x12, 0x21, 0x0a, 0x13, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, + 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x47, 0x48, 0x43, 0x52, 0x10, 0x03, 0x1a, 0x08, 0xea, 0xdc, + 0x14, 0x04, 0x67, 0x68, 0x63, 0x72, 0x12, 0x2b, 0x0a, 0x18, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, + 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x44, 0x4f, 0x43, 0x4b, 0x45, 0x52, 0x48, + 0x55, 0x42, 0x10, 0x04, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x64, 0x6f, 0x63, 0x6b, 0x65, 0x72, + 0x68, 0x75, 0x62, 0x2a, 0xa9, 0x02, 0x0a, 0x11, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x6c, 0x6f, 0x77, 0x12, 0x22, 0x0a, 0x1e, 0x41, 0x55, 0x54, + 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, + 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x25, 0x0a, + 0x17, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, + 0x4c, 0x4f, 0x57, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x01, 0x1a, 0x08, 0xea, 0xdc, 0x14, 0x04, + 0x6e, 0x6f, 0x6e, 0x65, 0x12, 0x31, 0x0a, 0x1d, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, + 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x5f, + 0x49, 0x4e, 0x50, 0x55, 0x54, 0x10, 0x02, 0x1a, 0x0e, 0xea, 0xdc, 0x14, 0x0a, 0x75, 0x73, 0x65, + 0x72, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x12, 0x59, 0x0a, 0x31, 0x41, 0x55, 0x54, 0x48, 0x4f, + 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x4f, 0x41, + 0x55, 0x54, 0x48, 0x32, 0x5f, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x10, 0x03, 0x1a, 0x22, + 0xea, 0xdc, 0x14, 0x1e, 0x6f, 0x61, 0x75, 0x74, 0x68, 0x32, 0x5f, 0x61, 0x75, 0x74, 0x68, 0x6f, + 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x66, 0x6c, + 0x6f, 0x77, 0x12, 0x3b, 0x0a, 0x22, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, + 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x5f, + 0x41, 0x50, 0x50, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x10, 0x04, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, + 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x5f, 0x61, 0x70, 0x70, 0x5f, 0x66, 0x6c, 0x6f, 0x77, 0x2a, + 0xbb, 0x01, 0x0a, 0x10, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x12, 0x21, 0x0a, 0x1d, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, + 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, + 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x22, 0x0a, 0x15, 0x43, 0x52, 0x45, 0x44, 0x45, + 0x4e, 0x54, 0x49, 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x45, 0x54, + 0x10, 0x01, 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x73, 0x65, 0x74, 0x12, 0x26, 0x0a, 0x17, 0x43, + 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, + 0x5f, 0x55, 0x4e, 0x53, 0x45, 0x54, 0x10, 0x02, 0x1a, 0x09, 0xea, 0xdc, 0x14, 0x05, 0x75, 0x6e, + 0x73, 0x65, 0x74, 0x12, 0x38, 0x0a, 0x20, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, 0x41, + 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x41, 0x50, 0x50, + 0x4c, 0x49, 0x43, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x03, 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x6e, + 0x6f, 0x74, 0x5f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x7d, 0x0a, + 0x0d, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x6c, + 0x0a, 0x0b, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, - 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1e, 0xaa, - 0xf8, 0x18, 0x04, 0x10, 0x01, 0x30, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x10, 0x12, 0x0e, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x32, 0xbc, 0x03, - 0x0a, 0x0f, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, - 0x65, 0x12, 0x95, 0x01, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, - 0x63, 0x74, 0x73, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x4c, 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x41, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0d, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x33, 0x5a, 0x13, 0x12, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, - 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x12, 0x1c, 0x2f, 0x61, 0x70, - 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x2f, 0x7b, - 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x12, 0x7f, 0x0a, 0x0f, 0x47, 0x65, 0x74, - 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, 0x12, 0x21, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, - 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, - 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x25, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0d, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, - 0x69, 0x66, 0x61, 0x63, 0x74, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x8f, 0x01, 0x0a, 0x11, 0x47, - 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, - 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, - 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, - 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2f, 0xaa, 0xf8, 0x18, - 0x04, 0x30, 0x03, 0x38, 0x0d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x21, 0x12, 0x1f, 0x2f, 0x61, 0x70, - 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x2f, 0x6e, 0x61, - 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x32, 0xb6, 0x05, 0x0a, - 0x0c, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x86, 0x01, - 0x0a, 0x13, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x55, 0x52, 0x4c, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, - 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x12, 0x12, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, - 0x74, 0x68, 0x2f, 0x75, 0x72, 0x6c, 0x12, 0xac, 0x01, 0x0a, 0x12, 0x53, 0x74, 0x6f, 0x72, 0x65, - 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x24, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x50, - 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x53, 0x74, 0x6f, 0x72, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, - 0x65, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x49, 0xaa, 0xf8, 0x18, 0x04, - 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3b, 0x3a, 0x01, 0x2a, 0x5a, 0x17, 0x3a, - 0x01, 0x2a, 0x22, 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, - 0x2f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x1d, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, - 0x61, 0x75, 0x74, 0x68, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, - 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0xd2, 0x01, 0x0a, 0x17, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, - 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x72, 0x6f, - 0x6d, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, - 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, - 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, + 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, + 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1e, 0xaa, 0xf8, + 0x18, 0x04, 0x10, 0x01, 0x30, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x10, 0x12, 0x0e, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x32, 0xbc, 0x03, 0x0a, + 0x0f, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x12, 0x95, 0x01, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, + 0x74, 0x73, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, + 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x4c, 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x41, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0d, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x33, 0x5a, 0x13, 0x12, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, + 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x12, 0x1c, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x2f, 0x7b, 0x70, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x12, 0x7f, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x41, + 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, 0x12, 0x21, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, + 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, + 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x25, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0d, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x17, 0x12, 0x15, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, + 0x66, 0x61, 0x63, 0x74, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x8f, 0x01, 0x0a, 0x11, 0x47, 0x65, + 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, + 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, + 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, 0x61, + 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2f, 0xaa, 0xf8, 0x18, 0x04, + 0x30, 0x03, 0x38, 0x0d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x21, 0x12, 0x1f, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x2f, 0x6e, 0x61, 0x6d, + 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x32, 0xb6, 0x05, 0x0a, 0x0c, + 0x4f, 0x41, 0x75, 0x74, 0x68, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x86, 0x01, 0x0a, + 0x13, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x55, 0x52, 0x4c, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, + 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x12, 0x12, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, + 0x68, 0x2f, 0x75, 0x72, 0x6c, 0x12, 0xac, 0x01, 0x0a, 0x12, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x50, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x24, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x50, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, + 0x74, 0x6f, 0x72, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, + 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x49, 0xaa, 0xf8, 0x18, 0x04, 0x30, + 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3b, 0x3a, 0x01, 0x2a, 0x5a, 0x17, 0x3a, 0x01, + 0x2a, 0x22, 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, + 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x1d, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, + 0x75, 0x74, 0x68, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x74, + 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0xd2, 0x01, 0x0a, 0x17, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x72, 0x6f, 0x6d, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x60, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, - 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4f, 0x5a, 0x21, 0x12, 0x1f, 0x2f, 0x61, 0x70, 0x69, + 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, + 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, + 0x46, 0x72, 0x6f, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x60, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, + 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4f, 0x5a, 0x21, 0x12, 0x1f, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x2f, 0x7b, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x7d, 0x12, 0x2a, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x2f, - 0x7b, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x7d, 0x12, 0x2a, 0x2f, 0x61, 0x70, - 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, - 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x7b, 0x74, 0x69, 0x6d, - 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x7d, 0x88, 0x02, 0x01, 0x12, 0x98, 0x01, 0x0a, 0x18, 0x56, + 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x7b, 0x74, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x7d, 0x88, 0x02, 0x01, 0x12, 0x98, 0x01, 0x0a, 0x18, 0x56, 0x65, + 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x72, 0x65, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x72, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x72, 0x65, - 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x72, - 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, - 0x12, 0x13, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, - 0x65, 0x72, 0x69, 0x66, 0x79, 0x32, 0xe9, 0x0a, 0x0a, 0x11, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x6f, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0xc7, 0x01, 0x0a, 0x12, - 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, - 0x72, 0x79, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x12, + 0x13, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, 0x65, + 0x72, 0x69, 0x66, 0x79, 0x32, 0xe9, 0x0a, 0x0a, 0x11, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x6f, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0xc7, 0x01, 0x0a, 0x12, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, - 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x64, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x56, 0x3a, - 0x01, 0x2a, 0x5a, 0x20, 0x3a, 0x01, 0x2a, 0x22, 0x1b, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, - 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x72, 0x65, 0x67, 0x69, - 0x73, 0x74, 0x65, 0x72, 0x22, 0x2f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, - 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x72, 0x65, 0x67, - 0x69, 0x73, 0x74, 0x65, 0x72, 0x12, 0xf1, 0x01, 0x0a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, - 0x6d, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, - 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x34, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x6d, + 0x79, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x64, + 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x56, 0x3a, 0x01, + 0x2a, 0x5a, 0x20, 0x3a, 0x01, 0x2a, 0x22, 0x1b, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, + 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x72, 0x65, 0x67, 0x69, 0x73, + 0x74, 0x65, 0x72, 0x22, 0x2f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, + 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x72, 0x65, 0x67, 0x69, + 0x73, 0x74, 0x65, 0x72, 0x12, 0xf1, 0x01, 0x0a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x46, - 0x72, 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x35, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, - 0x69, 0x73, 0x74, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x6f, 0x72, 0x69, 0x65, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5e, 0xaa, 0xf8, 0x18, 0x04, 0x30, - 0x03, 0x38, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x50, 0x5a, 0x1d, 0x12, 0x1b, 0x2f, 0x61, 0x70, - 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, - 0x73, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x12, 0x2f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, - 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x2f, 0x70, - 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x7d, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x12, 0xad, 0x01, 0x0a, 0x10, 0x4c, 0x69, - 0x73, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x12, 0x22, - 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, - 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, - 0x69, 0x73, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x50, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, - 0x09, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x42, 0x5a, 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x12, - 0x28, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x6f, 0x72, 0x69, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, - 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x12, 0x95, 0x01, 0x0a, 0x11, 0x47, 0x65, - 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x12, - 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, + 0x72, 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x34, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x6d, 0x6f, + 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x46, 0x72, + 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x35, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, + 0x72, 0x69, 0x65, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5e, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, + 0x38, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x50, 0x5a, 0x1d, 0x12, 0x1b, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, + 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x12, 0x2f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, + 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x2f, 0x70, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, + 0x7d, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x12, 0xad, 0x01, 0x0a, 0x10, 0x4c, 0x69, 0x73, + 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x12, 0x22, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x50, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x09, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x42, 0x5a, 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, + 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x12, 0x28, + 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, + 0x72, 0x69, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x12, 0x95, 0x01, 0x0a, 0x11, 0x47, 0x65, 0x74, + 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x12, 0x23, + 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, + 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0xaa, 0xf8, 0x18, 0x04, 0x30, + 0x03, 0x38, 0x09, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12, 0x25, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x69, 0x64, + 0x2f, 0x7b, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x69, 0x64, 0x7d, + 0x12, 0xd0, 0x01, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, + 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, + 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, + 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, + 0x09, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5c, 0x5a, 0x23, 0x12, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x6e, 0x61, + 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x12, 0x35, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, + 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, + 0x2a, 0x2a, 0x7d, 0x12, 0x9e, 0x01, 0x0a, 0x14, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x12, 0x26, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, - 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0xaa, 0xf8, 0x18, 0x04, - 0x30, 0x03, 0x38, 0x09, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12, 0x25, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x69, - 0x64, 0x2f, 0x7b, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x69, 0x64, - 0x7d, 0x12, 0xd0, 0x01, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, - 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, - 0x38, 0x09, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5c, 0x5a, 0x23, 0x12, 0x21, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x6e, - 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x12, 0x35, 0x2f, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, + 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0xaa, + 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x2a, 0x25, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, - 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, - 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, - 0x3d, 0x2a, 0x2a, 0x7d, 0x12, 0x9e, 0x01, 0x0a, 0x14, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, - 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x12, 0x26, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, - 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, - 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, - 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x2a, 0x25, - 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, - 0x72, 0x79, 0x2f, 0x69, 0x64, 0x2f, 0x7b, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, - 0x79, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0xd9, 0x01, 0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, - 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, - 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, - 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, - 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6e, - 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x5c, 0x5a, 0x23, 0x2a, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, - 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x6e, 0x61, 0x6d, 0x65, - 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x2a, 0x35, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x70, - 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x7d, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, - 0x7d, 0x32, 0xce, 0x04, 0x0a, 0x0b, 0x55, 0x73, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, - 0x65, 0x12, 0x68, 0x0a, 0x0a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, - 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, - 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, - 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0xaa, 0xf8, - 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x3a, 0x01, 0x2a, 0x22, 0x0c, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x12, 0x65, 0x0a, 0x0a, 0x44, - 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x0e, 0x2a, 0x0c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, - 0x65, 0x72, 0x12, 0x5c, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x12, 0x19, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, - 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x0e, 0x12, 0x0c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, - 0x12, 0x80, 0x01, 0x0a, 0x0f, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, - 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x12, 0x8c, 0x01, 0x0a, 0x11, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x49, - 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x49, 0x6e, 0x76, - 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, - 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, - 0x76, 0x65, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2c, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x20, 0x22, 0x1e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, - 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x7b, 0x63, 0x6f, 0x64, - 0x65, 0x7d, 0x32, 0xb7, 0x0e, 0x0a, 0x0e, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x65, - 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x76, 0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, - 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x79, 0x2f, 0x69, 0x64, 0x2f, 0x7b, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, + 0x5f, 0x69, 0x64, 0x7d, 0x12, 0xd9, 0x01, 0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, + 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, + 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, + 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x5c, 0x5a, 0x23, 0x2a, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, + 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, + 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x2a, 0x35, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x70, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, + 0x7d, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, + 0x32, 0xce, 0x04, 0x0a, 0x0b, 0x55, 0x73, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x12, 0x68, 0x0a, 0x0a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1c, + 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, + 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0xaa, 0xf8, 0x18, + 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x3a, 0x01, 0x2a, 0x22, 0x0c, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x12, 0x65, 0x0a, 0x0a, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x0e, 0x2a, 0x0c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, + 0x72, 0x12, 0x5c, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x12, 0x19, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x1a, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x0e, 0x12, 0x0c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x12, + 0x80, 0x01, 0x0a, 0x0f, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x12, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x02, + 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, + 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x12, 0x8c, 0x01, 0x0a, 0x11, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x49, 0x6e, + 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x49, 0x6e, 0x76, 0x69, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, + 0x65, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x2c, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x20, 0x22, 0x1e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2f, + 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x7b, 0x63, 0x6f, 0x64, 0x65, + 0x7d, 0x32, 0xb7, 0x0e, 0x0a, 0x0e, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x12, 0x76, 0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, + 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, - 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, - 0x03, 0x38, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x3a, 0x01, 0x2a, 0x22, 0x0f, 0x2f, 0x61, - 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x76, 0x0a, - 0x0d, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1f, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, + 0x38, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x3a, 0x01, 0x2a, 0x22, 0x0f, 0x2f, 0x61, 0x70, + 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x76, 0x0a, 0x0d, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1f, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, - 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, - 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x14, 0x3a, 0x01, 0x2a, 0x1a, 0x0f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, - 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x7c, 0x0a, 0x0c, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, - 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2b, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1f, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x3a, 0x05, 0x70, 0x61, 0x74, 0x63, 0x68, 0x32, 0x14, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, - 0x69, 0x64, 0x7d, 0x12, 0x78, 0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, - 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, + 0x3a, 0x01, 0x2a, 0x1a, 0x0f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, + 0x66, 0x69, 0x6c, 0x65, 0x12, 0x7c, 0x0a, 0x0c, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, + 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2b, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1f, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x3a, 0x05, 0x70, 0x61, 0x74, 0x63, 0x68, 0x32, 0x14, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, 0x69, + 0x64, 0x7d, 0x12, 0x78, 0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, + 0x69, 0x6c, 0x65, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, - 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x2a, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, - 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x71, 0x0a, - 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x1e, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, - 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, - 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, - 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x12, 0x10, - 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, - 0x12, 0x7b, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, - 0x49, 0x64, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, - 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, - 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, - 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0xa4, 0x01, - 0x0a, 0x16, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, - 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, - 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12, 0x25, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x6e, - 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x2f, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x12, 0x9e, 0x01, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, - 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x50, 0x72, 0x6f, 0x6a, 0x65, - 0x63, 0x74, 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, - 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, - 0x79, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x2c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, - 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x50, 0x72, - 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x73, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x76, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6c, - 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x20, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x2a, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, + 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x71, 0x0a, 0x0c, + 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x1e, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, + 0x66, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, + 0x66, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0xaa, + 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x12, 0x10, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x12, + 0x7b, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, 0x49, + 0x64, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, + 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1d, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, + 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0xa4, 0x01, 0x0a, + 0x16, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, + 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, + 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0xaa, 0xf8, + 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12, 0x25, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x6e, 0x61, + 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x2f, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x9e, 0x01, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, + 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, + 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, + 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, + 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x50, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, + 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x73, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x12, 0x76, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6c, 0x65, + 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, - 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, - 0x03, 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x12, 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x12, 0x90, 0x01, - 0x0a, 0x11, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x4e, - 0x61, 0x6d, 0x65, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x4e, 0x61, 0x6d, - 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, - 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, - 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22, 0x12, 0x20, - 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, - 0x65, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, - 0x12, 0x80, 0x01, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, - 0x42, 0x79, 0x49, 0x64, 0x12, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x49, 0x64, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, + 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x12, 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, + 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x12, 0x90, 0x01, 0x0a, + 0x11, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x4e, 0x61, + 0x6d, 0x65, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, + 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, - 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, - 0x04, 0x30, 0x03, 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x61, 0x70, - 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x7b, - 0x69, 0x64, 0x7d, 0x12, 0x7b, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, - 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, - 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, - 0x30, 0x03, 0x38, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x22, 0x11, 0x2f, + 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0xaa, + 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22, 0x12, 0x20, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, - 0x12, 0x7b, 0x0a, 0x0e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, - 0x70, 0x65, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, - 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, - 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x1a, 0x11, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x12, 0x7d, 0x0a, - 0x0e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, - 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, - 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, - 0x6c, 0x65, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1c, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x18, 0x2a, 0x16, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, - 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x32, 0xb0, 0x02, 0x0a, - 0x12, 0x45, 0x76, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x53, 0x65, 0x72, 0x76, - 0x69, 0x63, 0x65, 0x12, 0x8b, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, - 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x27, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, - 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x1f, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, - 0x12, 0x0f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, - 0x73, 0x12, 0x8b, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x27, 0x2e, 0x6d, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, - 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, - 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, - 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x12, 0x0f, - 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x32, - 0x8a, 0x05, 0x0a, 0x12, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x53, - 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x71, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, - 0x6c, 0x65, 0x73, 0x12, 0x1b, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, - 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x29, - 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x05, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1b, 0x12, 0x19, + 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x12, + 0x80, 0x01, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, + 0x79, 0x49, 0x64, 0x12, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, + 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x04, + 0x30, 0x03, 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x7b, 0x69, + 0x64, 0x7d, 0x12, 0x7b, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, + 0x03, 0x38, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x22, 0x11, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x12, + 0x7b, 0x0a, 0x0e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1b, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x1a, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x12, 0x7d, 0x0a, 0x0e, + 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x20, + 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, + 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1c, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x18, 0x2a, 0x16, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, + 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x32, 0xb0, 0x02, 0x0a, 0x12, + 0x45, 0x76, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x12, 0x8b, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x27, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, + 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x1f, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x12, + 0x0f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, + 0x12, 0x8b, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, + 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0xaa, + 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x12, 0x0f, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x32, 0x8a, + 0x05, 0x0a, 0x12, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x53, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x71, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, + 0x65, 0x73, 0x12, 0x1b, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, + 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x52, 0x6f, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x29, 0xaa, + 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x05, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1b, 0x12, 0x19, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x73, 0x2f, 0x72, 0x6f, 0x6c, 0x65, 0x73, 0x12, 0x95, 0x01, 0x0a, 0x13, 0x4c, 0x69, 0x73, + 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, + 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, 0x69, + 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x2f, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x06, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x21, 0x12, + 0x1f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, + 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x12, 0x78, 0x0a, 0x0a, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x1c, + 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x73, 0x73, 0x69, 0x67, + 0x6e, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x52, + 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0xaa, 0xf8, 0x18, + 0x04, 0x30, 0x03, 0x38, 0x07, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x3a, 0x01, 0x2a, 0x22, 0x1a, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, - 0x6f, 0x6e, 0x73, 0x2f, 0x72, 0x6f, 0x6c, 0x65, 0x73, 0x12, 0x95, 0x01, 0x0a, 0x13, 0x4c, 0x69, - 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, - 0x73, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, - 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, - 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x2f, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x06, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x21, - 0x12, 0x1f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, - 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, - 0x73, 0x12, 0x78, 0x0a, 0x0a, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x52, 0x6f, 0x6c, 0x65, 0x12, - 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x73, 0x73, 0x69, - 0x67, 0x6e, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, - 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0xaa, 0xf8, - 0x18, 0x04, 0x30, 0x03, 0x38, 0x07, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x3a, 0x01, 0x2a, 0x22, + 0x6f, 0x6e, 0x73, 0x2f, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x12, 0x78, 0x0a, 0x0a, 0x55, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x25, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x3a, 0x01, 0x2a, 0x22, 0x1a, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, + 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x12, 0x75, 0x0a, 0x0a, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x6f, + 0x6c, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, + 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6d, + 0x6f, 0x76, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x2a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x08, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x2a, 0x1a, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, - 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x12, 0x78, 0x0a, 0x0a, 0x55, - 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x25, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x3a, 0x01, 0x2a, 0x22, 0x1a, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x75, - 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x75, 0x0a, 0x0a, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, - 0x6f, 0x6c, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, - 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x2a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x08, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, - 0x2a, 0x1a, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, - 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x32, 0xc5, 0x07, 0x0a, - 0x0f, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x12, 0x71, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, - 0x12, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, - 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, - 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x02, 0x38, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x12, 0x12, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, - 0x63, 0x74, 0x73, 0x12, 0x77, 0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, - 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x32, 0xc5, 0x07, 0x0a, 0x0f, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, + 0x71, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, + 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x02, 0x38, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, + 0x12, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x73, 0x12, 0x77, 0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, - 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x3a, 0x01, 0x2a, 0x22, 0x10, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x9e, 0x01, 0x0a, - 0x11, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, - 0x74, 0x73, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, - 0x69, 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, - 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2f, - 0x7b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, - 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x12, 0x74, 0x0a, - 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x01, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x3a, 0x01, 0x2a, 0x22, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x9e, 0x01, 0x0a, 0x11, + 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x73, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e, 0xaa, 0xf8, + 0x18, 0x04, 0x30, 0x03, 0x38, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2f, 0x7b, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, + 0x69, 0x64, 0x7d, 0x2f, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x12, 0x74, 0x0a, 0x0d, + 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, - 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, - 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x04, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x12, 0x2a, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, - 0x63, 0x74, 0x73, 0x12, 0x77, 0x0a, 0x0d, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, - 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x04, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, + 0x2a, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x73, 0x12, 0x77, 0x0a, 0x0d, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, - 0x03, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x3a, 0x01, 0x2a, 0x1a, 0x10, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x78, 0x0a, 0x0c, - 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1e, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, - 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, - 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x27, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x03, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x3a, 0x05, 0x70, - 0x61, 0x74, 0x63, 0x68, 0x32, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, - 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0xbb, 0x01, 0x0a, 0x1e, 0x43, 0x72, 0x65, 0x61, 0x74, - 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, 0x69, - 0x74, 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x6d, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6e, - 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34, - 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x23, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x26, 0x3a, 0x01, - 0x2a, 0x22, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, - 0x63, 0x74, 0x73, 0x2f, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2f, 0x72, 0x65, 0x63, 0x6f, 0x6e, - 0x63, 0x69, 0x6c, 0x65, 0x32, 0xd5, 0x09, 0x0a, 0x10, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x7c, 0x0a, 0x0d, 0x50, 0x61, 0x74, - 0x63, 0x68, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, - 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x76, - 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x03, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x3a, 0x01, 0x2a, 0x1a, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x78, 0x0a, 0x0c, 0x50, + 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, - 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x3a, 0x05, 0x70, - 0x61, 0x74, 0x63, 0x68, 0x32, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, - 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x76, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x50, 0x72, - 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, - 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, - 0x75, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, - 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, - 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, - 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x21, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x13, 0x12, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, - 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x7b, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, - 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, - 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, - 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, - 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x16, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, - 0x22, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x73, 0x12, 0x78, 0x0a, 0x0e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, - 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x21, 0xaa, 0xf8, 0x18, 0x04, - 0x30, 0x03, 0x38, 0x18, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x13, 0x2a, 0x11, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x89, 0x01, - 0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, - 0x42, 0x79, 0x49, 0x44, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x42, - 0x79, 0x49, 0x44, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, - 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, - 0x76, 0x69, 0x64, 0x65, 0x72, 0x42, 0x79, 0x49, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x18, 0x2a, 0x16, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, - 0x64, 0x65, 0x72, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x8e, 0x01, 0x0a, 0x15, 0x47, 0x65, - 0x74, 0x55, 0x6e, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x73, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x47, 0x65, 0x74, 0x55, 0x6e, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, - 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x6e, 0x63, 0x6c, - 0x61, 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x79, - 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x8e, 0x01, 0x0a, 0x13, 0x4c, - 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, - 0x65, 0x73, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, - 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, - 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x28, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, - 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x12, 0xae, 0x01, 0x0a, 0x1b, - 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, - 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x2e, 0x6d, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, - 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, 0x69, 0x6e, + 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x27, 0xaa, 0xf8, + 0x18, 0x04, 0x30, 0x03, 0x38, 0x03, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x3a, 0x05, 0x70, 0x61, + 0x74, 0x63, 0x68, 0x32, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0xbb, 0x01, 0x0a, 0x1e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, + 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x6d, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34, 0xaa, + 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x23, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x26, 0x3a, 0x01, 0x2a, + 0x22, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x73, 0x2f, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2f, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x63, + 0x69, 0x6c, 0x65, 0x32, 0xd5, 0x09, 0x0a, 0x10, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, + 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x7c, 0x0a, 0x0d, 0x50, 0x61, 0x74, 0x63, + 0x68, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0xaa, 0xf8, + 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x3a, 0x05, 0x70, 0x61, + 0x74, 0x63, 0x68, 0x32, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x76, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x75, + 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, + 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, + 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x21, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x13, 0x12, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x7b, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, + 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, + 0x18, 0x04, 0x30, 0x03, 0x38, 0x16, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x22, + 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x72, 0x73, 0x12, 0x78, 0x0a, 0x0e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x21, 0xaa, 0xf8, 0x18, 0x04, 0x30, + 0x03, 0x38, 0x18, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x13, 0x2a, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x89, 0x01, 0x0a, + 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x42, + 0x79, 0x49, 0x44, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x42, 0x79, + 0x49, 0x44, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x42, 0x79, 0x49, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, + 0x2a, 0x16, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, + 0x65, 0x72, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x8e, 0x01, 0x0a, 0x15, 0x47, 0x65, 0x74, + 0x55, 0x6e, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x72, 0x73, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, + 0x65, 0x74, 0x55, 0x6e, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x6e, 0x63, 0x6c, 0x61, + 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x79, 0x2f, + 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x8e, 0x01, 0x0a, 0x13, 0x4c, 0x69, + 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, + 0x73, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x28, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, + 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, + 0x65, 0x72, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x12, 0xae, 0x01, 0x0a, 0x1b, 0x52, + 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0xaa, 0xf8, 0x18, 0x04, - 0x30, 0x03, 0x38, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22, 0x3a, 0x01, 0x2a, 0x22, 0x1d, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, - 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x6c, 0x6c, 0x32, 0x92, 0x01, 0x0a, - 0x0d, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x80, - 0x01, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, - 0x69, 0x6c, 0x73, 0x12, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x47, 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, - 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, - 0x18, 0x02, 0x30, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x2f, 0x7b, 0x63, 0x6f, 0x64, 0x65, - 0x7d, 0x3a, 0x3a, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, - 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, - 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xcd, 0xcb, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x3a, 0x58, 0x0a, - 0x0b, 0x72, 0x70, 0x63, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1e, 0x2e, 0x67, - 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, - 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x85, 0x8f, 0x03, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x52, 0x70, 0x63, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x0a, 0x72, 0x70, 0x63, - 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, 0x3a, 0x5a, 0x38, 0x67, 0x69, 0x74, 0x68, 0x75, - 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x6c, 0x6f, 0x6b, 0x2f, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x45, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0xaa, 0xf8, 0x18, 0x04, 0x30, + 0x03, 0x38, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22, 0x3a, 0x01, 0x2a, 0x22, 0x1d, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x72, + 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x6c, 0x6c, 0x32, 0x92, 0x01, 0x0a, 0x0d, + 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x80, 0x01, + 0x0a, 0x10, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x12, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, + 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, 0x18, + 0x02, 0x30, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x2f, 0x7b, 0x63, 0x6f, 0x64, 0x65, 0x7d, + 0x3a, 0x3a, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xcd, 0xcb, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x3a, 0x58, 0x0a, 0x0b, + 0x72, 0x70, 0x63, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1e, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, + 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x85, 0x8f, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x52, 0x70, 0x63, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x0a, 0x72, 0x70, 0x63, 0x4f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, 0x3a, 0x5a, 0x38, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x6c, 0x6f, 0x6b, 0x2f, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2f, + 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -15359,40 +15354,40 @@ var file_minder_v1_minder_proto_goTypes = []any{ (*ListEvaluationHistoryRequest)(nil), // 170: minder.v1.ListEvaluationHistoryRequest (*ListEvaluationHistoryResponse)(nil), // 171: minder.v1.ListEvaluationHistoryResponse (*EvaluationHistory)(nil), // 172: minder.v1.EvaluationHistory - (*EvaluationHistoryEntity)(nil), // 173: minder.v1.EvaluationHistoryEntity - (*EvaluationHistoryRule)(nil), // 174: minder.v1.EvaluationHistoryRule - (*EvaluationHistoryStatus)(nil), // 175: minder.v1.EvaluationHistoryStatus - (*EvaluationHistoryRemediation)(nil), // 176: minder.v1.EvaluationHistoryRemediation - (*EvaluationHistoryAlert)(nil), // 177: minder.v1.EvaluationHistoryAlert - (*PrDependencies_ContextualDependency)(nil), // 178: minder.v1.PrDependencies.ContextualDependency - (*PrDependencies_ContextualDependency_FilePatch)(nil), // 179: minder.v1.PrDependencies.ContextualDependency.FilePatch - (*PrContents_File)(nil), // 180: minder.v1.PrContents.File - (*PrContents_File_Line)(nil), // 181: minder.v1.PrContents.File.Line - (*RegisterRepoResult_Status)(nil), // 182: minder.v1.RegisterRepoResult.Status - nil, // 183: minder.v1.RuleEvaluationStatus.EntityInfoEntry - nil, // 184: minder.v1.AutoRegistration.EntitiesEntry - (*ListEvaluationResultsResponse_EntityProfileEvaluationResults)(nil), // 185: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults - (*ListEvaluationResultsResponse_EntityEvaluationResults)(nil), // 186: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults - (*RestType_Fallback)(nil), // 187: minder.v1.RestType.Fallback - (*DiffType_Ecosystem)(nil), // 188: minder.v1.DiffType.Ecosystem - (*RuleType_Definition)(nil), // 189: minder.v1.RuleType.Definition - (*RuleType_Definition_Ingest)(nil), // 190: minder.v1.RuleType.Definition.Ingest - (*RuleType_Definition_Eval)(nil), // 191: minder.v1.RuleType.Definition.Eval - (*RuleType_Definition_Remediate)(nil), // 192: minder.v1.RuleType.Definition.Remediate - (*RuleType_Definition_Alert)(nil), // 193: minder.v1.RuleType.Definition.Alert - (*RuleType_Definition_Eval_JQComparison)(nil), // 194: minder.v1.RuleType.Definition.Eval.JQComparison - (*RuleType_Definition_Eval_Rego)(nil), // 195: minder.v1.RuleType.Definition.Eval.Rego - (*RuleType_Definition_Eval_Vulncheck)(nil), // 196: minder.v1.RuleType.Definition.Eval.Vulncheck - (*RuleType_Definition_Eval_Trusty)(nil), // 197: minder.v1.RuleType.Definition.Eval.Trusty - (*RuleType_Definition_Eval_Homoglyphs)(nil), // 198: minder.v1.RuleType.Definition.Eval.Homoglyphs - (*RuleType_Definition_Eval_JQComparison_Operator)(nil), // 199: minder.v1.RuleType.Definition.Eval.JQComparison.Operator - (*RuleType_Definition_Remediate_GhBranchProtectionType)(nil), // 200: minder.v1.RuleType.Definition.Remediate.GhBranchProtectionType - (*RuleType_Definition_Remediate_PullRequestRemediation)(nil), // 201: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation - (*RuleType_Definition_Remediate_PullRequestRemediation_Content)(nil), // 202: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.Content - (*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha)(nil), // 203: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.ActionsReplaceTagsWithSha - (*RuleType_Definition_Alert_AlertTypeSA)(nil), // 204: minder.v1.RuleType.Definition.Alert.AlertTypeSA - (*Profile_Rule)(nil), // 205: minder.v1.Profile.Rule - (*Profile_Selector)(nil), // 206: minder.v1.Profile.Selector + (*PrDependencies_ContextualDependency)(nil), // 173: minder.v1.PrDependencies.ContextualDependency + (*PrDependencies_ContextualDependency_FilePatch)(nil), // 174: minder.v1.PrDependencies.ContextualDependency.FilePatch + (*PrContents_File)(nil), // 175: minder.v1.PrContents.File + (*PrContents_File_Line)(nil), // 176: minder.v1.PrContents.File.Line + (*RegisterRepoResult_Status)(nil), // 177: minder.v1.RegisterRepoResult.Status + nil, // 178: minder.v1.RuleEvaluationStatus.EntityInfoEntry + nil, // 179: minder.v1.AutoRegistration.EntitiesEntry + (*ListEvaluationResultsResponse_EntityProfileEvaluationResults)(nil), // 180: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults + (*ListEvaluationResultsResponse_EntityEvaluationResults)(nil), // 181: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults + (*RestType_Fallback)(nil), // 182: minder.v1.RestType.Fallback + (*DiffType_Ecosystem)(nil), // 183: minder.v1.DiffType.Ecosystem + (*RuleType_Definition)(nil), // 184: minder.v1.RuleType.Definition + (*RuleType_Definition_Ingest)(nil), // 185: minder.v1.RuleType.Definition.Ingest + (*RuleType_Definition_Eval)(nil), // 186: minder.v1.RuleType.Definition.Eval + (*RuleType_Definition_Remediate)(nil), // 187: minder.v1.RuleType.Definition.Remediate + (*RuleType_Definition_Alert)(nil), // 188: minder.v1.RuleType.Definition.Alert + (*RuleType_Definition_Eval_JQComparison)(nil), // 189: minder.v1.RuleType.Definition.Eval.JQComparison + (*RuleType_Definition_Eval_Rego)(nil), // 190: minder.v1.RuleType.Definition.Eval.Rego + (*RuleType_Definition_Eval_Vulncheck)(nil), // 191: minder.v1.RuleType.Definition.Eval.Vulncheck + (*RuleType_Definition_Eval_Trusty)(nil), // 192: minder.v1.RuleType.Definition.Eval.Trusty + (*RuleType_Definition_Eval_Homoglyphs)(nil), // 193: minder.v1.RuleType.Definition.Eval.Homoglyphs + (*RuleType_Definition_Eval_JQComparison_Operator)(nil), // 194: minder.v1.RuleType.Definition.Eval.JQComparison.Operator + (*RuleType_Definition_Remediate_GhBranchProtectionType)(nil), // 195: minder.v1.RuleType.Definition.Remediate.GhBranchProtectionType + (*RuleType_Definition_Remediate_PullRequestRemediation)(nil), // 196: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation + (*RuleType_Definition_Remediate_PullRequestRemediation_Content)(nil), // 197: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.Content + (*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha)(nil), // 198: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.ActionsReplaceTagsWithSha + (*RuleType_Definition_Alert_AlertTypeSA)(nil), // 199: minder.v1.RuleType.Definition.Alert.AlertTypeSA + (*Profile_Rule)(nil), // 200: minder.v1.Profile.Rule + (*Profile_Selector)(nil), // 201: minder.v1.Profile.Selector + (*EvaluationHistory_Entity)(nil), // 202: minder.v1.EvaluationHistory.Entity + (*EvaluationHistory_Rule)(nil), // 203: minder.v1.EvaluationHistory.Rule + (*EvaluationHistory_Status)(nil), // 204: minder.v1.EvaluationHistory.Status + (*EvaluationHistory_Remediation)(nil), // 205: minder.v1.EvaluationHistory.Remediation + (*EvaluationHistory_Alert)(nil), // 206: minder.v1.EvaluationHistory.Alert (*timestamppb.Timestamp)(nil), // 207: google.protobuf.Timestamp (*structpb.Struct)(nil), // 208: google.protobuf.Struct (*fieldmaskpb.FieldMask)(nil), // 209: google.protobuf.FieldMask @@ -15419,9 +15414,9 @@ var file_minder_v1_minder_proto_depIdxs = []int32{ 94, // 16: minder.v1.PullRequest.context:type_name -> minder.v1.Context 3, // 17: minder.v1.Dependency.ecosystem:type_name -> minder.v1.DepEcosystem 21, // 18: minder.v1.PrDependencies.pr:type_name -> minder.v1.PullRequest - 178, // 19: minder.v1.PrDependencies.deps:type_name -> minder.v1.PrDependencies.ContextualDependency + 173, // 19: minder.v1.PrDependencies.deps:type_name -> minder.v1.PrDependencies.ContextualDependency 21, // 20: minder.v1.PrContents.pr:type_name -> minder.v1.PullRequest - 180, // 21: minder.v1.PrContents.files:type_name -> minder.v1.PrContents.File + 175, // 21: minder.v1.PrContents.files:type_name -> minder.v1.PrContents.File 207, // 22: minder.v1.GetInviteDetailsResponse.expires_at:type_name -> google.protobuf.Timestamp 94, // 23: minder.v1.GetAuthorizationURLRequest.context:type_name -> minder.v1.Context 208, // 24: minder.v1.GetAuthorizationURLRequest.config:type_name -> google.protobuf.Struct @@ -15437,7 +15432,7 @@ var file_minder_v1_minder_proto_depIdxs = []int32{ 36, // 34: minder.v1.RegisterRepositoryRequest.repository:type_name -> minder.v1.UpstreamRepositoryRef 94, // 35: minder.v1.RegisterRepositoryRequest.context:type_name -> minder.v1.Context 37, // 36: minder.v1.RegisterRepoResult.repository:type_name -> minder.v1.Repository - 182, // 37: minder.v1.RegisterRepoResult.status:type_name -> minder.v1.RegisterRepoResult.Status + 177, // 37: minder.v1.RegisterRepoResult.status:type_name -> minder.v1.RegisterRepoResult.Status 39, // 38: minder.v1.RegisterRepositoryResponse.result:type_name -> minder.v1.RegisterRepoResult 94, // 39: minder.v1.GetRepositoryByIdRequest.context:type_name -> minder.v1.Context 37, // 40: minder.v1.GetRepositoryByIdResponse.repository:type_name -> minder.v1.Repository @@ -15476,7 +15471,7 @@ var file_minder_v1_minder_proto_depIdxs = []int32{ 207, // 73: minder.v1.ProfileStatus.last_updated:type_name -> google.protobuf.Timestamp 207, // 74: minder.v1.EvalResultAlert.last_updated:type_name -> google.protobuf.Timestamp 207, // 75: minder.v1.RuleEvaluationStatus.last_updated:type_name -> google.protobuf.Timestamp - 183, // 76: minder.v1.RuleEvaluationStatus.entity_info:type_name -> minder.v1.RuleEvaluationStatus.EntityInfoEntry + 178, // 76: minder.v1.RuleEvaluationStatus.entity_info:type_name -> minder.v1.RuleEvaluationStatus.EntityInfoEntry 207, // 77: minder.v1.RuleEvaluationStatus.remediation_last_updated:type_name -> google.protobuf.Timestamp 79, // 78: minder.v1.RuleEvaluationStatus.alert:type_name -> minder.v1.EvalResultAlert 115, // 79: minder.v1.RuleEvaluationStatus.severity:type_name -> minder.v1.Severity @@ -15487,7 +15482,7 @@ var file_minder_v1_minder_proto_depIdxs = []int32{ 80, // 84: minder.v1.GetProfileStatusByNameResponse.rule_evaluation_status:type_name -> minder.v1.RuleEvaluationStatus 94, // 85: minder.v1.GetProfileStatusByProjectRequest.context:type_name -> minder.v1.Context 78, // 86: minder.v1.GetProfileStatusByProjectResponse.profile_status:type_name -> minder.v1.ProfileStatus - 184, // 87: minder.v1.AutoRegistration.entities:type_name -> minder.v1.AutoRegistration.EntitiesEntry + 179, // 87: minder.v1.AutoRegistration.entities:type_name -> minder.v1.AutoRegistration.EntitiesEntry 87, // 88: minder.v1.ProviderConfig.auto_registration:type_name -> minder.v1.AutoRegistration 94, // 89: minder.v1.ListRuleTypesRequest.context:type_name -> minder.v1.Context 116, // 90: minder.v1.ListRuleTypesResponse.rule_types:type_name -> minder.v1.RuleType @@ -15502,19 +15497,19 @@ var file_minder_v1_minder_proto_depIdxs = []int32{ 94, // 99: minder.v1.DeleteRuleTypeRequest.context:type_name -> minder.v1.Context 94, // 100: minder.v1.ListEvaluationResultsRequest.context:type_name -> minder.v1.Context 81, // 101: minder.v1.ListEvaluationResultsRequest.entity:type_name -> minder.v1.EntityTypedId - 186, // 102: minder.v1.ListEvaluationResultsResponse.entities:type_name -> minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults - 187, // 103: minder.v1.RestType.fallback:type_name -> minder.v1.RestType.Fallback - 188, // 104: minder.v1.DiffType.ecosystems:type_name -> minder.v1.DiffType.Ecosystem + 181, // 102: minder.v1.ListEvaluationResultsResponse.entities:type_name -> minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults + 182, // 103: minder.v1.RestType.fallback:type_name -> minder.v1.RestType.Fallback + 183, // 104: minder.v1.DiffType.ecosystems:type_name -> minder.v1.DiffType.Ecosystem 9, // 105: minder.v1.Severity.value:type_name -> minder.v1.Severity.Value 94, // 106: minder.v1.RuleType.context:type_name -> minder.v1.Context - 189, // 107: minder.v1.RuleType.def:type_name -> minder.v1.RuleType.Definition + 184, // 107: minder.v1.RuleType.def:type_name -> minder.v1.RuleType.Definition 115, // 108: minder.v1.RuleType.severity:type_name -> minder.v1.Severity 94, // 109: minder.v1.Profile.context:type_name -> minder.v1.Context - 205, // 110: minder.v1.Profile.repository:type_name -> minder.v1.Profile.Rule - 205, // 111: minder.v1.Profile.build_environment:type_name -> minder.v1.Profile.Rule - 205, // 112: minder.v1.Profile.artifact:type_name -> minder.v1.Profile.Rule - 205, // 113: minder.v1.Profile.pull_request:type_name -> minder.v1.Profile.Rule - 206, // 114: minder.v1.Profile.selection:type_name -> minder.v1.Profile.Selector + 200, // 110: minder.v1.Profile.repository:type_name -> minder.v1.Profile.Rule + 200, // 111: minder.v1.Profile.build_environment:type_name -> minder.v1.Profile.Rule + 200, // 112: minder.v1.Profile.artifact:type_name -> minder.v1.Profile.Rule + 200, // 113: minder.v1.Profile.pull_request:type_name -> minder.v1.Profile.Rule + 201, // 114: minder.v1.Profile.selection:type_name -> minder.v1.Profile.Selector 33, // 115: minder.v1.ListProjectsResponse.projects:type_name -> minder.v1.Project 94, // 116: minder.v1.CreateProjectRequest.context:type_name -> minder.v1.Context 33, // 117: minder.v1.CreateProjectResponse.project:type_name -> minder.v1.Project @@ -15576,47 +15571,47 @@ var file_minder_v1_minder_proto_depIdxs = []int32{ 11, // 173: minder.v1.ListEvaluationHistoryRequest.cursor:type_name -> minder.v1.Cursor 172, // 174: minder.v1.ListEvaluationHistoryResponse.data:type_name -> minder.v1.EvaluationHistory 12, // 175: minder.v1.ListEvaluationHistoryResponse.page:type_name -> minder.v1.CursorPage - 173, // 176: minder.v1.EvaluationHistory.entity:type_name -> minder.v1.EvaluationHistoryEntity - 174, // 177: minder.v1.EvaluationHistory.rule:type_name -> minder.v1.EvaluationHistoryRule - 175, // 178: minder.v1.EvaluationHistory.status:type_name -> minder.v1.EvaluationHistoryStatus - 177, // 179: minder.v1.EvaluationHistory.alert:type_name -> minder.v1.EvaluationHistoryAlert - 176, // 180: minder.v1.EvaluationHistory.remediation:type_name -> minder.v1.EvaluationHistoryRemediation - 4, // 181: minder.v1.EvaluationHistoryEntity.type:type_name -> minder.v1.Entity - 207, // 182: minder.v1.EvaluationHistoryStatus.evaluated_at:type_name -> google.protobuf.Timestamp - 22, // 183: minder.v1.PrDependencies.ContextualDependency.dep:type_name -> minder.v1.Dependency - 179, // 184: minder.v1.PrDependencies.ContextualDependency.file:type_name -> minder.v1.PrDependencies.ContextualDependency.FilePatch - 181, // 185: minder.v1.PrContents.File.patch_lines:type_name -> minder.v1.PrContents.File.Line - 86, // 186: minder.v1.AutoRegistration.EntitiesEntry.value:type_name -> minder.v1.EntityAutoRegistrationConfig - 78, // 187: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults.profile_status:type_name -> minder.v1.ProfileStatus - 80, // 188: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults.results:type_name -> minder.v1.RuleEvaluationStatus - 81, // 189: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults.entity:type_name -> minder.v1.EntityTypedId - 185, // 190: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults.profiles:type_name -> minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults - 208, // 191: minder.v1.RuleType.Definition.rule_schema:type_name -> google.protobuf.Struct - 208, // 192: minder.v1.RuleType.Definition.param_schema:type_name -> google.protobuf.Struct - 190, // 193: minder.v1.RuleType.Definition.ingest:type_name -> minder.v1.RuleType.Definition.Ingest - 191, // 194: minder.v1.RuleType.Definition.eval:type_name -> minder.v1.RuleType.Definition.Eval - 192, // 195: minder.v1.RuleType.Definition.remediate:type_name -> minder.v1.RuleType.Definition.Remediate - 193, // 196: minder.v1.RuleType.Definition.alert:type_name -> minder.v1.RuleType.Definition.Alert - 110, // 197: minder.v1.RuleType.Definition.Ingest.rest:type_name -> minder.v1.RestType - 111, // 198: minder.v1.RuleType.Definition.Ingest.builtin:type_name -> minder.v1.BuiltinType - 112, // 199: minder.v1.RuleType.Definition.Ingest.artifact:type_name -> minder.v1.ArtifactType - 113, // 200: minder.v1.RuleType.Definition.Ingest.git:type_name -> minder.v1.GitType - 114, // 201: minder.v1.RuleType.Definition.Ingest.diff:type_name -> minder.v1.DiffType - 194, // 202: minder.v1.RuleType.Definition.Eval.jq:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison - 195, // 203: minder.v1.RuleType.Definition.Eval.rego:type_name -> minder.v1.RuleType.Definition.Eval.Rego - 196, // 204: minder.v1.RuleType.Definition.Eval.vulncheck:type_name -> minder.v1.RuleType.Definition.Eval.Vulncheck - 197, // 205: minder.v1.RuleType.Definition.Eval.trusty:type_name -> minder.v1.RuleType.Definition.Eval.Trusty - 198, // 206: minder.v1.RuleType.Definition.Eval.homoglyphs:type_name -> minder.v1.RuleType.Definition.Eval.Homoglyphs - 110, // 207: minder.v1.RuleType.Definition.Remediate.rest:type_name -> minder.v1.RestType - 200, // 208: minder.v1.RuleType.Definition.Remediate.gh_branch_protection:type_name -> minder.v1.RuleType.Definition.Remediate.GhBranchProtectionType - 201, // 209: minder.v1.RuleType.Definition.Remediate.pull_request:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation - 204, // 210: minder.v1.RuleType.Definition.Alert.security_advisory:type_name -> minder.v1.RuleType.Definition.Alert.AlertTypeSA - 199, // 211: minder.v1.RuleType.Definition.Eval.JQComparison.ingested:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison.Operator - 199, // 212: minder.v1.RuleType.Definition.Eval.JQComparison.profile:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison.Operator - 202, // 213: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.contents:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.Content - 203, // 214: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.actions_replace_tags_with_sha:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.ActionsReplaceTagsWithSha - 208, // 215: minder.v1.Profile.Rule.params:type_name -> google.protobuf.Struct - 208, // 216: minder.v1.Profile.Rule.def:type_name -> google.protobuf.Struct + 202, // 176: minder.v1.EvaluationHistory.entity:type_name -> minder.v1.EvaluationHistory.Entity + 203, // 177: minder.v1.EvaluationHistory.rule:type_name -> minder.v1.EvaluationHistory.Rule + 204, // 178: minder.v1.EvaluationHistory.status:type_name -> minder.v1.EvaluationHistory.Status + 206, // 179: minder.v1.EvaluationHistory.alert:type_name -> minder.v1.EvaluationHistory.Alert + 205, // 180: minder.v1.EvaluationHistory.remediation:type_name -> minder.v1.EvaluationHistory.Remediation + 22, // 181: minder.v1.PrDependencies.ContextualDependency.dep:type_name -> minder.v1.Dependency + 174, // 182: minder.v1.PrDependencies.ContextualDependency.file:type_name -> minder.v1.PrDependencies.ContextualDependency.FilePatch + 176, // 183: minder.v1.PrContents.File.patch_lines:type_name -> minder.v1.PrContents.File.Line + 86, // 184: minder.v1.AutoRegistration.EntitiesEntry.value:type_name -> minder.v1.EntityAutoRegistrationConfig + 78, // 185: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults.profile_status:type_name -> minder.v1.ProfileStatus + 80, // 186: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults.results:type_name -> minder.v1.RuleEvaluationStatus + 81, // 187: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults.entity:type_name -> minder.v1.EntityTypedId + 180, // 188: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults.profiles:type_name -> minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults + 208, // 189: minder.v1.RuleType.Definition.rule_schema:type_name -> google.protobuf.Struct + 208, // 190: minder.v1.RuleType.Definition.param_schema:type_name -> google.protobuf.Struct + 185, // 191: minder.v1.RuleType.Definition.ingest:type_name -> minder.v1.RuleType.Definition.Ingest + 186, // 192: minder.v1.RuleType.Definition.eval:type_name -> minder.v1.RuleType.Definition.Eval + 187, // 193: minder.v1.RuleType.Definition.remediate:type_name -> minder.v1.RuleType.Definition.Remediate + 188, // 194: minder.v1.RuleType.Definition.alert:type_name -> minder.v1.RuleType.Definition.Alert + 110, // 195: minder.v1.RuleType.Definition.Ingest.rest:type_name -> minder.v1.RestType + 111, // 196: minder.v1.RuleType.Definition.Ingest.builtin:type_name -> minder.v1.BuiltinType + 112, // 197: minder.v1.RuleType.Definition.Ingest.artifact:type_name -> minder.v1.ArtifactType + 113, // 198: minder.v1.RuleType.Definition.Ingest.git:type_name -> minder.v1.GitType + 114, // 199: minder.v1.RuleType.Definition.Ingest.diff:type_name -> minder.v1.DiffType + 189, // 200: minder.v1.RuleType.Definition.Eval.jq:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison + 190, // 201: minder.v1.RuleType.Definition.Eval.rego:type_name -> minder.v1.RuleType.Definition.Eval.Rego + 191, // 202: minder.v1.RuleType.Definition.Eval.vulncheck:type_name -> minder.v1.RuleType.Definition.Eval.Vulncheck + 192, // 203: minder.v1.RuleType.Definition.Eval.trusty:type_name -> minder.v1.RuleType.Definition.Eval.Trusty + 193, // 204: minder.v1.RuleType.Definition.Eval.homoglyphs:type_name -> minder.v1.RuleType.Definition.Eval.Homoglyphs + 110, // 205: minder.v1.RuleType.Definition.Remediate.rest:type_name -> minder.v1.RestType + 195, // 206: minder.v1.RuleType.Definition.Remediate.gh_branch_protection:type_name -> minder.v1.RuleType.Definition.Remediate.GhBranchProtectionType + 196, // 207: minder.v1.RuleType.Definition.Remediate.pull_request:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation + 199, // 208: minder.v1.RuleType.Definition.Alert.security_advisory:type_name -> minder.v1.RuleType.Definition.Alert.AlertTypeSA + 194, // 209: minder.v1.RuleType.Definition.Eval.JQComparison.ingested:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison.Operator + 194, // 210: minder.v1.RuleType.Definition.Eval.JQComparison.profile:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison.Operator + 197, // 211: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.contents:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.Content + 198, // 212: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.actions_replace_tags_with_sha:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.ActionsReplaceTagsWithSha + 208, // 213: minder.v1.Profile.Rule.params:type_name -> google.protobuf.Struct + 208, // 214: minder.v1.Profile.Rule.def:type_name -> google.protobuf.Struct + 4, // 215: minder.v1.EvaluationHistory.Entity.type:type_name -> minder.v1.Entity + 207, // 216: minder.v1.EvaluationHistory.Status.evaluated_at:type_name -> google.protobuf.Timestamp 210, // 217: minder.v1.name:extendee -> google.protobuf.EnumValueOptions 211, // 218: minder.v1.rpc_options:extendee -> google.protobuf.MethodOptions 10, // 219: minder.v1.rpc_options:type_name -> minder.v1.RpcOptions @@ -17706,7 +17701,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[163].Exporter = func(v any, i int) any { - switch v := v.(*EvaluationHistoryEntity); i { + switch v := v.(*PrDependencies_ContextualDependency); i { case 0: return &v.state case 1: @@ -17718,7 +17713,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[164].Exporter = func(v any, i int) any { - switch v := v.(*EvaluationHistoryRule); i { + switch v := v.(*PrDependencies_ContextualDependency_FilePatch); i { case 0: return &v.state case 1: @@ -17730,7 +17725,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[165].Exporter = func(v any, i int) any { - switch v := v.(*EvaluationHistoryStatus); i { + switch v := v.(*PrContents_File); i { case 0: return &v.state case 1: @@ -17742,7 +17737,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[166].Exporter = func(v any, i int) any { - switch v := v.(*EvaluationHistoryRemediation); i { + switch v := v.(*PrContents_File_Line); i { case 0: return &v.state case 1: @@ -17754,7 +17749,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[167].Exporter = func(v any, i int) any { - switch v := v.(*EvaluationHistoryAlert); i { + switch v := v.(*RegisterRepoResult_Status); i { case 0: return &v.state case 1: @@ -17765,8 +17760,8 @@ func file_minder_v1_minder_proto_init() { return nil } } - file_minder_v1_minder_proto_msgTypes[168].Exporter = func(v any, i int) any { - switch v := v.(*PrDependencies_ContextualDependency); i { + file_minder_v1_minder_proto_msgTypes[170].Exporter = func(v any, i int) any { + switch v := v.(*ListEvaluationResultsResponse_EntityProfileEvaluationResults); i { case 0: return &v.state case 1: @@ -17777,8 +17772,8 @@ func file_minder_v1_minder_proto_init() { return nil } } - file_minder_v1_minder_proto_msgTypes[169].Exporter = func(v any, i int) any { - switch v := v.(*PrDependencies_ContextualDependency_FilePatch); i { + file_minder_v1_minder_proto_msgTypes[171].Exporter = func(v any, i int) any { + switch v := v.(*ListEvaluationResultsResponse_EntityEvaluationResults); i { case 0: return &v.state case 1: @@ -17789,8 +17784,8 @@ func file_minder_v1_minder_proto_init() { return nil } } - file_minder_v1_minder_proto_msgTypes[170].Exporter = func(v any, i int) any { - switch v := v.(*PrContents_File); i { + file_minder_v1_minder_proto_msgTypes[172].Exporter = func(v any, i int) any { + switch v := v.(*RestType_Fallback); i { case 0: return &v.state case 1: @@ -17801,8 +17796,8 @@ func file_minder_v1_minder_proto_init() { return nil } } - file_minder_v1_minder_proto_msgTypes[171].Exporter = func(v any, i int) any { - switch v := v.(*PrContents_File_Line); i { + file_minder_v1_minder_proto_msgTypes[173].Exporter = func(v any, i int) any { + switch v := v.(*DiffType_Ecosystem); i { case 0: return &v.state case 1: @@ -17813,8 +17808,8 @@ func file_minder_v1_minder_proto_init() { return nil } } - file_minder_v1_minder_proto_msgTypes[172].Exporter = func(v any, i int) any { - switch v := v.(*RegisterRepoResult_Status); i { + file_minder_v1_minder_proto_msgTypes[174].Exporter = func(v any, i int) any { + switch v := v.(*RuleType_Definition); i { case 0: return &v.state case 1: @@ -17826,7 +17821,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[175].Exporter = func(v any, i int) any { - switch v := v.(*ListEvaluationResultsResponse_EntityProfileEvaluationResults); i { + switch v := v.(*RuleType_Definition_Ingest); i { case 0: return &v.state case 1: @@ -17838,7 +17833,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[176].Exporter = func(v any, i int) any { - switch v := v.(*ListEvaluationResultsResponse_EntityEvaluationResults); i { + switch v := v.(*RuleType_Definition_Eval); i { case 0: return &v.state case 1: @@ -17850,7 +17845,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[177].Exporter = func(v any, i int) any { - switch v := v.(*RestType_Fallback); i { + switch v := v.(*RuleType_Definition_Remediate); i { case 0: return &v.state case 1: @@ -17862,7 +17857,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[178].Exporter = func(v any, i int) any { - switch v := v.(*DiffType_Ecosystem); i { + switch v := v.(*RuleType_Definition_Alert); i { case 0: return &v.state case 1: @@ -17874,7 +17869,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[179].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition); i { + switch v := v.(*RuleType_Definition_Eval_JQComparison); i { case 0: return &v.state case 1: @@ -17886,7 +17881,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[180].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Ingest); i { + switch v := v.(*RuleType_Definition_Eval_Rego); i { case 0: return &v.state case 1: @@ -17898,7 +17893,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[181].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Eval); i { + switch v := v.(*RuleType_Definition_Eval_Vulncheck); i { case 0: return &v.state case 1: @@ -17910,7 +17905,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[182].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Remediate); i { + switch v := v.(*RuleType_Definition_Eval_Trusty); i { case 0: return &v.state case 1: @@ -17922,7 +17917,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[183].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Alert); i { + switch v := v.(*RuleType_Definition_Eval_Homoglyphs); i { case 0: return &v.state case 1: @@ -17934,7 +17929,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[184].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Eval_JQComparison); i { + switch v := v.(*RuleType_Definition_Eval_JQComparison_Operator); i { case 0: return &v.state case 1: @@ -17946,7 +17941,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[185].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Eval_Rego); i { + switch v := v.(*RuleType_Definition_Remediate_GhBranchProtectionType); i { case 0: return &v.state case 1: @@ -17958,7 +17953,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[186].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Eval_Vulncheck); i { + switch v := v.(*RuleType_Definition_Remediate_PullRequestRemediation); i { case 0: return &v.state case 1: @@ -17970,7 +17965,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[187].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Eval_Trusty); i { + switch v := v.(*RuleType_Definition_Remediate_PullRequestRemediation_Content); i { case 0: return &v.state case 1: @@ -17982,7 +17977,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[188].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Eval_Homoglyphs); i { + switch v := v.(*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha); i { case 0: return &v.state case 1: @@ -17994,7 +17989,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[189].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Eval_JQComparison_Operator); i { + switch v := v.(*RuleType_Definition_Alert_AlertTypeSA); i { case 0: return &v.state case 1: @@ -18006,7 +18001,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[190].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Remediate_GhBranchProtectionType); i { + switch v := v.(*Profile_Rule); i { case 0: return &v.state case 1: @@ -18018,7 +18013,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[191].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Remediate_PullRequestRemediation); i { + switch v := v.(*Profile_Selector); i { case 0: return &v.state case 1: @@ -18030,7 +18025,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[192].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Remediate_PullRequestRemediation_Content); i { + switch v := v.(*EvaluationHistory_Entity); i { case 0: return &v.state case 1: @@ -18042,7 +18037,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[193].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha); i { + switch v := v.(*EvaluationHistory_Rule); i { case 0: return &v.state case 1: @@ -18054,7 +18049,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[194].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Alert_AlertTypeSA); i { + switch v := v.(*EvaluationHistory_Status); i { case 0: return &v.state case 1: @@ -18066,7 +18061,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[195].Exporter = func(v any, i int) any { - switch v := v.(*Profile_Rule); i { + switch v := v.(*EvaluationHistory_Remediation); i { case 0: return &v.state case 1: @@ -18078,7 +18073,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[196].Exporter = func(v any, i int) any { - switch v := v.(*Profile_Selector); i { + switch v := v.(*EvaluationHistory_Alert); i { case 0: return &v.state case 1: @@ -18115,15 +18110,15 @@ func file_minder_v1_minder_proto_init() { file_minder_v1_minder_proto_msgTypes[157].OneofWrappers = []any{ (*ProviderParameter_GithubApp)(nil), } - file_minder_v1_minder_proto_msgTypes[172].OneofWrappers = []any{} - file_minder_v1_minder_proto_msgTypes[179].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[167].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[174].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[175].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[176].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[177].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[178].OneofWrappers = []any{} file_minder_v1_minder_proto_msgTypes[180].OneofWrappers = []any{} - file_minder_v1_minder_proto_msgTypes[181].OneofWrappers = []any{} - file_minder_v1_minder_proto_msgTypes[182].OneofWrappers = []any{} - file_minder_v1_minder_proto_msgTypes[183].OneofWrappers = []any{} - file_minder_v1_minder_proto_msgTypes[185].OneofWrappers = []any{} - file_minder_v1_minder_proto_msgTypes[191].OneofWrappers = []any{} - file_minder_v1_minder_proto_msgTypes[192].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[186].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[187].OneofWrappers = []any{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ diff --git a/proto/minder/v1/minder.proto b/proto/minder/v1/minder.proto index ca23a07d02..44afc73680 100644 --- a/proto/minder/v1/minder.proto +++ b/proto/minder/v1/minder.proto @@ -2563,73 +2563,73 @@ message ListEvaluationHistoryResponse { } message EvaluationHistory { - // entity contains details of the entity which was evaluated. - EvaluationHistoryEntity entity = 1; + message Entity { + // id is the ID of the entity. + string id = 1; - // rule contains details of the rule which the entity was evaluated against. - EvaluationHistoryRule rule = 2; + // type is the entity type. + minder.v1.Entity type = 2; - // status contains the evaluation status. - EvaluationHistoryStatus status = 3; + // name is the entity name. + string name = 3; + } - // alert contains details of the alerts for this evaluation. - EvaluationHistoryAlert alert = 4; + message Rule { + // name is the name of the rule instance. + string name = 1; - // remediation contains details of the remediation for this evaluation. - EvaluationHistoryRemediation remediation = 5; -} + // type is the name of the rule type. + string type = 2; -message EvaluationHistoryEntity { - // id is the ID of the entity. - string id = 1; + // profile is the name of the profile which contains the rule. + string profile = 3; + } - // type is the entity type. - Entity type = 2; + message Status { + // status is one of (success, error, failure, skipped) + // not using enums to mirror the behaviour of the existing API contracts. + string status = 1; - // name is the entity name. - string name = 3; -} + // details contains optional details about the evaluation. + // the structure and contents are rule type specific, and are subject to change. + string details = 2; -message EvaluationHistoryRule { - // name is the name of the rule instance. - string name = 1; + // created_at is the timestamp of creation of this evaluation + google.protobuf.Timestamp evaluated_at = 3; + } - // type is the name of the rule type. - string type = 2; + message Remediation { + // status is one of (success, error, failure, skipped, not available) + // not using enums to mirror the behaviour of the existing API contracts. + string status = 1; - // profile is the name of the profile which contains the rule. - string profile = 3; -} + // details contains optional details about the remediation. + // the structure and contents are remediation specific, and are subject to change. + string details = 2; + } -message EvaluationHistoryStatus { - // status is one of (success, error, failure, skipped) - // not using enums to mirror the behaviour of the existing API contracts. - string status = 1; + message Alert { + // status is one of (on, off, error, skipped, not available) + // not using enums to mirror the behaviour of the existing API contracts. + string status = 1; - // details contains optional details about the evaluation. - // the structure and contents are rule type specific, and are subject to change. - string details = 2; + // details contains optional details about the alert. + // the structure and contents are alert specific, and are subject to change. + string details = 2; + } - // created_at is the timestamp of creation of this evaluation - google.protobuf.Timestamp evaluated_at = 3; -} + // entity contains details of the entity which was evaluated. + EvaluationHistory.Entity entity = 1; -message EvaluationHistoryRemediation { - // status is one of (success, error, failure, skipped, not available) - // not using enums to mirror the behaviour of the existing API contracts. - string status = 1; + // rule contains details of the rule which the entity was evaluated against. + EvaluationHistory.Rule rule = 2; - // details contains optional details about the remediation. - // the structure and contents are remediation specific, and are subject to change. - string details = 2; -} + // status contains the evaluation status. + EvaluationHistory.Status status = 3; -message EvaluationHistoryAlert { - // status is one of (on, off, error, skipped, not available) - // not using enums to mirror the behaviour of the existing API contracts. - string status = 1; + // alert contains details of the alerts for this evaluation. + EvaluationHistory.Alert alert = 4; - // details contains optional details about the alert. - // the structure and contents are alert specific, and are subject to change. - string details = 2; + // remediation contains details of the remediation for this evaluation. + EvaluationHistory.Remediation remediation = 5; } From e5f701d76b51ae210169d9e44cd61eeafc159445 Mon Sep 17 00:00:00 2001 From: Michelangelo Mori Date: Tue, 9 Jul 2024 11:40:52 +0200 Subject: [PATCH 11/13] Revert "Embed proto messages specific to EvaluationHistory." This reverts commit 572ab4e303687390206f218f6859d25ca8155aa6. --- docs/docs/ref/proto.md | 20 +- internal/controlplane/handlers_evalstatus.go | 14 +- pkg/api/openapi/minder/v1/minder.swagger.json | 132 +- pkg/api/protobuf/go/minder/v1/minder.pb.go | 3511 +++++++++-------- proto/minder/v1/minder.proto | 104 +- 5 files changed, 1893 insertions(+), 1888 deletions(-) diff --git a/docs/docs/ref/proto.md b/docs/docs/ref/proto.md index 3134e077e9..b269f6ec09 100644 --- a/docs/docs/ref/proto.md +++ b/docs/docs/ref/proto.md @@ -798,15 +798,15 @@ EvalResultAlert holds the alert details for a given rule evaluation | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | -| entity | EvaluationHistory.Entity | | entity contains details of the entity which was evaluated. | -| rule | EvaluationHistory.Rule | | rule contains details of the rule which the entity was evaluated against. | -| status | EvaluationHistory.Status | | status contains the evaluation status. | -| alert | EvaluationHistory.Alert | | alert contains details of the alerts for this evaluation. | -| remediation | EvaluationHistory.Remediation | | remediation contains details of the remediation for this evaluation. | +| entity | EvaluationHistoryEntity | | entity contains details of the entity which was evaluated. | +| rule | EvaluationHistoryRule | | rule contains details of the rule which the entity was evaluated against. | +| status | EvaluationHistoryStatus | | status contains the evaluation status. | +| alert | EvaluationHistoryAlert | | alert contains details of the alerts for this evaluation. | +| remediation | EvaluationHistoryRemediation | | remediation contains details of the remediation for this evaluation. | -EvaluationHistory.Alert +EvaluationHistoryAlert @@ -818,7 +818,7 @@ EvalResultAlert holds the alert details for a given rule evaluation -EvaluationHistory.Entity +EvaluationHistoryEntity @@ -831,7 +831,7 @@ EvalResultAlert holds the alert details for a given rule evaluation -EvaluationHistory.Remediation +EvaluationHistoryRemediation @@ -843,7 +843,7 @@ EvalResultAlert holds the alert details for a given rule evaluation -EvaluationHistory.Rule +EvaluationHistoryRule @@ -856,7 +856,7 @@ EvalResultAlert holds the alert details for a given rule evaluation -EvaluationHistory.Status +EvaluationHistoryStatus diff --git a/internal/controlplane/handlers_evalstatus.go b/internal/controlplane/handlers_evalstatus.go index 7359a3833d..18278f3d76 100644 --- a/internal/controlplane/handlers_evalstatus.go +++ b/internal/controlplane/handlers_evalstatus.go @@ -144,33 +144,33 @@ func fromEvaluationHistoryRow( return nil, errors.New("internal error") } - var alert *minderv1.EvaluationHistory_Alert + var alert *minderv1.EvaluationHistoryAlert if row.AlertStatus.Valid { - alert = &minderv1.EvaluationHistory_Alert{ + alert = &minderv1.EvaluationHistoryAlert{ Status: string(row.AlertStatus.AlertStatusTypes), Details: row.AlertDetails.String, } } - var remediation *minderv1.EvaluationHistory_Remediation + var remediation *minderv1.EvaluationHistoryRemediation if row.RemediationStatus.Valid { - remediation = &minderv1.EvaluationHistory_Remediation{ + remediation = &minderv1.EvaluationHistoryRemediation{ Status: string(row.RemediationStatus.RemediationStatusTypes), Details: row.RemediationDetails.String, } } res = append(res, &minderv1.EvaluationHistory{ - Entity: &minderv1.EvaluationHistory_Entity{ + Entity: &minderv1.EvaluationHistoryEntity{ Id: row.EvaluationID.String(), Type: entityType, Name: entityName, }, - Rule: &minderv1.EvaluationHistory_Rule{ + Rule: &minderv1.EvaluationHistoryRule{ Name: row.RuleName, Type: row.RuleType, Profile: row.ProfileName, }, - Status: &minderv1.EvaluationHistory_Status{ + Status: &minderv1.EvaluationHistoryStatus{ Status: string(row.EvaluationStatus), Details: row.EvaluationDetails, EvaluatedAt: timestamppb.New(row.EvaluatedAt), diff --git a/pkg/api/openapi/minder/v1/minder.swagger.json b/pkg/api/openapi/minder/v1/minder.swagger.json index a06a79eedd..c0fdecfbb9 100644 --- a/pkg/api/openapi/minder/v1/minder.swagger.json +++ b/pkg/api/openapi/minder/v1/minder.swagger.json @@ -2784,6 +2784,17 @@ } } }, + "DefinitionAlert": { + "type": "object", + "properties": { + "type": { + "type": "string" + }, + "securityAdvisory": { + "$ref": "#/definitions/AlertAlertTypeSA" + } + } + }, "DefinitionEval": { "type": "object", "properties": { @@ -2929,19 +2940,6 @@ "type": "object", "title": "no configuration for now" }, - "EvaluationHistoryRemediation": { - "type": "object", - "properties": { - "status": { - "type": "string", - "description": "status is one of (success, error, failure, skipped, not available)\nnot using enums to mirror the behaviour of the existing API contracts." - }, - "details": { - "type": "string", - "description": "details contains optional details about the remediation.\nthe structure and contents are remediation specific, and are subject to change." - } - } - }, "JQComparisonOperator": { "type": "object", "properties": { @@ -2996,6 +2994,28 @@ } } }, + "ProfileRule": { + "type": "object", + "properties": { + "type": { + "type": "string", + "description": "type is the type of the rule to be instantiated." + }, + "params": { + "type": "object", + "description": "params are the parameters that are passed to the rule.\nThis is optional and depends on the rule type." + }, + "def": { + "type": "object", + "description": "def is the definition of the rule.\nThis depends on the rule type." + }, + "name": { + "type": "string", + "title": "name is the descriptive name of the rule, not to be confused with type" + } + }, + "description": "Rule defines the individual call of a certain rule type." + }, "ProfileSelector": { "type": "object", "properties": { @@ -3135,34 +3155,11 @@ "$ref": "#/definitions/DefinitionRemediate" }, "alert": { - "$ref": "#/definitions/RuleTypeDefinitionAlert" + "$ref": "#/definitions/DefinitionAlert" } }, "description": "Definition defines the rule type. It encompases the schema and the data evaluation." }, - "RuleTypeDefinitionAlert": { - "type": "object", - "properties": { - "type": { - "type": "string" - }, - "securityAdvisory": { - "$ref": "#/definitions/AlertAlertTypeSA" - } - } - }, - "minderv1Entity": { - "type": "string", - "enum": [ - "ENTITY_UNSPECIFIED", - "ENTITY_REPOSITORIES", - "ENTITY_BUILD_ENVIRONMENTS", - "ENTITY_ARTIFACTS", - "ENTITY_PULL_REQUESTS" - ], - "default": "ENTITY_UNSPECIFIED", - "description": "Entity defines the entity that is supported by the provider." - }, "protobufNullValue": { "type": "string", "enum": [ @@ -3569,11 +3566,23 @@ }, "description": "DiffType defines the diff data ingester." }, + "v1Entity": { + "type": "string", + "enum": [ + "ENTITY_UNSPECIFIED", + "ENTITY_REPOSITORIES", + "ENTITY_BUILD_ENVIRONMENTS", + "ENTITY_ARTIFACTS", + "ENTITY_PULL_REQUESTS" + ], + "default": "ENTITY_UNSPECIFIED", + "description": "Entity defines the entity that is supported by the provider." + }, "v1EntityTypedId": { "type": "object", "properties": { "type": { - "$ref": "#/definitions/minderv1Entity", + "$ref": "#/definitions/v1Entity", "title": "entity is the entity to get status for. Incompatible with `all`" }, "id": { @@ -3626,7 +3635,7 @@ "description": "alert contains details of the alerts for this evaluation." }, "remediation": { - "$ref": "#/definitions/EvaluationHistoryRemediation", + "$ref": "#/definitions/v1EvaluationHistoryRemediation", "description": "remediation contains details of the remediation for this evaluation." } } @@ -3652,7 +3661,7 @@ "description": "id is the ID of the entity." }, "type": { - "$ref": "#/definitions/minderv1Entity", + "$ref": "#/definitions/v1Entity", "description": "type is the entity type." }, "name": { @@ -3661,6 +3670,19 @@ } } }, + "v1EvaluationHistoryRemediation": { + "type": "object", + "properties": { + "status": { + "type": "string", + "description": "status is one of (success, error, failure, skipped, not available)\nnot using enums to mirror the behaviour of the existing API contracts." + }, + "details": { + "type": "string", + "description": "details contains optional details about the remediation.\nthe structure and contents are remediation specific, and are subject to change." + } + } + }, "v1EvaluationHistoryRule": { "type": "object", "properties": { @@ -4208,7 +4230,7 @@ "type": "array", "items": { "type": "object", - "$ref": "#/definitions/v1ProfileRule" + "$ref": "#/definitions/ProfileRule" }, "description": "These are the entities that one could set in the profile." }, @@ -4216,21 +4238,21 @@ "type": "array", "items": { "type": "object", - "$ref": "#/definitions/v1ProfileRule" + "$ref": "#/definitions/ProfileRule" } }, "artifact": { "type": "array", "items": { "type": "object", - "$ref": "#/definitions/v1ProfileRule" + "$ref": "#/definitions/ProfileRule" } }, "pullRequest": { "type": "array", "items": { "type": "object", - "$ref": "#/definitions/v1ProfileRule" + "$ref": "#/definitions/ProfileRule" } }, "selection": { @@ -4263,28 +4285,6 @@ }, "description": "Profile defines a profile that is user defined." }, - "v1ProfileRule": { - "type": "object", - "properties": { - "type": { - "type": "string", - "description": "type is the type of the rule to be instantiated." - }, - "params": { - "type": "object", - "description": "params are the parameters that are passed to the rule.\nThis is optional and depends on the rule type." - }, - "def": { - "type": "object", - "description": "def is the definition of the rule.\nThis depends on the rule type." - }, - "name": { - "type": "string", - "title": "name is the descriptive name of the rule, not to be confused with type" - } - }, - "description": "Rule defines the individual call of a certain rule type." - }, "v1ProfileStatus": { "type": "object", "properties": { diff --git a/pkg/api/protobuf/go/minder/v1/minder.pb.go b/pkg/api/protobuf/go/minder/v1/minder.pb.go index 02cc42200b..e53749f9b9 100644 --- a/pkg/api/protobuf/go/minder/v1/minder.pb.go +++ b/pkg/api/protobuf/go/minder/v1/minder.pb.go @@ -10667,15 +10667,15 @@ type EvaluationHistory struct { unknownFields protoimpl.UnknownFields // entity contains details of the entity which was evaluated. - Entity *EvaluationHistory_Entity `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"` + Entity *EvaluationHistoryEntity `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"` // rule contains details of the rule which the entity was evaluated against. - Rule *EvaluationHistory_Rule `protobuf:"bytes,2,opt,name=rule,proto3" json:"rule,omitempty"` + Rule *EvaluationHistoryRule `protobuf:"bytes,2,opt,name=rule,proto3" json:"rule,omitempty"` // status contains the evaluation status. - Status *EvaluationHistory_Status `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"` + Status *EvaluationHistoryStatus `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"` // alert contains details of the alerts for this evaluation. - Alert *EvaluationHistory_Alert `protobuf:"bytes,4,opt,name=alert,proto3" json:"alert,omitempty"` + Alert *EvaluationHistoryAlert `protobuf:"bytes,4,opt,name=alert,proto3" json:"alert,omitempty"` // remediation contains details of the remediation for this evaluation. - Remediation *EvaluationHistory_Remediation `protobuf:"bytes,5,opt,name=remediation,proto3" json:"remediation,omitempty"` + Remediation *EvaluationHistoryRemediation `protobuf:"bytes,5,opt,name=remediation,proto3" json:"remediation,omitempty"` } func (x *EvaluationHistory) Reset() { @@ -10710,52 +10710,56 @@ func (*EvaluationHistory) Descriptor() ([]byte, []int) { return file_minder_v1_minder_proto_rawDescGZIP(), []int{162} } -func (x *EvaluationHistory) GetEntity() *EvaluationHistory_Entity { +func (x *EvaluationHistory) GetEntity() *EvaluationHistoryEntity { if x != nil { return x.Entity } return nil } -func (x *EvaluationHistory) GetRule() *EvaluationHistory_Rule { +func (x *EvaluationHistory) GetRule() *EvaluationHistoryRule { if x != nil { return x.Rule } return nil } -func (x *EvaluationHistory) GetStatus() *EvaluationHistory_Status { +func (x *EvaluationHistory) GetStatus() *EvaluationHistoryStatus { if x != nil { return x.Status } return nil } -func (x *EvaluationHistory) GetAlert() *EvaluationHistory_Alert { +func (x *EvaluationHistory) GetAlert() *EvaluationHistoryAlert { if x != nil { return x.Alert } return nil } -func (x *EvaluationHistory) GetRemediation() *EvaluationHistory_Remediation { +func (x *EvaluationHistory) GetRemediation() *EvaluationHistoryRemediation { if x != nil { return x.Remediation } return nil } -type PrDependencies_ContextualDependency struct { +type EvaluationHistoryEntity struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Dep *Dependency `protobuf:"bytes,1,opt,name=dep,proto3" json:"dep,omitempty"` - File *PrDependencies_ContextualDependency_FilePatch `protobuf:"bytes,2,opt,name=file,proto3" json:"file,omitempty"` + // id is the ID of the entity. + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // type is the entity type. + Type Entity `protobuf:"varint,2,opt,name=type,proto3,enum=minder.v1.Entity" json:"type,omitempty"` + // name is the entity name. + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` } -func (x *PrDependencies_ContextualDependency) Reset() { - *x = PrDependencies_ContextualDependency{} +func (x *EvaluationHistoryEntity) Reset() { + *x = EvaluationHistoryEntity{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[163] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10763,13 +10767,13 @@ func (x *PrDependencies_ContextualDependency) Reset() { } } -func (x *PrDependencies_ContextualDependency) String() string { +func (x *EvaluationHistoryEntity) String() string { return protoimpl.X.MessageStringOf(x) } -func (*PrDependencies_ContextualDependency) ProtoMessage() {} +func (*EvaluationHistoryEntity) ProtoMessage() {} -func (x *PrDependencies_ContextualDependency) ProtoReflect() protoreflect.Message { +func (x *EvaluationHistoryEntity) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[163] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10781,36 +10785,47 @@ func (x *PrDependencies_ContextualDependency) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use PrDependencies_ContextualDependency.ProtoReflect.Descriptor instead. -func (*PrDependencies_ContextualDependency) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{13, 0} +// Deprecated: Use EvaluationHistoryEntity.ProtoReflect.Descriptor instead. +func (*EvaluationHistoryEntity) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{163} } -func (x *PrDependencies_ContextualDependency) GetDep() *Dependency { +func (x *EvaluationHistoryEntity) GetId() string { if x != nil { - return x.Dep + return x.Id } - return nil + return "" } -func (x *PrDependencies_ContextualDependency) GetFile() *PrDependencies_ContextualDependency_FilePatch { +func (x *EvaluationHistoryEntity) GetType() Entity { if x != nil { - return x.File + return x.Type } - return nil + return Entity_ENTITY_UNSPECIFIED } -type PrDependencies_ContextualDependency_FilePatch struct { +func (x *EvaluationHistoryEntity) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type EvaluationHistoryRule struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // file changed, e.g. package-lock.json - PatchUrl string `protobuf:"bytes,2,opt,name=patch_url,json=patchUrl,proto3" json:"patch_url,omitempty"` // points to the the raw patchfile + // name is the name of the rule instance. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // type is the name of the rule type. + Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"` + // profile is the name of the profile which contains the rule. + Profile string `protobuf:"bytes,3,opt,name=profile,proto3" json:"profile,omitempty"` } -func (x *PrDependencies_ContextualDependency_FilePatch) Reset() { - *x = PrDependencies_ContextualDependency_FilePatch{} +func (x *EvaluationHistoryRule) Reset() { + *x = EvaluationHistoryRule{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[164] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10818,13 +10833,13 @@ func (x *PrDependencies_ContextualDependency_FilePatch) Reset() { } } -func (x *PrDependencies_ContextualDependency_FilePatch) String() string { +func (x *EvaluationHistoryRule) String() string { return protoimpl.X.MessageStringOf(x) } -func (*PrDependencies_ContextualDependency_FilePatch) ProtoMessage() {} +func (*EvaluationHistoryRule) ProtoMessage() {} -func (x *PrDependencies_ContextualDependency_FilePatch) ProtoReflect() protoreflect.Message { +func (x *EvaluationHistoryRule) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[164] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10836,37 +10851,49 @@ func (x *PrDependencies_ContextualDependency_FilePatch) ProtoReflect() protorefl return mi.MessageOf(x) } -// Deprecated: Use PrDependencies_ContextualDependency_FilePatch.ProtoReflect.Descriptor instead. -func (*PrDependencies_ContextualDependency_FilePatch) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{13, 0, 0} +// Deprecated: Use EvaluationHistoryRule.ProtoReflect.Descriptor instead. +func (*EvaluationHistoryRule) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{164} } -func (x *PrDependencies_ContextualDependency_FilePatch) GetName() string { +func (x *EvaluationHistoryRule) GetName() string { if x != nil { return x.Name } return "" } -func (x *PrDependencies_ContextualDependency_FilePatch) GetPatchUrl() string { +func (x *EvaluationHistoryRule) GetType() string { if x != nil { - return x.PatchUrl + return x.Type } return "" } -type PrContents_File struct { +func (x *EvaluationHistoryRule) GetProfile() string { + if x != nil { + return x.Profile + } + return "" +} + +type EvaluationHistoryStatus struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - FilePatchUrl string `protobuf:"bytes,2,opt,name=file_patch_url,json=filePatchUrl,proto3" json:"file_patch_url,omitempty"` - PatchLines []*PrContents_File_Line `protobuf:"bytes,3,rep,name=patch_lines,json=patchLines,proto3" json:"patch_lines,omitempty"` + // status is one of (success, error, failure, skipped) + // not using enums to mirror the behaviour of the existing API contracts. + Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + // details contains optional details about the evaluation. + // the structure and contents are rule type specific, and are subject to change. + Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"` + // created_at is the timestamp of creation of this evaluation + EvaluatedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=evaluated_at,json=evaluatedAt,proto3" json:"evaluated_at,omitempty"` } -func (x *PrContents_File) Reset() { - *x = PrContents_File{} +func (x *EvaluationHistoryStatus) Reset() { + *x = EvaluationHistoryStatus{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[165] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10874,13 +10901,13 @@ func (x *PrContents_File) Reset() { } } -func (x *PrContents_File) String() string { +func (x *EvaluationHistoryStatus) String() string { return protoimpl.X.MessageStringOf(x) } -func (*PrContents_File) ProtoMessage() {} +func (*EvaluationHistoryStatus) ProtoMessage() {} -func (x *PrContents_File) ProtoReflect() protoreflect.Message { +func (x *EvaluationHistoryStatus) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[165] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10892,45 +10919,47 @@ func (x *PrContents_File) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use PrContents_File.ProtoReflect.Descriptor instead. -func (*PrContents_File) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{14, 0} +// Deprecated: Use EvaluationHistoryStatus.ProtoReflect.Descriptor instead. +func (*EvaluationHistoryStatus) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{165} } -func (x *PrContents_File) GetName() string { +func (x *EvaluationHistoryStatus) GetStatus() string { if x != nil { - return x.Name + return x.Status } return "" } -func (x *PrContents_File) GetFilePatchUrl() string { +func (x *EvaluationHistoryStatus) GetDetails() string { if x != nil { - return x.FilePatchUrl + return x.Details } return "" } -func (x *PrContents_File) GetPatchLines() []*PrContents_File_Line { +func (x *EvaluationHistoryStatus) GetEvaluatedAt() *timestamppb.Timestamp { if x != nil { - return x.PatchLines + return x.EvaluatedAt } return nil } -type PrContents_File_Line struct { +type EvaluationHistoryRemediation struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // Deliberately left as an int32: a diff with more than 2^31 lines - // could lead to various problems while processing. - LineNumber int32 `protobuf:"varint,1,opt,name=line_number,json=lineNumber,proto3" json:"line_number,omitempty"` - Content string `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"` + // status is one of (success, error, failure, skipped, not available) + // not using enums to mirror the behaviour of the existing API contracts. + Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + // details contains optional details about the remediation. + // the structure and contents are remediation specific, and are subject to change. + Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"` } -func (x *PrContents_File_Line) Reset() { - *x = PrContents_File_Line{} +func (x *EvaluationHistoryRemediation) Reset() { + *x = EvaluationHistoryRemediation{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[166] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10938,13 +10967,13 @@ func (x *PrContents_File_Line) Reset() { } } -func (x *PrContents_File_Line) String() string { +func (x *EvaluationHistoryRemediation) String() string { return protoimpl.X.MessageStringOf(x) } -func (*PrContents_File_Line) ProtoMessage() {} +func (*EvaluationHistoryRemediation) ProtoMessage() {} -func (x *PrContents_File_Line) ProtoReflect() protoreflect.Message { +func (x *EvaluationHistoryRemediation) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[166] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10956,36 +10985,40 @@ func (x *PrContents_File_Line) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use PrContents_File_Line.ProtoReflect.Descriptor instead. -func (*PrContents_File_Line) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{14, 0, 0} +// Deprecated: Use EvaluationHistoryRemediation.ProtoReflect.Descriptor instead. +func (*EvaluationHistoryRemediation) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{166} } -func (x *PrContents_File_Line) GetLineNumber() int32 { +func (x *EvaluationHistoryRemediation) GetStatus() string { if x != nil { - return x.LineNumber + return x.Status } - return 0 + return "" } -func (x *PrContents_File_Line) GetContent() string { +func (x *EvaluationHistoryRemediation) GetDetails() string { if x != nil { - return x.Content + return x.Details } return "" } -type RegisterRepoResult_Status struct { +type EvaluationHistoryAlert struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` - Error *string `protobuf:"bytes,2,opt,name=error,proto3,oneof" json:"error,omitempty"` + // status is one of (on, off, error, skipped, not available) + // not using enums to mirror the behaviour of the existing API contracts. + Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + // details contains optional details about the alert. + // the structure and contents are alert specific, and are subject to change. + Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"` } -func (x *RegisterRepoResult_Status) Reset() { - *x = RegisterRepoResult_Status{} +func (x *EvaluationHistoryAlert) Reset() { + *x = EvaluationHistoryAlert{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[167] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -10993,13 +11026,13 @@ func (x *RegisterRepoResult_Status) Reset() { } } -func (x *RegisterRepoResult_Status) String() string { +func (x *EvaluationHistoryAlert) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RegisterRepoResult_Status) ProtoMessage() {} +func (*EvaluationHistoryAlert) ProtoMessage() {} -func (x *RegisterRepoResult_Status) ProtoReflect() protoreflect.Message { +func (x *EvaluationHistoryAlert) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[167] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11011,54 +11044,51 @@ func (x *RegisterRepoResult_Status) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RegisterRepoResult_Status.ProtoReflect.Descriptor instead. -func (*RegisterRepoResult_Status) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{29, 0} +// Deprecated: Use EvaluationHistoryAlert.ProtoReflect.Descriptor instead. +func (*EvaluationHistoryAlert) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{167} } -func (x *RegisterRepoResult_Status) GetSuccess() bool { +func (x *EvaluationHistoryAlert) GetStatus() string { if x != nil { - return x.Success + return x.Status } - return false + return "" } -func (x *RegisterRepoResult_Status) GetError() string { - if x != nil && x.Error != nil { - return *x.Error +func (x *EvaluationHistoryAlert) GetDetails() string { + if x != nil { + return x.Details } return "" } -type ListEvaluationResultsResponse_EntityProfileEvaluationResults struct { +type PrDependencies_ContextualDependency struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // profile_status is the status of the profile - id, name, status, last_updated - ProfileStatus *ProfileStatus `protobuf:"bytes,1,opt,name=profile_status,json=profileStatus,proto3" json:"profile_status,omitempty"` - // Note that some fields like profile_id and entity might be empty - // Eventually we might replace this type with another one that fits the API better - Results []*RuleEvaluationStatus `protobuf:"bytes,2,rep,name=results,proto3" json:"results,omitempty"` + Dep *Dependency `protobuf:"bytes,1,opt,name=dep,proto3" json:"dep,omitempty"` + File *PrDependencies_ContextualDependency_FilePatch `protobuf:"bytes,2,opt,name=file,proto3" json:"file,omitempty"` } -func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) Reset() { - *x = ListEvaluationResultsResponse_EntityProfileEvaluationResults{} +func (x *PrDependencies_ContextualDependency) Reset() { + *x = PrDependencies_ContextualDependency{} if protoimpl.UnsafeEnabled { - mi := &file_minder_v1_minder_proto_msgTypes[170] + mi := &file_minder_v1_minder_proto_msgTypes[168] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) String() string { +func (x *PrDependencies_ContextualDependency) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListEvaluationResultsResponse_EntityProfileEvaluationResults) ProtoMessage() {} +func (*PrDependencies_ContextualDependency) ProtoMessage() {} -func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) ProtoReflect() protoreflect.Message { - mi := &file_minder_v1_minder_proto_msgTypes[170] +func (x *PrDependencies_ContextualDependency) ProtoReflect() protoreflect.Message { + mi := &file_minder_v1_minder_proto_msgTypes[168] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11069,51 +11099,51 @@ func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) ProtoRefl return mi.MessageOf(x) } -// Deprecated: Use ListEvaluationResultsResponse_EntityProfileEvaluationResults.ProtoReflect.Descriptor instead. -func (*ListEvaluationResultsResponse_EntityProfileEvaluationResults) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{99, 0} +// Deprecated: Use PrDependencies_ContextualDependency.ProtoReflect.Descriptor instead. +func (*PrDependencies_ContextualDependency) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{13, 0} } -func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) GetProfileStatus() *ProfileStatus { +func (x *PrDependencies_ContextualDependency) GetDep() *Dependency { if x != nil { - return x.ProfileStatus + return x.Dep } return nil } -func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) GetResults() []*RuleEvaluationStatus { +func (x *PrDependencies_ContextualDependency) GetFile() *PrDependencies_ContextualDependency_FilePatch { if x != nil { - return x.Results + return x.File } return nil } -type ListEvaluationResultsResponse_EntityEvaluationResults struct { +type PrDependencies_ContextualDependency_FilePatch struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Entity *EntityTypedId `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"` - Profiles []*ListEvaluationResultsResponse_EntityProfileEvaluationResults `protobuf:"bytes,2,rep,name=profiles,proto3" json:"profiles,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // file changed, e.g. package-lock.json + PatchUrl string `protobuf:"bytes,2,opt,name=patch_url,json=patchUrl,proto3" json:"patch_url,omitempty"` // points to the the raw patchfile } -func (x *ListEvaluationResultsResponse_EntityEvaluationResults) Reset() { - *x = ListEvaluationResultsResponse_EntityEvaluationResults{} +func (x *PrDependencies_ContextualDependency_FilePatch) Reset() { + *x = PrDependencies_ContextualDependency_FilePatch{} if protoimpl.UnsafeEnabled { - mi := &file_minder_v1_minder_proto_msgTypes[171] + mi := &file_minder_v1_minder_proto_msgTypes[169] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *ListEvaluationResultsResponse_EntityEvaluationResults) String() string { +func (x *PrDependencies_ContextualDependency_FilePatch) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListEvaluationResultsResponse_EntityEvaluationResults) ProtoMessage() {} +func (*PrDependencies_ContextualDependency_FilePatch) ProtoMessage() {} -func (x *ListEvaluationResultsResponse_EntityEvaluationResults) ProtoReflect() protoreflect.Message { - mi := &file_minder_v1_minder_proto_msgTypes[171] +func (x *PrDependencies_ContextualDependency_FilePatch) ProtoReflect() protoreflect.Message { + mi := &file_minder_v1_minder_proto_msgTypes[169] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11124,51 +11154,52 @@ func (x *ListEvaluationResultsResponse_EntityEvaluationResults) ProtoReflect() p return mi.MessageOf(x) } -// Deprecated: Use ListEvaluationResultsResponse_EntityEvaluationResults.ProtoReflect.Descriptor instead. -func (*ListEvaluationResultsResponse_EntityEvaluationResults) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{99, 1} +// Deprecated: Use PrDependencies_ContextualDependency_FilePatch.ProtoReflect.Descriptor instead. +func (*PrDependencies_ContextualDependency_FilePatch) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{13, 0, 0} } -func (x *ListEvaluationResultsResponse_EntityEvaluationResults) GetEntity() *EntityTypedId { +func (x *PrDependencies_ContextualDependency_FilePatch) GetName() string { if x != nil { - return x.Entity + return x.Name } - return nil + return "" } -func (x *ListEvaluationResultsResponse_EntityEvaluationResults) GetProfiles() []*ListEvaluationResultsResponse_EntityProfileEvaluationResults { +func (x *PrDependencies_ContextualDependency_FilePatch) GetPatchUrl() string { if x != nil { - return x.Profiles + return x.PatchUrl } - return nil + return "" } -type RestType_Fallback struct { +type PrContents_File struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - HttpCode int32 `protobuf:"varint,1,opt,name=http_code,json=httpCode,proto3" json:"http_code,omitempty"` - Body string `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + FilePatchUrl string `protobuf:"bytes,2,opt,name=file_patch_url,json=filePatchUrl,proto3" json:"file_patch_url,omitempty"` + PatchLines []*PrContents_File_Line `protobuf:"bytes,3,rep,name=patch_lines,json=patchLines,proto3" json:"patch_lines,omitempty"` } -func (x *RestType_Fallback) Reset() { - *x = RestType_Fallback{} +func (x *PrContents_File) Reset() { + *x = PrContents_File{} if protoimpl.UnsafeEnabled { - mi := &file_minder_v1_minder_proto_msgTypes[172] + mi := &file_minder_v1_minder_proto_msgTypes[170] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *RestType_Fallback) String() string { +func (x *PrContents_File) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RestType_Fallback) ProtoMessage() {} +func (*PrContents_File) ProtoMessage() {} -func (x *RestType_Fallback) ProtoReflect() protoreflect.Message { - mi := &file_minder_v1_minder_proto_msgTypes[172] +func (x *PrContents_File) ProtoReflect() protoreflect.Message { + mi := &file_minder_v1_minder_proto_msgTypes[170] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11179,53 +11210,60 @@ func (x *RestType_Fallback) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RestType_Fallback.ProtoReflect.Descriptor instead. -func (*RestType_Fallback) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{100, 0} +// Deprecated: Use PrContents_File.ProtoReflect.Descriptor instead. +func (*PrContents_File) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{14, 0} } -func (x *RestType_Fallback) GetHttpCode() int32 { +func (x *PrContents_File) GetName() string { if x != nil { - return x.HttpCode + return x.Name } - return 0 + return "" } -func (x *RestType_Fallback) GetBody() string { +func (x *PrContents_File) GetFilePatchUrl() string { if x != nil { - return x.Body + return x.FilePatchUrl } return "" } -type DiffType_Ecosystem struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // name is the name of the ecosystem. - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - // depfile is the file that contains the dependencies for this ecosystem - Depfile string `protobuf:"bytes,2,opt,name=depfile,proto3" json:"depfile,omitempty"` +func (x *PrContents_File) GetPatchLines() []*PrContents_File_Line { + if x != nil { + return x.PatchLines + } + return nil } -func (x *DiffType_Ecosystem) Reset() { - *x = DiffType_Ecosystem{} +type PrContents_File_Line struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Deliberately left as an int32: a diff with more than 2^31 lines + // could lead to various problems while processing. + LineNumber int32 `protobuf:"varint,1,opt,name=line_number,json=lineNumber,proto3" json:"line_number,omitempty"` + Content string `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"` +} + +func (x *PrContents_File_Line) Reset() { + *x = PrContents_File_Line{} if protoimpl.UnsafeEnabled { - mi := &file_minder_v1_minder_proto_msgTypes[173] + mi := &file_minder_v1_minder_proto_msgTypes[171] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *DiffType_Ecosystem) String() string { +func (x *PrContents_File_Line) String() string { return protoimpl.X.MessageStringOf(x) } -func (*DiffType_Ecosystem) ProtoMessage() {} +func (*PrContents_File_Line) ProtoMessage() {} -func (x *DiffType_Ecosystem) ProtoReflect() protoreflect.Message { - mi := &file_minder_v1_minder_proto_msgTypes[173] +func (x *PrContents_File_Line) ProtoReflect() protoreflect.Message { + mi := &file_minder_v1_minder_proto_msgTypes[171] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11236,62 +11274,51 @@ func (x *DiffType_Ecosystem) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use DiffType_Ecosystem.ProtoReflect.Descriptor instead. -func (*DiffType_Ecosystem) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{104, 0} +// Deprecated: Use PrContents_File_Line.ProtoReflect.Descriptor instead. +func (*PrContents_File_Line) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{14, 0, 0} } -func (x *DiffType_Ecosystem) GetName() string { +func (x *PrContents_File_Line) GetLineNumber() int32 { if x != nil { - return x.Name + return x.LineNumber } - return "" + return 0 } -func (x *DiffType_Ecosystem) GetDepfile() string { +func (x *PrContents_File_Line) GetContent() string { if x != nil { - return x.Depfile + return x.Content } return "" } -// Definition defines the rule type. It encompases the schema and the data evaluation. -type RuleType_Definition struct { +type RegisterRepoResult_Status struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // in_entity is the entity in which the rule is evaluated. - // This can be repository, build_environment or artifact. - InEntity string `protobuf:"bytes,1,opt,name=in_entity,json=inEntity,proto3" json:"in_entity,omitempty"` - // rule_schema is the schema of the rule. This is expressed in JSON Schema. - RuleSchema *structpb.Struct `protobuf:"bytes,2,opt,name=rule_schema,json=ruleSchema,proto3" json:"rule_schema,omitempty"` - // param_schema is the schema of the parameters that are passed to the rule. - // This is expressed in JSON Schema. - ParamSchema *structpb.Struct `protobuf:"bytes,3,opt,name=param_schema,json=paramSchema,proto3,oneof" json:"param_schema,omitempty"` - Ingest *RuleType_Definition_Ingest `protobuf:"bytes,4,opt,name=ingest,proto3" json:"ingest,omitempty"` - Eval *RuleType_Definition_Eval `protobuf:"bytes,5,opt,name=eval,proto3" json:"eval,omitempty"` - Remediate *RuleType_Definition_Remediate `protobuf:"bytes,6,opt,name=remediate,proto3" json:"remediate,omitempty"` - Alert *RuleType_Definition_Alert `protobuf:"bytes,7,opt,name=alert,proto3" json:"alert,omitempty"` + Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` + Error *string `protobuf:"bytes,2,opt,name=error,proto3,oneof" json:"error,omitempty"` } -func (x *RuleType_Definition) Reset() { - *x = RuleType_Definition{} +func (x *RegisterRepoResult_Status) Reset() { + *x = RegisterRepoResult_Status{} if protoimpl.UnsafeEnabled { - mi := &file_minder_v1_minder_proto_msgTypes[174] + mi := &file_minder_v1_minder_proto_msgTypes[172] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *RuleType_Definition) String() string { +func (x *RegisterRepoResult_Status) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition) ProtoMessage() {} +func (*RegisterRepoResult_Status) ProtoMessage() {} -func (x *RuleType_Definition) ProtoReflect() protoreflect.Message { - mi := &file_minder_v1_minder_proto_msgTypes[174] +func (x *RegisterRepoResult_Status) ProtoReflect() protoreflect.Message { + mi := &file_minder_v1_minder_proto_msgTypes[172] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -11302,84 +11329,39 @@ func (x *RuleType_Definition) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition.ProtoReflect.Descriptor instead. -func (*RuleType_Definition) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0} -} - -func (x *RuleType_Definition) GetInEntity() string { - if x != nil { - return x.InEntity - } - return "" -} - -func (x *RuleType_Definition) GetRuleSchema() *structpb.Struct { - if x != nil { - return x.RuleSchema - } - return nil -} - -func (x *RuleType_Definition) GetParamSchema() *structpb.Struct { - if x != nil { - return x.ParamSchema - } - return nil -} - -func (x *RuleType_Definition) GetIngest() *RuleType_Definition_Ingest { - if x != nil { - return x.Ingest - } - return nil -} - -func (x *RuleType_Definition) GetEval() *RuleType_Definition_Eval { - if x != nil { - return x.Eval - } - return nil +// Deprecated: Use RegisterRepoResult_Status.ProtoReflect.Descriptor instead. +func (*RegisterRepoResult_Status) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{29, 0} } -func (x *RuleType_Definition) GetRemediate() *RuleType_Definition_Remediate { +func (x *RegisterRepoResult_Status) GetSuccess() bool { if x != nil { - return x.Remediate + return x.Success } - return nil + return false } -func (x *RuleType_Definition) GetAlert() *RuleType_Definition_Alert { - if x != nil { - return x.Alert +func (x *RegisterRepoResult_Status) GetError() string { + if x != nil && x.Error != nil { + return *x.Error } - return nil + return "" } -// Ingest defines how the data is ingested. -type RuleType_Definition_Ingest struct { +type ListEvaluationResultsResponse_EntityProfileEvaluationResults struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // type is the type of the data ingestion. - // we currently support rest, artifact and builtin. - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - // rest is the rest data ingestion. - // this is only used if the type is rest. - Rest *RestType `protobuf:"bytes,3,opt,name=rest,proto3,oneof" json:"rest,omitempty"` - // builtin is the builtin data ingestion. - Builtin *BuiltinType `protobuf:"bytes,4,opt,name=builtin,proto3,oneof" json:"builtin,omitempty"` - // artifact is the artifact data ingestion. - Artifact *ArtifactType `protobuf:"bytes,5,opt,name=artifact,proto3,oneof" json:"artifact,omitempty"` - // git is the git data ingestion. - Git *GitType `protobuf:"bytes,6,opt,name=git,proto3,oneof" json:"git,omitempty"` - // diff is the diff data ingestion. - Diff *DiffType `protobuf:"bytes,7,opt,name=diff,proto3,oneof" json:"diff,omitempty"` + // profile_status is the status of the profile - id, name, status, last_updated + ProfileStatus *ProfileStatus `protobuf:"bytes,1,opt,name=profile_status,json=profileStatus,proto3" json:"profile_status,omitempty"` + // Note that some fields like profile_id and entity might be empty + // Eventually we might replace this type with another one that fits the API better + Results []*RuleEvaluationStatus `protobuf:"bytes,2,rep,name=results,proto3" json:"results,omitempty"` } -func (x *RuleType_Definition_Ingest) Reset() { - *x = RuleType_Definition_Ingest{} +func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) Reset() { + *x = ListEvaluationResultsResponse_EntityProfileEvaluationResults{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[175] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11387,13 +11369,13 @@ func (x *RuleType_Definition_Ingest) Reset() { } } -func (x *RuleType_Definition_Ingest) String() string { +func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Ingest) ProtoMessage() {} +func (*ListEvaluationResultsResponse_EntityProfileEvaluationResults) ProtoMessage() {} -func (x *RuleType_Definition_Ingest) ProtoReflect() protoreflect.Message { +func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[175] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11405,81 +11387,36 @@ func (x *RuleType_Definition_Ingest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Ingest.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Ingest) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 0} -} - -func (x *RuleType_Definition_Ingest) GetType() string { - if x != nil { - return x.Type - } - return "" -} - -func (x *RuleType_Definition_Ingest) GetRest() *RestType { - if x != nil { - return x.Rest - } - return nil -} - -func (x *RuleType_Definition_Ingest) GetBuiltin() *BuiltinType { - if x != nil { - return x.Builtin - } - return nil -} - -func (x *RuleType_Definition_Ingest) GetArtifact() *ArtifactType { - if x != nil { - return x.Artifact - } - return nil +// Deprecated: Use ListEvaluationResultsResponse_EntityProfileEvaluationResults.ProtoReflect.Descriptor instead. +func (*ListEvaluationResultsResponse_EntityProfileEvaluationResults) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{99, 0} } -func (x *RuleType_Definition_Ingest) GetGit() *GitType { +func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) GetProfileStatus() *ProfileStatus { if x != nil { - return x.Git + return x.ProfileStatus } return nil } -func (x *RuleType_Definition_Ingest) GetDiff() *DiffType { +func (x *ListEvaluationResultsResponse_EntityProfileEvaluationResults) GetResults() []*RuleEvaluationStatus { if x != nil { - return x.Diff + return x.Results } return nil } -// Eval defines the data evaluation definition. -// This pertains to the way we traverse data from the upstream -// endpoint and how we compare it to the rule. -type RuleType_Definition_Eval struct { +type ListEvaluationResultsResponse_EntityEvaluationResults struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // type is the type of the data evaluation. - // Right now only `jq` is supported as a driver - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - // jq is only used if the `jq` type is selected. - // It defines the comparisons that are made between - // the ingested data and the profile rule. - Jq []*RuleType_Definition_Eval_JQComparison `protobuf:"bytes,2,rep,name=jq,proto3" json:"jq,omitempty"` - // rego is only used if the `rego` type is selected. - Rego *RuleType_Definition_Eval_Rego `protobuf:"bytes,3,opt,name=rego,proto3,oneof" json:"rego,omitempty"` - // vulncheck is only used if the `vulncheck` type is selected. - Vulncheck *RuleType_Definition_Eval_Vulncheck `protobuf:"bytes,4,opt,name=vulncheck,proto3,oneof" json:"vulncheck,omitempty"` - // The trusty type is no longer used, but is still here for backwards - // compatibility with existing stored rules - Trusty *RuleType_Definition_Eval_Trusty `protobuf:"bytes,5,opt,name=trusty,proto3,oneof" json:"trusty,omitempty"` - // homoglyphs is only used if the `homoglyphs` type is selected. - Homoglyphs *RuleType_Definition_Eval_Homoglyphs `protobuf:"bytes,6,opt,name=homoglyphs,proto3,oneof" json:"homoglyphs,omitempty"` + Entity *EntityTypedId `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"` + Profiles []*ListEvaluationResultsResponse_EntityProfileEvaluationResults `protobuf:"bytes,2,rep,name=profiles,proto3" json:"profiles,omitempty"` } -func (x *RuleType_Definition_Eval) Reset() { - *x = RuleType_Definition_Eval{} +func (x *ListEvaluationResultsResponse_EntityEvaluationResults) Reset() { + *x = ListEvaluationResultsResponse_EntityEvaluationResults{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[176] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11487,13 +11424,13 @@ func (x *RuleType_Definition_Eval) Reset() { } } -func (x *RuleType_Definition_Eval) String() string { +func (x *ListEvaluationResultsResponse_EntityEvaluationResults) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Eval) ProtoMessage() {} +func (*ListEvaluationResultsResponse_EntityEvaluationResults) ProtoMessage() {} -func (x *RuleType_Definition_Eval) ProtoReflect() protoreflect.Message { +func (x *ListEvaluationResultsResponse_EntityEvaluationResults) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[176] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11505,66 +11442,36 @@ func (x *RuleType_Definition_Eval) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Eval.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Eval) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1} +// Deprecated: Use ListEvaluationResultsResponse_EntityEvaluationResults.ProtoReflect.Descriptor instead. +func (*ListEvaluationResultsResponse_EntityEvaluationResults) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{99, 1} } -func (x *RuleType_Definition_Eval) GetType() string { +func (x *ListEvaluationResultsResponse_EntityEvaluationResults) GetEntity() *EntityTypedId { if x != nil { - return x.Type + return x.Entity } - return "" + return nil } -func (x *RuleType_Definition_Eval) GetJq() []*RuleType_Definition_Eval_JQComparison { +func (x *ListEvaluationResultsResponse_EntityEvaluationResults) GetProfiles() []*ListEvaluationResultsResponse_EntityProfileEvaluationResults { if x != nil { - return x.Jq + return x.Profiles } return nil } -func (x *RuleType_Definition_Eval) GetRego() *RuleType_Definition_Eval_Rego { - if x != nil { - return x.Rego - } - return nil -} - -func (x *RuleType_Definition_Eval) GetVulncheck() *RuleType_Definition_Eval_Vulncheck { - if x != nil { - return x.Vulncheck - } - return nil -} - -func (x *RuleType_Definition_Eval) GetTrusty() *RuleType_Definition_Eval_Trusty { - if x != nil { - return x.Trusty - } - return nil -} - -func (x *RuleType_Definition_Eval) GetHomoglyphs() *RuleType_Definition_Eval_Homoglyphs { - if x != nil { - return x.Homoglyphs - } - return nil -} - -type RuleType_Definition_Remediate struct { +type RestType_Fallback struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - Rest *RestType `protobuf:"bytes,2,opt,name=rest,proto3,oneof" json:"rest,omitempty"` - GhBranchProtection *RuleType_Definition_Remediate_GhBranchProtectionType `protobuf:"bytes,3,opt,name=gh_branch_protection,json=ghBranchProtection,proto3,oneof" json:"gh_branch_protection,omitempty"` - PullRequest *RuleType_Definition_Remediate_PullRequestRemediation `protobuf:"bytes,4,opt,name=pull_request,json=pullRequest,proto3,oneof" json:"pull_request,omitempty"` + HttpCode int32 `protobuf:"varint,1,opt,name=http_code,json=httpCode,proto3" json:"http_code,omitempty"` + Body string `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"` } -func (x *RuleType_Definition_Remediate) Reset() { - *x = RuleType_Definition_Remediate{} +func (x *RestType_Fallback) Reset() { + *x = RestType_Fallback{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11572,13 +11479,13 @@ func (x *RuleType_Definition_Remediate) Reset() { } } -func (x *RuleType_Definition_Remediate) String() string { +func (x *RestType_Fallback) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Remediate) ProtoMessage() {} +func (*RestType_Fallback) ProtoMessage() {} -func (x *RuleType_Definition_Remediate) ProtoReflect() protoreflect.Message { +func (x *RestType_Fallback) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[177] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11590,50 +11497,38 @@ func (x *RuleType_Definition_Remediate) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Remediate.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Remediate) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2} -} - -func (x *RuleType_Definition_Remediate) GetType() string { - if x != nil { - return x.Type - } - return "" -} - -func (x *RuleType_Definition_Remediate) GetRest() *RestType { - if x != nil { - return x.Rest - } - return nil +// Deprecated: Use RestType_Fallback.ProtoReflect.Descriptor instead. +func (*RestType_Fallback) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{100, 0} } -func (x *RuleType_Definition_Remediate) GetGhBranchProtection() *RuleType_Definition_Remediate_GhBranchProtectionType { +func (x *RestType_Fallback) GetHttpCode() int32 { if x != nil { - return x.GhBranchProtection + return x.HttpCode } - return nil + return 0 } -func (x *RuleType_Definition_Remediate) GetPullRequest() *RuleType_Definition_Remediate_PullRequestRemediation { +func (x *RestType_Fallback) GetBody() string { if x != nil { - return x.PullRequest + return x.Body } - return nil + return "" } -type RuleType_Definition_Alert struct { +type DiffType_Ecosystem struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - SecurityAdvisory *RuleType_Definition_Alert_AlertTypeSA `protobuf:"bytes,2,opt,name=security_advisory,json=securityAdvisory,proto3,oneof" json:"security_advisory,omitempty"` + // name is the name of the ecosystem. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // depfile is the file that contains the dependencies for this ecosystem + Depfile string `protobuf:"bytes,2,opt,name=depfile,proto3" json:"depfile,omitempty"` } -func (x *RuleType_Definition_Alert) Reset() { - *x = RuleType_Definition_Alert{} +func (x *DiffType_Ecosystem) Reset() { + *x = DiffType_Ecosystem{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11641,13 +11536,13 @@ func (x *RuleType_Definition_Alert) Reset() { } } -func (x *RuleType_Definition_Alert) String() string { +func (x *DiffType_Ecosystem) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Alert) ProtoMessage() {} +func (*DiffType_Ecosystem) ProtoMessage() {} -func (x *RuleType_Definition_Alert) ProtoReflect() protoreflect.Message { +func (x *DiffType_Ecosystem) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[178] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11659,38 +11554,47 @@ func (x *RuleType_Definition_Alert) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Alert.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Alert) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 3} +// Deprecated: Use DiffType_Ecosystem.ProtoReflect.Descriptor instead. +func (*DiffType_Ecosystem) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{104, 0} } -func (x *RuleType_Definition_Alert) GetType() string { +func (x *DiffType_Ecosystem) GetName() string { if x != nil { - return x.Type + return x.Name } return "" } -func (x *RuleType_Definition_Alert) GetSecurityAdvisory() *RuleType_Definition_Alert_AlertTypeSA { +func (x *DiffType_Ecosystem) GetDepfile() string { if x != nil { - return x.SecurityAdvisory + return x.Depfile } - return nil + return "" } -type RuleType_Definition_Eval_JQComparison struct { +// Definition defines the rule type. It encompases the schema and the data evaluation. +type RuleType_Definition struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // Ingested points to the data retrieved in the `ingest` section - Ingested *RuleType_Definition_Eval_JQComparison_Operator `protobuf:"bytes,1,opt,name=ingested,proto3" json:"ingested,omitempty"` - // Profile points to the profile itself. - Profile *RuleType_Definition_Eval_JQComparison_Operator `protobuf:"bytes,2,opt,name=profile,proto3" json:"profile,omitempty"` + // in_entity is the entity in which the rule is evaluated. + // This can be repository, build_environment or artifact. + InEntity string `protobuf:"bytes,1,opt,name=in_entity,json=inEntity,proto3" json:"in_entity,omitempty"` + // rule_schema is the schema of the rule. This is expressed in JSON Schema. + RuleSchema *structpb.Struct `protobuf:"bytes,2,opt,name=rule_schema,json=ruleSchema,proto3" json:"rule_schema,omitempty"` + // param_schema is the schema of the parameters that are passed to the rule. + // This is expressed in JSON Schema. + ParamSchema *structpb.Struct `protobuf:"bytes,3,opt,name=param_schema,json=paramSchema,proto3,oneof" json:"param_schema,omitempty"` + Ingest *RuleType_Definition_Ingest `protobuf:"bytes,4,opt,name=ingest,proto3" json:"ingest,omitempty"` + Eval *RuleType_Definition_Eval `protobuf:"bytes,5,opt,name=eval,proto3" json:"eval,omitempty"` + Remediate *RuleType_Definition_Remediate `protobuf:"bytes,6,opt,name=remediate,proto3" json:"remediate,omitempty"` + Alert *RuleType_Definition_Alert `protobuf:"bytes,7,opt,name=alert,proto3" json:"alert,omitempty"` } -func (x *RuleType_Definition_Eval_JQComparison) Reset() { - *x = RuleType_Definition_Eval_JQComparison{} +func (x *RuleType_Definition) Reset() { + *x = RuleType_Definition{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11698,13 +11602,13 @@ func (x *RuleType_Definition_Eval_JQComparison) Reset() { } } -func (x *RuleType_Definition_Eval_JQComparison) String() string { +func (x *RuleType_Definition) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Eval_JQComparison) ProtoMessage() {} +func (*RuleType_Definition) ProtoMessage() {} -func (x *RuleType_Definition_Eval_JQComparison) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[179] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11716,52 +11620,84 @@ func (x *RuleType_Definition_Eval_JQComparison) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Eval_JQComparison.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Eval_JQComparison) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 0} +// Deprecated: Use RuleType_Definition.ProtoReflect.Descriptor instead. +func (*RuleType_Definition) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0} } -func (x *RuleType_Definition_Eval_JQComparison) GetIngested() *RuleType_Definition_Eval_JQComparison_Operator { +func (x *RuleType_Definition) GetInEntity() string { if x != nil { - return x.Ingested + return x.InEntity + } + return "" +} + +func (x *RuleType_Definition) GetRuleSchema() *structpb.Struct { + if x != nil { + return x.RuleSchema } return nil } -func (x *RuleType_Definition_Eval_JQComparison) GetProfile() *RuleType_Definition_Eval_JQComparison_Operator { +func (x *RuleType_Definition) GetParamSchema() *structpb.Struct { if x != nil { - return x.Profile + return x.ParamSchema } return nil } -type RuleType_Definition_Eval_Rego struct { +func (x *RuleType_Definition) GetIngest() *RuleType_Definition_Ingest { + if x != nil { + return x.Ingest + } + return nil +} + +func (x *RuleType_Definition) GetEval() *RuleType_Definition_Eval { + if x != nil { + return x.Eval + } + return nil +} + +func (x *RuleType_Definition) GetRemediate() *RuleType_Definition_Remediate { + if x != nil { + return x.Remediate + } + return nil +} + +func (x *RuleType_Definition) GetAlert() *RuleType_Definition_Alert { + if x != nil { + return x.Alert + } + return nil +} + +// Ingest defines how the data is ingested. +type RuleType_Definition_Ingest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // type is the type of evaluation engine to use - // for rego. We currently have two modes of operation: - // - deny-by-default: this is the default mode of operation - // where we deny access by default and allow access only - // if the profile explicitly allows it. It expects the - // profile to set an `allow` variable to true or false. - // - constraints: this is the mode of operation where we - // allow access by default and deny access only if a - // violation is found. It expects the profile to set a - // `violations` variable with a "msg" field. + // type is the type of the data ingestion. + // we currently support rest, artifact and builtin. Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - // def is the definition of the rego profile. - Def string `protobuf:"bytes,2,opt,name=def,proto3" json:"def,omitempty"` - // how are violations reported. This is only used if the - // `constraints` type is selected. The default is `text` - // which returns human-readable text. The other option is - // `json` which returns a JSON array containing the violations. - ViolationFormat *string `protobuf:"bytes,3,opt,name=violation_format,json=violationFormat,proto3,oneof" json:"violation_format,omitempty"` + // rest is the rest data ingestion. + // this is only used if the type is rest. + Rest *RestType `protobuf:"bytes,3,opt,name=rest,proto3,oneof" json:"rest,omitempty"` + // builtin is the builtin data ingestion. + Builtin *BuiltinType `protobuf:"bytes,4,opt,name=builtin,proto3,oneof" json:"builtin,omitempty"` + // artifact is the artifact data ingestion. + Artifact *ArtifactType `protobuf:"bytes,5,opt,name=artifact,proto3,oneof" json:"artifact,omitempty"` + // git is the git data ingestion. + Git *GitType `protobuf:"bytes,6,opt,name=git,proto3,oneof" json:"git,omitempty"` + // diff is the diff data ingestion. + Diff *DiffType `protobuf:"bytes,7,opt,name=diff,proto3,oneof" json:"diff,omitempty"` } -func (x *RuleType_Definition_Eval_Rego) Reset() { - *x = RuleType_Definition_Eval_Rego{} +func (x *RuleType_Definition_Ingest) Reset() { + *x = RuleType_Definition_Ingest{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11769,13 +11705,13 @@ func (x *RuleType_Definition_Eval_Rego) Reset() { } } -func (x *RuleType_Definition_Eval_Rego) String() string { +func (x *RuleType_Definition_Ingest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Eval_Rego) ProtoMessage() {} +func (*RuleType_Definition_Ingest) ProtoMessage() {} -func (x *RuleType_Definition_Eval_Rego) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Ingest) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[180] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11787,40 +11723,81 @@ func (x *RuleType_Definition_Eval_Rego) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Eval_Rego.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Eval_Rego) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 1} +// Deprecated: Use RuleType_Definition_Ingest.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Ingest) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 0} } -func (x *RuleType_Definition_Eval_Rego) GetType() string { +func (x *RuleType_Definition_Ingest) GetType() string { if x != nil { return x.Type } return "" } -func (x *RuleType_Definition_Eval_Rego) GetDef() string { +func (x *RuleType_Definition_Ingest) GetRest() *RestType { if x != nil { - return x.Def + return x.Rest } - return "" + return nil } -func (x *RuleType_Definition_Eval_Rego) GetViolationFormat() string { - if x != nil && x.ViolationFormat != nil { - return *x.ViolationFormat +func (x *RuleType_Definition_Ingest) GetBuiltin() *BuiltinType { + if x != nil { + return x.Builtin } - return "" + return nil } -type RuleType_Definition_Eval_Vulncheck struct { +func (x *RuleType_Definition_Ingest) GetArtifact() *ArtifactType { + if x != nil { + return x.Artifact + } + return nil +} + +func (x *RuleType_Definition_Ingest) GetGit() *GitType { + if x != nil { + return x.Git + } + return nil +} + +func (x *RuleType_Definition_Ingest) GetDiff() *DiffType { + if x != nil { + return x.Diff + } + return nil +} + +// Eval defines the data evaluation definition. +// This pertains to the way we traverse data from the upstream +// endpoint and how we compare it to the rule. +type RuleType_Definition_Eval struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields + + // type is the type of the data evaluation. + // Right now only `jq` is supported as a driver + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + // jq is only used if the `jq` type is selected. + // It defines the comparisons that are made between + // the ingested data and the profile rule. + Jq []*RuleType_Definition_Eval_JQComparison `protobuf:"bytes,2,rep,name=jq,proto3" json:"jq,omitempty"` + // rego is only used if the `rego` type is selected. + Rego *RuleType_Definition_Eval_Rego `protobuf:"bytes,3,opt,name=rego,proto3,oneof" json:"rego,omitempty"` + // vulncheck is only used if the `vulncheck` type is selected. + Vulncheck *RuleType_Definition_Eval_Vulncheck `protobuf:"bytes,4,opt,name=vulncheck,proto3,oneof" json:"vulncheck,omitempty"` + // The trusty type is no longer used, but is still here for backwards + // compatibility with existing stored rules + Trusty *RuleType_Definition_Eval_Trusty `protobuf:"bytes,5,opt,name=trusty,proto3,oneof" json:"trusty,omitempty"` + // homoglyphs is only used if the `homoglyphs` type is selected. + Homoglyphs *RuleType_Definition_Eval_Homoglyphs `protobuf:"bytes,6,opt,name=homoglyphs,proto3,oneof" json:"homoglyphs,omitempty"` } -func (x *RuleType_Definition_Eval_Vulncheck) Reset() { - *x = RuleType_Definition_Eval_Vulncheck{} +func (x *RuleType_Definition_Eval) Reset() { + *x = RuleType_Definition_Eval{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11828,13 +11805,13 @@ func (x *RuleType_Definition_Eval_Vulncheck) Reset() { } } -func (x *RuleType_Definition_Eval_Vulncheck) String() string { +func (x *RuleType_Definition_Eval) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Eval_Vulncheck) ProtoMessage() {} +func (*RuleType_Definition_Eval) ProtoMessage() {} -func (x *RuleType_Definition_Eval_Vulncheck) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Eval) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[181] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11846,23 +11823,66 @@ func (x *RuleType_Definition_Eval_Vulncheck) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Eval_Vulncheck.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Eval_Vulncheck) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 2} +// Deprecated: Use RuleType_Definition_Eval.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Eval) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1} } -type RuleType_Definition_Eval_Trusty struct { +func (x *RuleType_Definition_Eval) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *RuleType_Definition_Eval) GetJq() []*RuleType_Definition_Eval_JQComparison { + if x != nil { + return x.Jq + } + return nil +} + +func (x *RuleType_Definition_Eval) GetRego() *RuleType_Definition_Eval_Rego { + if x != nil { + return x.Rego + } + return nil +} + +func (x *RuleType_Definition_Eval) GetVulncheck() *RuleType_Definition_Eval_Vulncheck { + if x != nil { + return x.Vulncheck + } + return nil +} + +func (x *RuleType_Definition_Eval) GetTrusty() *RuleType_Definition_Eval_Trusty { + if x != nil { + return x.Trusty + } + return nil +} + +func (x *RuleType_Definition_Eval) GetHomoglyphs() *RuleType_Definition_Eval_Homoglyphs { + if x != nil { + return x.Homoglyphs + } + return nil +} + +type RuleType_Definition_Remediate struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // This is no longer used, but is still here for backwards - // compatibility with existing stored rules - Endpoint string `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"` + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + Rest *RestType `protobuf:"bytes,2,opt,name=rest,proto3,oneof" json:"rest,omitempty"` + GhBranchProtection *RuleType_Definition_Remediate_GhBranchProtectionType `protobuf:"bytes,3,opt,name=gh_branch_protection,json=ghBranchProtection,proto3,oneof" json:"gh_branch_protection,omitempty"` + PullRequest *RuleType_Definition_Remediate_PullRequestRemediation `protobuf:"bytes,4,opt,name=pull_request,json=pullRequest,proto3,oneof" json:"pull_request,omitempty"` } -func (x *RuleType_Definition_Eval_Trusty) Reset() { - *x = RuleType_Definition_Eval_Trusty{} +func (x *RuleType_Definition_Remediate) Reset() { + *x = RuleType_Definition_Remediate{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11870,13 +11890,13 @@ func (x *RuleType_Definition_Eval_Trusty) Reset() { } } -func (x *RuleType_Definition_Eval_Trusty) String() string { +func (x *RuleType_Definition_Remediate) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Eval_Trusty) ProtoMessage() {} +func (*RuleType_Definition_Remediate) ProtoMessage() {} -func (x *RuleType_Definition_Eval_Trusty) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Remediate) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[182] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11885,31 +11905,53 @@ func (x *RuleType_Definition_Eval_Trusty) ProtoReflect() protoreflect.Message { } return ms } - return mi.MessageOf(x) + return mi.MessageOf(x) +} + +// Deprecated: Use RuleType_Definition_Remediate.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Remediate) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2} +} + +func (x *RuleType_Definition_Remediate) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *RuleType_Definition_Remediate) GetRest() *RestType { + if x != nil { + return x.Rest + } + return nil } -// Deprecated: Use RuleType_Definition_Eval_Trusty.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Eval_Trusty) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 3} +func (x *RuleType_Definition_Remediate) GetGhBranchProtection() *RuleType_Definition_Remediate_GhBranchProtectionType { + if x != nil { + return x.GhBranchProtection + } + return nil } -func (x *RuleType_Definition_Eval_Trusty) GetEndpoint() string { +func (x *RuleType_Definition_Remediate) GetPullRequest() *RuleType_Definition_Remediate_PullRequestRemediation { if x != nil { - return x.Endpoint + return x.PullRequest } - return "" + return nil } -type RuleType_Definition_Eval_Homoglyphs struct { +type RuleType_Definition_Alert struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + SecurityAdvisory *RuleType_Definition_Alert_AlertTypeSA `protobuf:"bytes,2,opt,name=security_advisory,json=securityAdvisory,proto3,oneof" json:"security_advisory,omitempty"` } -func (x *RuleType_Definition_Eval_Homoglyphs) Reset() { - *x = RuleType_Definition_Eval_Homoglyphs{} +func (x *RuleType_Definition_Alert) Reset() { + *x = RuleType_Definition_Alert{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11917,13 +11959,13 @@ func (x *RuleType_Definition_Eval_Homoglyphs) Reset() { } } -func (x *RuleType_Definition_Eval_Homoglyphs) String() string { +func (x *RuleType_Definition_Alert) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Eval_Homoglyphs) ProtoMessage() {} +func (*RuleType_Definition_Alert) ProtoMessage() {} -func (x *RuleType_Definition_Eval_Homoglyphs) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Alert) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[183] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11935,28 +11977,38 @@ func (x *RuleType_Definition_Eval_Homoglyphs) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Eval_Homoglyphs.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Eval_Homoglyphs) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 4} +// Deprecated: Use RuleType_Definition_Alert.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Alert) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 3} } -func (x *RuleType_Definition_Eval_Homoglyphs) GetType() string { +func (x *RuleType_Definition_Alert) GetType() string { if x != nil { return x.Type } return "" } -type RuleType_Definition_Eval_JQComparison_Operator struct { +func (x *RuleType_Definition_Alert) GetSecurityAdvisory() *RuleType_Definition_Alert_AlertTypeSA { + if x != nil { + return x.SecurityAdvisory + } + return nil +} + +type RuleType_Definition_Eval_JQComparison struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Def string `protobuf:"bytes,1,opt,name=def,proto3" json:"def,omitempty"` + // Ingested points to the data retrieved in the `ingest` section + Ingested *RuleType_Definition_Eval_JQComparison_Operator `protobuf:"bytes,1,opt,name=ingested,proto3" json:"ingested,omitempty"` + // Profile points to the profile itself. + Profile *RuleType_Definition_Eval_JQComparison_Operator `protobuf:"bytes,2,opt,name=profile,proto3" json:"profile,omitempty"` } -func (x *RuleType_Definition_Eval_JQComparison_Operator) Reset() { - *x = RuleType_Definition_Eval_JQComparison_Operator{} +func (x *RuleType_Definition_Eval_JQComparison) Reset() { + *x = RuleType_Definition_Eval_JQComparison{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11964,13 +12016,13 @@ func (x *RuleType_Definition_Eval_JQComparison_Operator) Reset() { } } -func (x *RuleType_Definition_Eval_JQComparison_Operator) String() string { +func (x *RuleType_Definition_Eval_JQComparison) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Eval_JQComparison_Operator) ProtoMessage() {} +func (*RuleType_Definition_Eval_JQComparison) ProtoMessage() {} -func (x *RuleType_Definition_Eval_JQComparison_Operator) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Eval_JQComparison) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[184] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -11982,28 +12034,52 @@ func (x *RuleType_Definition_Eval_JQComparison_Operator) ProtoReflect() protoref return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Eval_JQComparison_Operator.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Eval_JQComparison_Operator) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 0, 0} +// Deprecated: Use RuleType_Definition_Eval_JQComparison.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Eval_JQComparison) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 0} } -func (x *RuleType_Definition_Eval_JQComparison_Operator) GetDef() string { +func (x *RuleType_Definition_Eval_JQComparison) GetIngested() *RuleType_Definition_Eval_JQComparison_Operator { if x != nil { - return x.Def + return x.Ingested } - return "" + return nil } -type RuleType_Definition_Remediate_GhBranchProtectionType struct { +func (x *RuleType_Definition_Eval_JQComparison) GetProfile() *RuleType_Definition_Eval_JQComparison_Operator { + if x != nil { + return x.Profile + } + return nil +} + +type RuleType_Definition_Eval_Rego struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Patch string `protobuf:"bytes,1,opt,name=patch,proto3" json:"patch,omitempty"` + // type is the type of evaluation engine to use + // for rego. We currently have two modes of operation: + // - deny-by-default: this is the default mode of operation + // where we deny access by default and allow access only + // if the profile explicitly allows it. It expects the + // profile to set an `allow` variable to true or false. + // - constraints: this is the mode of operation where we + // allow access by default and deny access only if a + // violation is found. It expects the profile to set a + // `violations` variable with a "msg" field. + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + // def is the definition of the rego profile. + Def string `protobuf:"bytes,2,opt,name=def,proto3" json:"def,omitempty"` + // how are violations reported. This is only used if the + // `constraints` type is selected. The default is `text` + // which returns human-readable text. The other option is + // `json` which returns a JSON array containing the violations. + ViolationFormat *string `protobuf:"bytes,3,opt,name=violation_format,json=violationFormat,proto3,oneof" json:"violation_format,omitempty"` } -func (x *RuleType_Definition_Remediate_GhBranchProtectionType) Reset() { - *x = RuleType_Definition_Remediate_GhBranchProtectionType{} +func (x *RuleType_Definition_Eval_Rego) Reset() { + *x = RuleType_Definition_Eval_Rego{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[185] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12011,13 +12087,13 @@ func (x *RuleType_Definition_Remediate_GhBranchProtectionType) Reset() { } } -func (x *RuleType_Definition_Remediate_GhBranchProtectionType) String() string { +func (x *RuleType_Definition_Eval_Rego) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Remediate_GhBranchProtectionType) ProtoMessage() {} +func (*RuleType_Definition_Eval_Rego) ProtoMessage() {} -func (x *RuleType_Definition_Remediate_GhBranchProtectionType) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Eval_Rego) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[185] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12029,45 +12105,40 @@ func (x *RuleType_Definition_Remediate_GhBranchProtectionType) ProtoReflect() pr return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Remediate_GhBranchProtectionType.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Remediate_GhBranchProtectionType) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 0} +// Deprecated: Use RuleType_Definition_Eval_Rego.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Eval_Rego) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 1} } -func (x *RuleType_Definition_Remediate_GhBranchProtectionType) GetPatch() string { +func (x *RuleType_Definition_Eval_Rego) GetType() string { if x != nil { - return x.Patch + return x.Type } return "" } -// the name stutters a bit but we already use a PullRequest message for handling PR entities -type RuleType_Definition_Remediate_PullRequestRemediation struct { +func (x *RuleType_Definition_Eval_Rego) GetDef() string { + if x != nil { + return x.Def + } + return "" +} + +func (x *RuleType_Definition_Eval_Rego) GetViolationFormat() string { + if x != nil && x.ViolationFormat != nil { + return *x.ViolationFormat + } + return "" +} + +type RuleType_Definition_Eval_Vulncheck struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - - // the title of the PR - Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` - // the body of the PR - Body string `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"` - Contents []*RuleType_Definition_Remediate_PullRequestRemediation_Content `protobuf:"bytes,3,rep,name=contents,proto3" json:"contents,omitempty"` - // the method to use to create the PR. For now, these are supported: - // -- minder.content - ensures that the content of the file is exactly as specified - // - // refer to the Content message for more details - // - // -- minder.actions.replace_tags_with_sha - finds any github actions within a workflow - // - // file and replaces the tag with the SHA - Method string `protobuf:"bytes,4,opt,name=method,proto3" json:"method,omitempty"` - // If the method is minder.actions.replace_tags_with_sha, this is the configuration - // for that method - ActionsReplaceTagsWithSha *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha `protobuf:"bytes,5,opt,name=actions_replace_tags_with_sha,json=actionsReplaceTagsWithSha,proto3,oneof" json:"actions_replace_tags_with_sha,omitempty"` } -func (x *RuleType_Definition_Remediate_PullRequestRemediation) Reset() { - *x = RuleType_Definition_Remediate_PullRequestRemediation{} +func (x *RuleType_Definition_Eval_Vulncheck) Reset() { + *x = RuleType_Definition_Eval_Vulncheck{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[186] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12075,13 +12146,13 @@ func (x *RuleType_Definition_Remediate_PullRequestRemediation) Reset() { } } -func (x *RuleType_Definition_Remediate_PullRequestRemediation) String() string { +func (x *RuleType_Definition_Eval_Vulncheck) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Remediate_PullRequestRemediation) ProtoMessage() {} +func (*RuleType_Definition_Eval_Vulncheck) ProtoMessage() {} -func (x *RuleType_Definition_Remediate_PullRequestRemediation) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Eval_Vulncheck) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[186] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12093,66 +12164,23 @@ func (x *RuleType_Definition_Remediate_PullRequestRemediation) ProtoReflect() pr return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Remediate_PullRequestRemediation.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Remediate_PullRequestRemediation) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 1} -} - -func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetTitle() string { - if x != nil { - return x.Title - } - return "" -} - -func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetBody() string { - if x != nil { - return x.Body - } - return "" -} - -func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetContents() []*RuleType_Definition_Remediate_PullRequestRemediation_Content { - if x != nil { - return x.Contents - } - return nil -} - -func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetMethod() string { - if x != nil { - return x.Method - } - return "" -} - -func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetActionsReplaceTagsWithSha() *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha { - if x != nil { - return x.ActionsReplaceTagsWithSha - } - return nil +// Deprecated: Use RuleType_Definition_Eval_Vulncheck.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Eval_Vulncheck) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 2} } -type RuleType_Definition_Remediate_PullRequestRemediation_Content struct { +type RuleType_Definition_Eval_Trusty struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // the file to patch - Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` - // how to patch the file. For now, only replace is supported - Action string `protobuf:"bytes,2,opt,name=action,proto3" json:"action,omitempty"` - // the content of the file - Content string `protobuf:"bytes,4,opt,name=content,proto3" json:"content,omitempty"` - // the GIT mode of the file. Not UNIX mode! String because the GH API also uses strings - // the usual modes are: 100644 for regular files, 100755 for executable files and - // 040000 for submodules (which we don't use but now you know the meaning of the 1 in 100644) - // see e.g. https://github.com/go-git/go-git/blob/32e0172851c35ae2fac495069c923330040903d2/plumbing/filemode/filemode.go#L16 - Mode *string `protobuf:"bytes,3,opt,name=mode,proto3,oneof" json:"mode,omitempty"` + // This is no longer used, but is still here for backwards + // compatibility with existing stored rules + Endpoint string `protobuf:"bytes,1,opt,name=endpoint,proto3" json:"endpoint,omitempty"` } -func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) Reset() { - *x = RuleType_Definition_Remediate_PullRequestRemediation_Content{} +func (x *RuleType_Definition_Eval_Trusty) Reset() { + *x = RuleType_Definition_Eval_Trusty{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[187] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12160,68 +12188,46 @@ func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) Reset() { } } -func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) String() string { +func (x *RuleType_Definition_Eval_Trusty) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Remediate_PullRequestRemediation_Content) ProtoMessage() {} +func (*RuleType_Definition_Eval_Trusty) ProtoMessage() {} -func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Eval_Trusty) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[187] if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use RuleType_Definition_Remediate_PullRequestRemediation_Content.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Remediate_PullRequestRemediation_Content) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 1, 0} -} - -func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetPath() string { - if x != nil { - return x.Path + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return "" + return mi.MessageOf(x) } -func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetAction() string { - if x != nil { - return x.Action - } - return "" +// Deprecated: Use RuleType_Definition_Eval_Trusty.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Eval_Trusty) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 3} } -func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetContent() string { +func (x *RuleType_Definition_Eval_Trusty) GetEndpoint() string { if x != nil { - return x.Content - } - return "" -} - -func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetMode() string { - if x != nil && x.Mode != nil { - return *x.Mode + return x.Endpoint } return "" } -type RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha struct { +type RuleType_Definition_Eval_Homoglyphs struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // List of actions to exclude from the replacement - Exclude []string `protobuf:"bytes,1,rep,name=exclude,proto3" json:"exclude,omitempty"` + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` } -func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) Reset() { - *x = RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha{} +func (x *RuleType_Definition_Eval_Homoglyphs) Reset() { + *x = RuleType_Definition_Eval_Homoglyphs{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[188] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12229,14 +12235,13 @@ func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTags } } -func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) String() string { +func (x *RuleType_Definition_Eval_Homoglyphs) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) ProtoMessage() { -} +func (*RuleType_Definition_Eval_Homoglyphs) ProtoMessage() {} -func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Eval_Homoglyphs) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[188] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12248,28 +12253,28 @@ func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTags return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 1, 1} +// Deprecated: Use RuleType_Definition_Eval_Homoglyphs.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Eval_Homoglyphs) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 4} } -func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) GetExclude() []string { +func (x *RuleType_Definition_Eval_Homoglyphs) GetType() string { if x != nil { - return x.Exclude + return x.Type } - return nil + return "" } -type RuleType_Definition_Alert_AlertTypeSA struct { +type RuleType_Definition_Eval_JQComparison_Operator struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Severity string `protobuf:"bytes,1,opt,name=severity,proto3" json:"severity,omitempty"` + Def string `protobuf:"bytes,1,opt,name=def,proto3" json:"def,omitempty"` } -func (x *RuleType_Definition_Alert_AlertTypeSA) Reset() { - *x = RuleType_Definition_Alert_AlertTypeSA{} +func (x *RuleType_Definition_Eval_JQComparison_Operator) Reset() { + *x = RuleType_Definition_Eval_JQComparison_Operator{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[189] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12277,13 +12282,13 @@ func (x *RuleType_Definition_Alert_AlertTypeSA) Reset() { } } -func (x *RuleType_Definition_Alert_AlertTypeSA) String() string { +func (x *RuleType_Definition_Eval_JQComparison_Operator) String() string { return protoimpl.X.MessageStringOf(x) } -func (*RuleType_Definition_Alert_AlertTypeSA) ProtoMessage() {} +func (*RuleType_Definition_Eval_JQComparison_Operator) ProtoMessage() {} -func (x *RuleType_Definition_Alert_AlertTypeSA) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Eval_JQComparison_Operator) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[189] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12295,38 +12300,28 @@ func (x *RuleType_Definition_Alert_AlertTypeSA) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use RuleType_Definition_Alert_AlertTypeSA.ProtoReflect.Descriptor instead. -func (*RuleType_Definition_Alert_AlertTypeSA) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 3, 0} +// Deprecated: Use RuleType_Definition_Eval_JQComparison_Operator.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Eval_JQComparison_Operator) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 1, 0, 0} } -func (x *RuleType_Definition_Alert_AlertTypeSA) GetSeverity() string { +func (x *RuleType_Definition_Eval_JQComparison_Operator) GetDef() string { if x != nil { - return x.Severity + return x.Def } return "" } -// Rule defines the individual call of a certain rule type. -type Profile_Rule struct { +type RuleType_Definition_Remediate_GhBranchProtectionType struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // type is the type of the rule to be instantiated. - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - // params are the parameters that are passed to the rule. - // This is optional and depends on the rule type. - Params *structpb.Struct `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"` - // def is the definition of the rule. - // This depends on the rule type. - Def *structpb.Struct `protobuf:"bytes,3,opt,name=def,proto3" json:"def,omitempty"` - // name is the descriptive name of the rule, not to be confused with type - Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` + Patch string `protobuf:"bytes,1,opt,name=patch,proto3" json:"patch,omitempty"` } -func (x *Profile_Rule) Reset() { - *x = Profile_Rule{} +func (x *RuleType_Definition_Remediate_GhBranchProtectionType) Reset() { + *x = RuleType_Definition_Remediate_GhBranchProtectionType{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[190] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12334,13 +12329,13 @@ func (x *Profile_Rule) Reset() { } } -func (x *Profile_Rule) String() string { +func (x *RuleType_Definition_Remediate_GhBranchProtectionType) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Profile_Rule) ProtoMessage() {} +func (*RuleType_Definition_Remediate_GhBranchProtectionType) ProtoMessage() {} -func (x *Profile_Rule) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Remediate_GhBranchProtectionType) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[190] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12352,56 +12347,45 @@ func (x *Profile_Rule) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Profile_Rule.ProtoReflect.Descriptor instead. -func (*Profile_Rule) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{107, 0} -} - -func (x *Profile_Rule) GetType() string { - if x != nil { - return x.Type - } - return "" -} - -func (x *Profile_Rule) GetParams() *structpb.Struct { - if x != nil { - return x.Params - } - return nil -} - -func (x *Profile_Rule) GetDef() *structpb.Struct { - if x != nil { - return x.Def - } - return nil +// Deprecated: Use RuleType_Definition_Remediate_GhBranchProtectionType.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Remediate_GhBranchProtectionType) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 0} } -func (x *Profile_Rule) GetName() string { +func (x *RuleType_Definition_Remediate_GhBranchProtectionType) GetPatch() string { if x != nil { - return x.Name + return x.Patch } return "" } -type Profile_Selector struct { +// the name stutters a bit but we already use a PullRequest message for handling PR entities +type RuleType_Definition_Remediate_PullRequestRemediation struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // id is optional and use for updates to match upserts as well as read operations. It is ignored for creates. - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - // entity is the entity to select. - Entity string `protobuf:"bytes,2,opt,name=entity,proto3" json:"entity,omitempty"` - // expr is the expression to select the entity. - Selector string `protobuf:"bytes,4,opt,name=selector,proto3" json:"selector,omitempty"` - // description is the human-readable description of the selector. - Comment string `protobuf:"bytes,5,opt,name=comment,proto3" json:"comment,omitempty"` + // the title of the PR + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + // the body of the PR + Body string `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"` + Contents []*RuleType_Definition_Remediate_PullRequestRemediation_Content `protobuf:"bytes,3,rep,name=contents,proto3" json:"contents,omitempty"` + // the method to use to create the PR. For now, these are supported: + // -- minder.content - ensures that the content of the file is exactly as specified + // + // refer to the Content message for more details + // + // -- minder.actions.replace_tags_with_sha - finds any github actions within a workflow + // + // file and replaces the tag with the SHA + Method string `protobuf:"bytes,4,opt,name=method,proto3" json:"method,omitempty"` + // If the method is minder.actions.replace_tags_with_sha, this is the configuration + // for that method + ActionsReplaceTagsWithSha *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha `protobuf:"bytes,5,opt,name=actions_replace_tags_with_sha,json=actionsReplaceTagsWithSha,proto3,oneof" json:"actions_replace_tags_with_sha,omitempty"` } -func (x *Profile_Selector) Reset() { - *x = Profile_Selector{} +func (x *RuleType_Definition_Remediate_PullRequestRemediation) Reset() { + *x = RuleType_Definition_Remediate_PullRequestRemediation{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[191] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12409,13 +12393,13 @@ func (x *Profile_Selector) Reset() { } } -func (x *Profile_Selector) String() string { +func (x *RuleType_Definition_Remediate_PullRequestRemediation) String() string { return protoimpl.X.MessageStringOf(x) } -func (*Profile_Selector) ProtoMessage() {} +func (*RuleType_Definition_Remediate_PullRequestRemediation) ProtoMessage() {} -func (x *Profile_Selector) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Remediate_PullRequestRemediation) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[191] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12427,54 +12411,66 @@ func (x *Profile_Selector) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use Profile_Selector.ProtoReflect.Descriptor instead. -func (*Profile_Selector) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{107, 1} +// Deprecated: Use RuleType_Definition_Remediate_PullRequestRemediation.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Remediate_PullRequestRemediation) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 1} } -func (x *Profile_Selector) GetId() string { +func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetTitle() string { if x != nil { - return x.Id + return x.Title } return "" } -func (x *Profile_Selector) GetEntity() string { +func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetBody() string { if x != nil { - return x.Entity + return x.Body } return "" } -func (x *Profile_Selector) GetSelector() string { +func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetContents() []*RuleType_Definition_Remediate_PullRequestRemediation_Content { if x != nil { - return x.Selector + return x.Contents } - return "" + return nil } -func (x *Profile_Selector) GetComment() string { +func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetMethod() string { if x != nil { - return x.Comment + return x.Method } return "" } -type EvaluationHistory_Entity struct { +func (x *RuleType_Definition_Remediate_PullRequestRemediation) GetActionsReplaceTagsWithSha() *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha { + if x != nil { + return x.ActionsReplaceTagsWithSha + } + return nil +} + +type RuleType_Definition_Remediate_PullRequestRemediation_Content struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // id is the ID of the entity. - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - // type is the entity type. - Type Entity `protobuf:"varint,2,opt,name=type,proto3,enum=minder.v1.Entity" json:"type,omitempty"` - // name is the entity name. - Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` + // the file to patch + Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + // how to patch the file. For now, only replace is supported + Action string `protobuf:"bytes,2,opt,name=action,proto3" json:"action,omitempty"` + // the content of the file + Content string `protobuf:"bytes,4,opt,name=content,proto3" json:"content,omitempty"` + // the GIT mode of the file. Not UNIX mode! String because the GH API also uses strings + // the usual modes are: 100644 for regular files, 100755 for executable files and + // 040000 for submodules (which we don't use but now you know the meaning of the 1 in 100644) + // see e.g. https://github.com/go-git/go-git/blob/32e0172851c35ae2fac495069c923330040903d2/plumbing/filemode/filemode.go#L16 + Mode *string `protobuf:"bytes,3,opt,name=mode,proto3,oneof" json:"mode,omitempty"` } -func (x *EvaluationHistory_Entity) Reset() { - *x = EvaluationHistory_Entity{} +func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) Reset() { + *x = RuleType_Definition_Remediate_PullRequestRemediation_Content{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[192] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12482,13 +12478,13 @@ func (x *EvaluationHistory_Entity) Reset() { } } -func (x *EvaluationHistory_Entity) String() string { +func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) String() string { return protoimpl.X.MessageStringOf(x) } -func (*EvaluationHistory_Entity) ProtoMessage() {} +func (*RuleType_Definition_Remediate_PullRequestRemediation_Content) ProtoMessage() {} -func (x *EvaluationHistory_Entity) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[192] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12500,47 +12496,50 @@ func (x *EvaluationHistory_Entity) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use EvaluationHistory_Entity.ProtoReflect.Descriptor instead. -func (*EvaluationHistory_Entity) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{162, 0} +// Deprecated: Use RuleType_Definition_Remediate_PullRequestRemediation_Content.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Remediate_PullRequestRemediation_Content) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 1, 0} } -func (x *EvaluationHistory_Entity) GetId() string { +func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetPath() string { if x != nil { - return x.Id + return x.Path } return "" } -func (x *EvaluationHistory_Entity) GetType() Entity { +func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetAction() string { if x != nil { - return x.Type + return x.Action } - return Entity_ENTITY_UNSPECIFIED + return "" } -func (x *EvaluationHistory_Entity) GetName() string { +func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetContent() string { if x != nil { - return x.Name + return x.Content } return "" } -type EvaluationHistory_Rule struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields +func (x *RuleType_Definition_Remediate_PullRequestRemediation_Content) GetMode() string { + if x != nil && x.Mode != nil { + return *x.Mode + } + return "" +} - // name is the name of the rule instance. - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - // type is the name of the rule type. - Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"` - // profile is the name of the profile which contains the rule. - Profile string `protobuf:"bytes,3,opt,name=profile,proto3" json:"profile,omitempty"` +type RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // List of actions to exclude from the replacement + Exclude []string `protobuf:"bytes,1,rep,name=exclude,proto3" json:"exclude,omitempty"` } -func (x *EvaluationHistory_Rule) Reset() { - *x = EvaluationHistory_Rule{} +func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) Reset() { + *x = RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[193] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12548,13 +12547,14 @@ func (x *EvaluationHistory_Rule) Reset() { } } -func (x *EvaluationHistory_Rule) String() string { +func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) String() string { return protoimpl.X.MessageStringOf(x) } -func (*EvaluationHistory_Rule) ProtoMessage() {} +func (*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) ProtoMessage() { +} -func (x *EvaluationHistory_Rule) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[193] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12566,49 +12566,28 @@ func (x *EvaluationHistory_Rule) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use EvaluationHistory_Rule.ProtoReflect.Descriptor instead. -func (*EvaluationHistory_Rule) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{162, 1} -} - -func (x *EvaluationHistory_Rule) GetName() string { - if x != nil { - return x.Name - } - return "" -} - -func (x *EvaluationHistory_Rule) GetType() string { - if x != nil { - return x.Type - } - return "" +// Deprecated: Use RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 2, 1, 1} } -func (x *EvaluationHistory_Rule) GetProfile() string { +func (x *RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha) GetExclude() []string { if x != nil { - return x.Profile + return x.Exclude } - return "" + return nil } -type EvaluationHistory_Status struct { +type RuleType_Definition_Alert_AlertTypeSA struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // status is one of (success, error, failure, skipped) - // not using enums to mirror the behaviour of the existing API contracts. - Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` - // details contains optional details about the evaluation. - // the structure and contents are rule type specific, and are subject to change. - Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"` - // created_at is the timestamp of creation of this evaluation - EvaluatedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=evaluated_at,json=evaluatedAt,proto3" json:"evaluated_at,omitempty"` + Severity string `protobuf:"bytes,1,opt,name=severity,proto3" json:"severity,omitempty"` } -func (x *EvaluationHistory_Status) Reset() { - *x = EvaluationHistory_Status{} +func (x *RuleType_Definition_Alert_AlertTypeSA) Reset() { + *x = RuleType_Definition_Alert_AlertTypeSA{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[194] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12616,13 +12595,13 @@ func (x *EvaluationHistory_Status) Reset() { } } -func (x *EvaluationHistory_Status) String() string { +func (x *RuleType_Definition_Alert_AlertTypeSA) String() string { return protoimpl.X.MessageStringOf(x) } -func (*EvaluationHistory_Status) ProtoMessage() {} +func (*RuleType_Definition_Alert_AlertTypeSA) ProtoMessage() {} -func (x *EvaluationHistory_Status) ProtoReflect() protoreflect.Message { +func (x *RuleType_Definition_Alert_AlertTypeSA) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[194] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12634,47 +12613,38 @@ func (x *EvaluationHistory_Status) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use EvaluationHistory_Status.ProtoReflect.Descriptor instead. -func (*EvaluationHistory_Status) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{162, 2} -} - -func (x *EvaluationHistory_Status) GetStatus() string { - if x != nil { - return x.Status - } - return "" +// Deprecated: Use RuleType_Definition_Alert_AlertTypeSA.ProtoReflect.Descriptor instead. +func (*RuleType_Definition_Alert_AlertTypeSA) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{106, 0, 3, 0} } -func (x *EvaluationHistory_Status) GetDetails() string { +func (x *RuleType_Definition_Alert_AlertTypeSA) GetSeverity() string { if x != nil { - return x.Details + return x.Severity } return "" } -func (x *EvaluationHistory_Status) GetEvaluatedAt() *timestamppb.Timestamp { - if x != nil { - return x.EvaluatedAt - } - return nil -} - -type EvaluationHistory_Remediation struct { +// Rule defines the individual call of a certain rule type. +type Profile_Rule struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // status is one of (success, error, failure, skipped, not available) - // not using enums to mirror the behaviour of the existing API contracts. - Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` - // details contains optional details about the remediation. - // the structure and contents are remediation specific, and are subject to change. - Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"` + // type is the type of the rule to be instantiated. + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + // params are the parameters that are passed to the rule. + // This is optional and depends on the rule type. + Params *structpb.Struct `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"` + // def is the definition of the rule. + // This depends on the rule type. + Def *structpb.Struct `protobuf:"bytes,3,opt,name=def,proto3" json:"def,omitempty"` + // name is the descriptive name of the rule, not to be confused with type + Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` } -func (x *EvaluationHistory_Remediation) Reset() { - *x = EvaluationHistory_Remediation{} +func (x *Profile_Rule) Reset() { + *x = Profile_Rule{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[195] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12682,13 +12652,13 @@ func (x *EvaluationHistory_Remediation) Reset() { } } -func (x *EvaluationHistory_Remediation) String() string { +func (x *Profile_Rule) String() string { return protoimpl.X.MessageStringOf(x) } -func (*EvaluationHistory_Remediation) ProtoMessage() {} +func (*Profile_Rule) ProtoMessage() {} -func (x *EvaluationHistory_Remediation) ProtoReflect() protoreflect.Message { +func (x *Profile_Rule) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[195] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12700,40 +12670,56 @@ func (x *EvaluationHistory_Remediation) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use EvaluationHistory_Remediation.ProtoReflect.Descriptor instead. -func (*EvaluationHistory_Remediation) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{162, 3} +// Deprecated: Use Profile_Rule.ProtoReflect.Descriptor instead. +func (*Profile_Rule) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{107, 0} } -func (x *EvaluationHistory_Remediation) GetStatus() string { +func (x *Profile_Rule) GetType() string { if x != nil { - return x.Status + return x.Type } return "" } -func (x *EvaluationHistory_Remediation) GetDetails() string { +func (x *Profile_Rule) GetParams() *structpb.Struct { if x != nil { - return x.Details + return x.Params + } + return nil +} + +func (x *Profile_Rule) GetDef() *structpb.Struct { + if x != nil { + return x.Def + } + return nil +} + +func (x *Profile_Rule) GetName() string { + if x != nil { + return x.Name } return "" } -type EvaluationHistory_Alert struct { +type Profile_Selector struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // status is one of (on, off, error, skipped, not available) - // not using enums to mirror the behaviour of the existing API contracts. - Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` - // details contains optional details about the alert. - // the structure and contents are alert specific, and are subject to change. - Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"` + // id is optional and use for updates to match upserts as well as read operations. It is ignored for creates. + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // entity is the entity to select. + Entity string `protobuf:"bytes,2,opt,name=entity,proto3" json:"entity,omitempty"` + // expr is the expression to select the entity. + Selector string `protobuf:"bytes,4,opt,name=selector,proto3" json:"selector,omitempty"` + // description is the human-readable description of the selector. + Comment string `protobuf:"bytes,5,opt,name=comment,proto3" json:"comment,omitempty"` } -func (x *EvaluationHistory_Alert) Reset() { - *x = EvaluationHistory_Alert{} +func (x *Profile_Selector) Reset() { + *x = Profile_Selector{} if protoimpl.UnsafeEnabled { mi := &file_minder_v1_minder_proto_msgTypes[196] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12741,13 +12727,13 @@ func (x *EvaluationHistory_Alert) Reset() { } } -func (x *EvaluationHistory_Alert) String() string { +func (x *Profile_Selector) String() string { return protoimpl.X.MessageStringOf(x) } -func (*EvaluationHistory_Alert) ProtoMessage() {} +func (*Profile_Selector) ProtoMessage() {} -func (x *EvaluationHistory_Alert) ProtoReflect() protoreflect.Message { +func (x *Profile_Selector) ProtoReflect() protoreflect.Message { mi := &file_minder_v1_minder_proto_msgTypes[196] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -12759,21 +12745,35 @@ func (x *EvaluationHistory_Alert) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use EvaluationHistory_Alert.ProtoReflect.Descriptor instead. -func (*EvaluationHistory_Alert) Descriptor() ([]byte, []int) { - return file_minder_v1_minder_proto_rawDescGZIP(), []int{162, 4} +// Deprecated: Use Profile_Selector.ProtoReflect.Descriptor instead. +func (*Profile_Selector) Descriptor() ([]byte, []int) { + return file_minder_v1_minder_proto_rawDescGZIP(), []int{107, 1} } -func (x *EvaluationHistory_Alert) GetStatus() string { +func (x *Profile_Selector) GetId() string { if x != nil { - return x.Status + return x.Id } return "" } -func (x *EvaluationHistory_Alert) GetDetails() string { +func (x *Profile_Selector) GetEntity() string { if x != nil { - return x.Details + return x.Entity + } + return "" +} + +func (x *Profile_Selector) GetSelector() string { + if x != nil { + return x.Selector + } + return "" +} + +func (x *Profile_Selector) GetComment() string { + if x != nil { + return x.Comment } return "" } @@ -14371,799 +14371,804 @@ var file_minder_v1_minder_proto_rawDesc = []byte{ 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x29, 0x0a, 0x04, 0x70, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x75, - 0x72, 0x73, 0x6f, 0x72, 0x50, 0x61, 0x67, 0x65, 0x52, 0x04, 0x70, 0x61, 0x67, 0x65, 0x22, 0xe0, - 0x05, 0x0a, 0x11, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, - 0x74, 0x6f, 0x72, 0x79, 0x12, 0x3b, 0x0a, 0x06, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, - 0x72, 0x79, 0x2e, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x06, 0x65, 0x6e, 0x74, 0x69, 0x74, - 0x79, 0x12, 0x35, 0x0a, 0x04, 0x72, 0x75, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x61, 0x6c, - 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x2e, 0x52, 0x75, - 0x6c, 0x65, 0x52, 0x04, 0x72, 0x75, 0x6c, 0x65, 0x12, 0x3b, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, - 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x38, 0x0a, 0x05, 0x61, 0x6c, 0x65, 0x72, 0x74, 0x18, 0x04, + 0x72, 0x73, 0x6f, 0x72, 0x50, 0x61, 0x67, 0x65, 0x52, 0x04, 0x70, 0x61, 0x67, 0x65, 0x22, 0xc5, + 0x02, 0x0a, 0x11, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, + 0x74, 0x6f, 0x72, 0x79, 0x12, 0x3a, 0x0a, 0x06, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, - 0x72, 0x79, 0x2e, 0x41, 0x6c, 0x65, 0x72, 0x74, 0x52, 0x05, 0x61, 0x6c, 0x65, 0x72, 0x74, 0x12, - 0x4a, 0x0a, 0x0b, 0x72, 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, - 0x72, 0x79, 0x2e, 0x52, 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, - 0x72, 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x53, 0x0a, 0x06, 0x45, - 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x25, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, - 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x1a, 0x48, 0x0a, 0x04, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, - 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, - 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x1a, 0x79, 0x0a, 0x06, 0x53, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, - 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x3d, 0x0a, 0x0c, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, - 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, - 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, - 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, - 0x74, 0x65, 0x64, 0x41, 0x74, 0x1a, 0x3f, 0x0a, 0x0b, 0x52, 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, + 0x72, 0x79, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x06, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, + 0x12, 0x34, 0x0a, 0x04, 0x72, 0x75, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, + 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x61, 0x6c, 0x75, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x75, 0x6c, 0x65, + 0x52, 0x04, 0x72, 0x75, 0x6c, 0x65, 0x12, 0x3a, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, + 0x74, 0x6f, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x12, 0x37, 0x0a, 0x05, 0x61, 0x6c, 0x65, 0x72, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, + 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x41, + 0x6c, 0x65, 0x72, 0x74, 0x52, 0x05, 0x61, 0x6c, 0x65, 0x72, 0x74, 0x12, 0x49, 0x0a, 0x0b, 0x72, + 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x61, + 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, + 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x72, 0x65, 0x6d, 0x65, 0x64, + 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x64, 0x0a, 0x17, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x45, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, + 0x64, 0x12, 0x25, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x11, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x59, 0x0a, 0x15, + 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, + 0x79, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, + 0x07, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x22, 0x8a, 0x01, 0x0a, 0x17, 0x45, 0x76, 0x61, 0x6c, + 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x64, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x3d, 0x0a, 0x0c, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, + 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, + 0x65, 0x64, 0x41, 0x74, 0x22, 0x50, 0x0a, 0x1c, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x1a, 0x39, 0x0a, 0x05, 0x41, 0x6c, 0x65, 0x72, 0x74, 0x12, - 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, - 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, - 0x73, 0x2a, 0x62, 0x0a, 0x0b, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4f, 0x77, 0x6e, 0x65, 0x72, - 0x12, 0x1c, 0x0a, 0x18, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, 0x52, - 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x18, - 0x0a, 0x14, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, 0x52, 0x5f, 0x50, - 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x10, 0x02, 0x12, 0x15, 0x0a, 0x11, 0x4f, 0x42, 0x4a, 0x45, - 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, 0x52, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x10, 0x03, 0x22, - 0x04, 0x08, 0x01, 0x10, 0x01, 0x2a, 0x95, 0x0e, 0x0a, 0x08, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, - 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1f, 0x0a, 0x0f, - 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, - 0x01, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, - 0x0c, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x02, 0x1a, - 0x07, 0xea, 0xdc, 0x14, 0x03, 0x67, 0x65, 0x74, 0x12, 0x1f, 0x0a, 0x0f, 0x52, 0x45, 0x4c, 0x41, - 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x03, 0x1a, 0x0a, 0xea, - 0xdc, 0x14, 0x06, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0f, 0x52, 0x45, 0x4c, - 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x04, 0x1a, 0x0a, - 0xea, 0xdc, 0x14, 0x06, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, 0x52, 0x45, - 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x4c, 0x49, 0x53, 0x54, - 0x10, 0x05, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6c, 0x69, 0x73, - 0x74, 0x12, 0x3b, 0x0a, 0x1d, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, - 0x4c, 0x45, 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x4c, 0x49, - 0x53, 0x54, 0x10, 0x06, 0x1a, 0x18, 0xea, 0xdc, 0x14, 0x14, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, - 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x12, 0x3f, - 0x0a, 0x1f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, - 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, - 0x45, 0x10, 0x07, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, 0x73, - 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x4a, 0x0a, 0x16, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x41, 0x6c, 0x65, 0x72, 0x74, + 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x2a, 0x62, 0x0a, 0x0b, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4f, 0x77, 0x6e, 0x65, + 0x72, 0x12, 0x1c, 0x0a, 0x18, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, + 0x52, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, + 0x18, 0x0a, 0x14, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, 0x52, 0x5f, + 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x10, 0x02, 0x12, 0x15, 0x0a, 0x11, 0x4f, 0x42, 0x4a, + 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, 0x52, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x10, 0x03, + 0x22, 0x04, 0x08, 0x01, 0x10, 0x01, 0x2a, 0x95, 0x0e, 0x0a, 0x08, 0x52, 0x65, 0x6c, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, + 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1f, 0x0a, + 0x0f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, + 0x10, 0x01, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x19, + 0x0a, 0x0c, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x02, + 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x67, 0x65, 0x74, 0x12, 0x1f, 0x0a, 0x0f, 0x52, 0x45, 0x4c, + 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x03, 0x1a, 0x0a, + 0xea, 0xdc, 0x14, 0x06, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0f, 0x52, 0x45, + 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x04, 0x1a, + 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, 0x52, + 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x4c, 0x49, 0x53, + 0x54, 0x10, 0x05, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6c, 0x69, + 0x73, 0x74, 0x12, 0x3b, 0x0a, 0x1d, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, + 0x4f, 0x4c, 0x45, 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x4c, + 0x49, 0x53, 0x54, 0x10, 0x06, 0x1a, 0x18, 0xea, 0xdc, 0x14, 0x14, 0x72, 0x6f, 0x6c, 0x65, 0x5f, + 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x12, 0x3f, 0x0a, 0x1f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, - 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x52, 0x45, 0x4d, 0x4f, - 0x56, 0x45, 0x10, 0x08, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, - 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, - 0x12, 0x23, 0x0a, 0x11, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x50, - 0x4f, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x09, 0x1a, 0x0c, 0xea, 0xdc, 0x14, 0x08, 0x72, 0x65, 0x70, - 0x6f, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, - 0x4e, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x0a, 0x1a, - 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, - 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x50, - 0x4f, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x0b, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, - 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x14, 0x52, - 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x44, 0x45, 0x4c, - 0x45, 0x54, 0x45, 0x10, 0x0c, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x5f, - 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x15, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, - 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x47, 0x45, 0x54, 0x10, - 0x0d, 0x1a, 0x10, 0xea, 0xdc, 0x14, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, - 0x67, 0x65, 0x74, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, - 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, - 0x0e, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, - 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, - 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x55, 0x50, 0x44, 0x41, - 0x54, 0x45, 0x10, 0x0f, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, - 0x63, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, - 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x44, - 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x10, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, 0x74, - 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0f, - 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x47, 0x45, 0x54, 0x10, - 0x11, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x70, 0x72, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x25, 0x0a, - 0x12, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x43, 0x52, 0x45, - 0x41, 0x54, 0x45, 0x10, 0x12, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x70, 0x72, 0x5f, 0x63, 0x72, - 0x65, 0x61, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, - 0x5f, 0x50, 0x52, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x13, 0x1a, 0x0d, 0xea, 0xdc, - 0x14, 0x09, 0x70, 0x72, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, 0x52, - 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, - 0x45, 0x10, 0x14, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x70, 0x72, 0x5f, 0x64, 0x65, 0x6c, 0x65, - 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x15, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, - 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x15, 0x1a, 0x10, 0xea, - 0xdc, 0x14, 0x0c, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x67, 0x65, 0x74, 0x12, - 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x56, - 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x16, 0x1a, 0x13, 0xea, - 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x72, 0x65, 0x61, - 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, - 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x17, - 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x75, - 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, - 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, - 0x45, 0x10, 0x18, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x2d, 0x0a, 0x16, 0x52, 0x45, 0x4c, 0x41, - 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x47, - 0x45, 0x54, 0x10, 0x19, 0x1a, 0x11, 0xea, 0xdc, 0x14, 0x0d, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, - 0x79, 0x70, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, 0x54, - 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x52, - 0x45, 0x41, 0x54, 0x45, 0x10, 0x1a, 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x72, 0x75, 0x6c, 0x65, - 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x33, 0x0a, 0x19, - 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, - 0x50, 0x45, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x1b, 0x1a, 0x14, 0xea, 0xdc, 0x14, - 0x10, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, - 0x65, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, - 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x1c, - 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, - 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, - 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x1d, - 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x67, 0x65, - 0x74, 0x12, 0x2f, 0x0a, 0x17, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, - 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x1e, 0x1a, 0x12, - 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x61, - 0x74, 0x65, 0x12, 0x2f, 0x0a, 0x17, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, - 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x1f, 0x1a, - 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x75, 0x70, 0x64, + 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x41, + 0x54, 0x45, 0x10, 0x07, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, + 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x12, 0x3f, 0x0a, 0x1f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, + 0x45, 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x52, 0x45, 0x4d, + 0x4f, 0x56, 0x45, 0x10, 0x08, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, + 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x6d, 0x6f, 0x76, + 0x65, 0x12, 0x23, 0x0a, 0x11, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, + 0x50, 0x4f, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x09, 0x1a, 0x0c, 0xea, 0xdc, 0x14, 0x08, 0x72, 0x65, + 0x70, 0x6f, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x0a, + 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, + 0x50, 0x4f, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x0b, 0x1a, 0x0f, 0xea, 0xdc, 0x14, + 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x14, + 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x44, 0x45, + 0x4c, 0x45, 0x54, 0x45, 0x10, 0x0c, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, 0x70, 0x6f, + 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x15, 0x52, 0x45, 0x4c, 0x41, 0x54, + 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x47, 0x45, 0x54, + 0x10, 0x0d, 0x1a, 0x10, 0xea, 0xdc, 0x14, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x5f, 0x67, 0x65, 0x74, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, + 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, + 0x10, 0x0e, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, + 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x55, 0x50, 0x44, + 0x41, 0x54, 0x45, 0x10, 0x0f, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, 0x74, 0x69, 0x66, + 0x61, 0x63, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, + 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, + 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x10, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, + 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1f, 0x0a, + 0x0f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x47, 0x45, 0x54, + 0x10, 0x11, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x70, 0x72, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x25, + 0x0a, 0x12, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x43, 0x52, + 0x45, 0x41, 0x54, 0x45, 0x10, 0x12, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x70, 0x72, 0x5f, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, + 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x13, 0x1a, 0x0d, 0xea, + 0xdc, 0x14, 0x09, 0x70, 0x72, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, + 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x44, 0x45, 0x4c, 0x45, + 0x54, 0x45, 0x10, 0x14, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x70, 0x72, 0x5f, 0x64, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x15, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, + 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x15, 0x1a, 0x10, + 0xea, 0xdc, 0x14, 0x0c, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x67, 0x65, 0x74, + 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, + 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x16, 0x1a, 0x13, + 0xea, 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, + 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, + 0x17, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, + 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x44, 0x45, 0x4c, 0x45, + 0x54, 0x45, 0x10, 0x18, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, + 0x65, 0x72, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x2d, 0x0a, 0x16, 0x52, 0x45, 0x4c, + 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, + 0x47, 0x45, 0x54, 0x10, 0x19, 0x1a, 0x11, 0xea, 0xdc, 0x14, 0x0d, 0x72, 0x75, 0x6c, 0x65, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, + 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x1a, 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x72, 0x75, 0x6c, + 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x33, 0x0a, + 0x19, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x1b, 0x1a, 0x14, 0xea, 0xdc, + 0x14, 0x10, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, + 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, + 0x1c, 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, + 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, + 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x47, 0x45, 0x54, 0x10, + 0x1d, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x67, + 0x65, 0x74, 0x12, 0x2f, 0x0a, 0x17, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, + 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x1e, 0x1a, + 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x2f, 0x0a, 0x17, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, - 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x20, - 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x64, 0x65, - 0x6c, 0x65, 0x74, 0x65, 0x12, 0x37, 0x0a, 0x1b, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, - 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, - 0x47, 0x45, 0x54, 0x10, 0x21, 0x1a, 0x16, 0xea, 0xdc, 0x14, 0x12, 0x70, 0x72, 0x6f, 0x66, 0x69, - 0x6c, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x31, 0x0a, - 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x4d, 0x4f, 0x54, 0x45, - 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x22, 0x1a, 0x13, 0xea, 0xdc, 0x14, - 0x0f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x67, 0x65, 0x74, - 0x12, 0x55, 0x0a, 0x2a, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x4e, 0x54, - 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x43, 0x4f, 0x4e, 0x43, 0x49, 0x4c, 0x49, 0x41, 0x54, 0x49, - 0x4f, 0x4e, 0x5f, 0x54, 0x41, 0x53, 0x4b, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x23, - 0x1a, 0x25, 0xea, 0xdc, 0x14, 0x21, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x72, 0x65, 0x63, - 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x61, 0x73, 0x6b, - 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, 0x54, - 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x43, 0x4f, 0x4e, - 0x43, 0x49, 0x4c, 0x45, 0x10, 0x24, 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x65, 0x6e, 0x74, 0x69, - 0x74, 0x79, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x12, 0x3f, 0x0a, 0x1f, - 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x41, 0x53, - 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, - 0x25, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x69, - 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2a, 0x82, 0x01, - 0x0a, 0x0e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x12, 0x1f, 0x0a, 0x1b, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, - 0x52, 0x43, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, - 0x00, 0x12, 0x18, 0x0a, 0x14, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, 0x4f, - 0x55, 0x52, 0x43, 0x45, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x01, 0x12, 0x18, 0x0a, 0x14, 0x54, - 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x55, - 0x53, 0x45, 0x52, 0x10, 0x02, 0x12, 0x1b, 0x0a, 0x17, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, - 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, - 0x10, 0x03, 0x2a, 0x72, 0x0a, 0x0c, 0x44, 0x65, 0x70, 0x45, 0x63, 0x6f, 0x73, 0x79, 0x73, 0x74, - 0x65, 0x6d, 0x12, 0x1d, 0x0a, 0x19, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, - 0x54, 0x45, 0x4d, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, - 0x00, 0x12, 0x15, 0x0a, 0x11, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, - 0x45, 0x4d, 0x5f, 0x4e, 0x50, 0x4d, 0x10, 0x01, 0x12, 0x14, 0x0a, 0x10, 0x44, 0x45, 0x50, 0x5f, - 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x5f, 0x47, 0x4f, 0x10, 0x02, 0x12, 0x16, - 0x0a, 0x12, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x5f, - 0x50, 0x59, 0x50, 0x49, 0x10, 0x03, 0x2a, 0x88, 0x01, 0x0a, 0x06, 0x45, 0x6e, 0x74, 0x69, 0x74, - 0x79, 0x12, 0x16, 0x0a, 0x12, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x55, 0x4e, 0x53, 0x50, - 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x45, 0x4e, 0x54, - 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x53, 0x49, 0x54, 0x4f, 0x52, 0x49, 0x45, 0x53, - 0x10, 0x01, 0x12, 0x1d, 0x0a, 0x19, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x42, 0x55, 0x49, - 0x4c, 0x44, 0x5f, 0x45, 0x4e, 0x56, 0x49, 0x52, 0x4f, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x53, 0x10, - 0x02, 0x12, 0x14, 0x0a, 0x10, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x41, 0x52, 0x54, 0x49, - 0x46, 0x41, 0x43, 0x54, 0x53, 0x10, 0x03, 0x12, 0x18, 0x0a, 0x14, 0x45, 0x4e, 0x54, 0x49, 0x54, - 0x59, 0x5f, 0x50, 0x55, 0x4c, 0x4c, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x45, 0x53, 0x54, 0x53, 0x10, - 0x04, 0x2a, 0x97, 0x02, 0x0a, 0x0c, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x79, - 0x70, 0x65, 0x12, 0x1d, 0x0a, 0x19, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, - 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, - 0x00, 0x12, 0x24, 0x0a, 0x14, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, - 0x50, 0x45, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x10, 0x01, 0x1a, 0x0a, 0xea, 0xdc, 0x14, - 0x06, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x12, 0x20, 0x0a, 0x12, 0x50, 0x52, 0x4f, 0x56, 0x49, - 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x52, 0x45, 0x53, 0x54, 0x10, 0x02, 0x1a, - 0x08, 0xea, 0xdc, 0x14, 0x04, 0x72, 0x65, 0x73, 0x74, 0x12, 0x1e, 0x0a, 0x11, 0x50, 0x52, 0x4f, - 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x47, 0x49, 0x54, 0x10, 0x03, - 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x67, 0x69, 0x74, 0x12, 0x1e, 0x0a, 0x11, 0x50, 0x52, 0x4f, - 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4f, 0x43, 0x49, 0x10, 0x04, - 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x6f, 0x63, 0x69, 0x12, 0x2e, 0x0a, 0x19, 0x50, 0x52, 0x4f, - 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, - 0x4c, 0x49, 0x53, 0x54, 0x45, 0x52, 0x10, 0x05, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, - 0x70, 0x6f, 0x2d, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x72, 0x12, 0x30, 0x0a, 0x1a, 0x50, 0x52, 0x4f, - 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4d, 0x41, 0x47, 0x45, - 0x5f, 0x4c, 0x49, 0x53, 0x54, 0x45, 0x52, 0x10, 0x06, 0x1a, 0x10, 0xea, 0xdc, 0x14, 0x0c, 0x69, - 0x6d, 0x61, 0x67, 0x65, 0x2d, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x72, 0x2a, 0xd5, 0x01, 0x0a, 0x0d, - 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x1e, 0x0a, - 0x1a, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, - 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x25, 0x0a, - 0x15, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, - 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x10, 0x01, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x67, 0x69, - 0x74, 0x68, 0x75, 0x62, 0x12, 0x2d, 0x0a, 0x19, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, - 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x5f, 0x41, 0x50, - 0x50, 0x10, 0x02, 0x1a, 0x0e, 0xea, 0xdc, 0x14, 0x0a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2d, - 0x61, 0x70, 0x70, 0x12, 0x21, 0x0a, 0x13, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, - 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x47, 0x48, 0x43, 0x52, 0x10, 0x03, 0x1a, 0x08, 0xea, 0xdc, - 0x14, 0x04, 0x67, 0x68, 0x63, 0x72, 0x12, 0x2b, 0x0a, 0x18, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, - 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x44, 0x4f, 0x43, 0x4b, 0x45, 0x52, 0x48, - 0x55, 0x42, 0x10, 0x04, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x64, 0x6f, 0x63, 0x6b, 0x65, 0x72, - 0x68, 0x75, 0x62, 0x2a, 0xa9, 0x02, 0x0a, 0x11, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x6c, 0x6f, 0x77, 0x12, 0x22, 0x0a, 0x1e, 0x41, 0x55, 0x54, - 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, - 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x25, 0x0a, - 0x17, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, - 0x4c, 0x4f, 0x57, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x01, 0x1a, 0x08, 0xea, 0xdc, 0x14, 0x04, - 0x6e, 0x6f, 0x6e, 0x65, 0x12, 0x31, 0x0a, 0x1d, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, - 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x5f, - 0x49, 0x4e, 0x50, 0x55, 0x54, 0x10, 0x02, 0x1a, 0x0e, 0xea, 0xdc, 0x14, 0x0a, 0x75, 0x73, 0x65, - 0x72, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x12, 0x59, 0x0a, 0x31, 0x41, 0x55, 0x54, 0x48, 0x4f, - 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x4f, 0x41, - 0x55, 0x54, 0x48, 0x32, 0x5f, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, - 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x10, 0x03, 0x1a, 0x22, - 0xea, 0xdc, 0x14, 0x1e, 0x6f, 0x61, 0x75, 0x74, 0x68, 0x32, 0x5f, 0x61, 0x75, 0x74, 0x68, 0x6f, - 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x66, 0x6c, - 0x6f, 0x77, 0x12, 0x3b, 0x0a, 0x22, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, - 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x5f, - 0x41, 0x50, 0x50, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x10, 0x04, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, - 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x5f, 0x61, 0x70, 0x70, 0x5f, 0x66, 0x6c, 0x6f, 0x77, 0x2a, - 0xbb, 0x01, 0x0a, 0x10, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x53, - 0x74, 0x61, 0x74, 0x65, 0x12, 0x21, 0x0a, 0x1d, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, - 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, - 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x22, 0x0a, 0x15, 0x43, 0x52, 0x45, 0x44, 0x45, - 0x4e, 0x54, 0x49, 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x45, 0x54, - 0x10, 0x01, 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x73, 0x65, 0x74, 0x12, 0x26, 0x0a, 0x17, 0x43, - 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, - 0x5f, 0x55, 0x4e, 0x53, 0x45, 0x54, 0x10, 0x02, 0x1a, 0x09, 0xea, 0xdc, 0x14, 0x05, 0x75, 0x6e, - 0x73, 0x65, 0x74, 0x12, 0x38, 0x0a, 0x20, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, 0x41, - 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x41, 0x50, 0x50, - 0x4c, 0x49, 0x43, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x03, 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x6e, - 0x6f, 0x74, 0x5f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x7d, 0x0a, - 0x0d, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x6c, - 0x0a, 0x0b, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x1d, 0x2e, + 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x1f, + 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x12, 0x2f, 0x0a, 0x17, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, + 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, + 0x20, 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x64, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x37, 0x0a, 0x1b, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, + 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, + 0x5f, 0x47, 0x45, 0x54, 0x10, 0x21, 0x1a, 0x16, 0xea, 0xdc, 0x14, 0x12, 0x70, 0x72, 0x6f, 0x66, + 0x69, 0x6c, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x31, + 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x4d, 0x4f, 0x54, + 0x45, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x22, 0x1a, 0x13, 0xea, 0xdc, + 0x14, 0x0f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x67, 0x65, + 0x74, 0x12, 0x55, 0x0a, 0x2a, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x4e, + 0x54, 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x43, 0x4f, 0x4e, 0x43, 0x49, 0x4c, 0x49, 0x41, 0x54, + 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x41, 0x53, 0x4b, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, + 0x23, 0x1a, 0x25, 0xea, 0xdc, 0x14, 0x21, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x72, 0x65, + 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x61, 0x73, + 0x6b, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x43, 0x4f, + 0x4e, 0x43, 0x49, 0x4c, 0x45, 0x10, 0x24, 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x12, 0x3f, 0x0a, + 0x1f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x41, + 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, + 0x10, 0x25, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, 0x73, 0x73, + 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2a, 0x82, + 0x01, 0x0a, 0x0e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x12, 0x1f, 0x0a, 0x1b, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, 0x4f, + 0x55, 0x52, 0x43, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, + 0x10, 0x00, 0x12, 0x18, 0x0a, 0x14, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, + 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x01, 0x12, 0x18, 0x0a, 0x14, + 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, + 0x55, 0x53, 0x45, 0x52, 0x10, 0x02, 0x12, 0x1b, 0x0a, 0x17, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, + 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, + 0x54, 0x10, 0x03, 0x2a, 0x72, 0x0a, 0x0c, 0x44, 0x65, 0x70, 0x45, 0x63, 0x6f, 0x73, 0x79, 0x73, + 0x74, 0x65, 0x6d, 0x12, 0x1d, 0x0a, 0x19, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, + 0x53, 0x54, 0x45, 0x4d, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, + 0x10, 0x00, 0x12, 0x15, 0x0a, 0x11, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, + 0x54, 0x45, 0x4d, 0x5f, 0x4e, 0x50, 0x4d, 0x10, 0x01, 0x12, 0x14, 0x0a, 0x10, 0x44, 0x45, 0x50, + 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x5f, 0x47, 0x4f, 0x10, 0x02, 0x12, + 0x16, 0x0a, 0x12, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, + 0x5f, 0x50, 0x59, 0x50, 0x49, 0x10, 0x03, 0x2a, 0x88, 0x01, 0x0a, 0x06, 0x45, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x12, 0x16, 0x0a, 0x12, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x55, 0x4e, 0x53, + 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x45, 0x4e, + 0x54, 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x53, 0x49, 0x54, 0x4f, 0x52, 0x49, 0x45, + 0x53, 0x10, 0x01, 0x12, 0x1d, 0x0a, 0x19, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x42, 0x55, + 0x49, 0x4c, 0x44, 0x5f, 0x45, 0x4e, 0x56, 0x49, 0x52, 0x4f, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x53, + 0x10, 0x02, 0x12, 0x14, 0x0a, 0x10, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x41, 0x52, 0x54, + 0x49, 0x46, 0x41, 0x43, 0x54, 0x53, 0x10, 0x03, 0x12, 0x18, 0x0a, 0x14, 0x45, 0x4e, 0x54, 0x49, + 0x54, 0x59, 0x5f, 0x50, 0x55, 0x4c, 0x4c, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x45, 0x53, 0x54, 0x53, + 0x10, 0x04, 0x2a, 0x97, 0x02, 0x0a, 0x0c, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x1d, 0x0a, 0x19, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, + 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, + 0x10, 0x00, 0x12, 0x24, 0x0a, 0x14, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x10, 0x01, 0x1a, 0x0a, 0xea, 0xdc, + 0x14, 0x06, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x12, 0x20, 0x0a, 0x12, 0x50, 0x52, 0x4f, 0x56, + 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x52, 0x45, 0x53, 0x54, 0x10, 0x02, + 0x1a, 0x08, 0xea, 0xdc, 0x14, 0x04, 0x72, 0x65, 0x73, 0x74, 0x12, 0x1e, 0x0a, 0x11, 0x50, 0x52, + 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x47, 0x49, 0x54, 0x10, + 0x03, 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x67, 0x69, 0x74, 0x12, 0x1e, 0x0a, 0x11, 0x50, 0x52, + 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4f, 0x43, 0x49, 0x10, + 0x04, 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x6f, 0x63, 0x69, 0x12, 0x2e, 0x0a, 0x19, 0x50, 0x52, + 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x52, 0x45, 0x50, 0x4f, + 0x5f, 0x4c, 0x49, 0x53, 0x54, 0x45, 0x52, 0x10, 0x05, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, + 0x65, 0x70, 0x6f, 0x2d, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x72, 0x12, 0x30, 0x0a, 0x1a, 0x50, 0x52, + 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4d, 0x41, 0x47, + 0x45, 0x5f, 0x4c, 0x49, 0x53, 0x54, 0x45, 0x52, 0x10, 0x06, 0x1a, 0x10, 0xea, 0xdc, 0x14, 0x0c, + 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2d, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x72, 0x2a, 0xd5, 0x01, 0x0a, + 0x0d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x1e, + 0x0a, 0x1a, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, + 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x25, + 0x0a, 0x15, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, + 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x10, 0x01, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x12, 0x2d, 0x0a, 0x19, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, + 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x5f, 0x41, + 0x50, 0x50, 0x10, 0x02, 0x1a, 0x0e, 0xea, 0xdc, 0x14, 0x0a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2d, 0x61, 0x70, 0x70, 0x12, 0x21, 0x0a, 0x13, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, + 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x47, 0x48, 0x43, 0x52, 0x10, 0x03, 0x1a, 0x08, 0xea, + 0xdc, 0x14, 0x04, 0x67, 0x68, 0x63, 0x72, 0x12, 0x2b, 0x0a, 0x18, 0x50, 0x52, 0x4f, 0x56, 0x49, + 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x44, 0x4f, 0x43, 0x4b, 0x45, 0x52, + 0x48, 0x55, 0x42, 0x10, 0x04, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x64, 0x6f, 0x63, 0x6b, 0x65, + 0x72, 0x68, 0x75, 0x62, 0x2a, 0xa9, 0x02, 0x0a, 0x11, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, + 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x6c, 0x6f, 0x77, 0x12, 0x22, 0x0a, 0x1e, 0x41, 0x55, + 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, + 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x25, + 0x0a, 0x17, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, + 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x01, 0x1a, 0x08, 0xea, 0xdc, 0x14, + 0x04, 0x6e, 0x6f, 0x6e, 0x65, 0x12, 0x31, 0x0a, 0x1d, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, + 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x55, 0x53, 0x45, 0x52, + 0x5f, 0x49, 0x4e, 0x50, 0x55, 0x54, 0x10, 0x02, 0x1a, 0x0e, 0xea, 0xdc, 0x14, 0x0a, 0x75, 0x73, + 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x12, 0x59, 0x0a, 0x31, 0x41, 0x55, 0x54, 0x48, + 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x4f, + 0x41, 0x55, 0x54, 0x48, 0x32, 0x5f, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, + 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x10, 0x03, 0x1a, + 0x22, 0xea, 0xdc, 0x14, 0x1e, 0x6f, 0x61, 0x75, 0x74, 0x68, 0x32, 0x5f, 0x61, 0x75, 0x74, 0x68, + 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x66, + 0x6c, 0x6f, 0x77, 0x12, 0x3b, 0x0a, 0x22, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, + 0x5f, 0x41, 0x50, 0x50, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x10, 0x04, 0x1a, 0x13, 0xea, 0xdc, 0x14, + 0x0f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x5f, 0x61, 0x70, 0x70, 0x5f, 0x66, 0x6c, 0x6f, 0x77, + 0x2a, 0xbb, 0x01, 0x0a, 0x10, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x21, 0x0a, 0x1d, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, + 0x49, 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, + 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x22, 0x0a, 0x15, 0x43, 0x52, 0x45, 0x44, + 0x45, 0x4e, 0x54, 0x49, 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x45, + 0x54, 0x10, 0x01, 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x73, 0x65, 0x74, 0x12, 0x26, 0x0a, 0x17, + 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, + 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x45, 0x54, 0x10, 0x02, 0x1a, 0x09, 0xea, 0xdc, 0x14, 0x05, 0x75, + 0x6e, 0x73, 0x65, 0x74, 0x12, 0x38, 0x0a, 0x20, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, + 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x41, 0x50, + 0x50, 0x4c, 0x49, 0x43, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x03, 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, + 0x6e, 0x6f, 0x74, 0x5f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x7d, + 0x0a, 0x0d, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, + 0x6c, 0x0a, 0x0b, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x1d, + 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, + 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, - 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, - 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1e, 0xaa, 0xf8, - 0x18, 0x04, 0x10, 0x01, 0x30, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x10, 0x12, 0x0e, 0x2f, 0x61, - 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x32, 0xbc, 0x03, 0x0a, - 0x0f, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x12, 0x95, 0x01, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, - 0x74, 0x73, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, - 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x4c, 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x41, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0d, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x33, 0x5a, 0x13, 0x12, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, - 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x12, 0x1c, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x2f, 0x7b, 0x70, - 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x12, 0x7f, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x41, - 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, 0x12, 0x21, 0x2e, 0x6d, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, - 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, - 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, - 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x25, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0d, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x17, 0x12, 0x15, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, - 0x66, 0x61, 0x63, 0x74, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x8f, 0x01, 0x0a, 0x11, 0x47, 0x65, - 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, - 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, - 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, 0x61, - 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2f, 0xaa, 0xf8, 0x18, 0x04, - 0x30, 0x03, 0x38, 0x0d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x21, 0x12, 0x1f, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x2f, 0x6e, 0x61, 0x6d, - 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x32, 0xb6, 0x05, 0x0a, 0x0c, - 0x4f, 0x41, 0x75, 0x74, 0x68, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x86, 0x01, 0x0a, - 0x13, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x55, 0x52, 0x4c, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, - 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x12, 0x12, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, - 0x68, 0x2f, 0x75, 0x72, 0x6c, 0x12, 0xac, 0x01, 0x0a, 0x12, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x50, - 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x24, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x50, 0x72, - 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, - 0x74, 0x6f, 0x72, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, - 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x49, 0xaa, 0xf8, 0x18, 0x04, 0x30, - 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3b, 0x3a, 0x01, 0x2a, 0x5a, 0x17, 0x3a, 0x01, - 0x2a, 0x22, 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, - 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x1d, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, - 0x75, 0x74, 0x68, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x74, - 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0xd2, 0x01, 0x0a, 0x17, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, + 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1e, 0xaa, + 0xf8, 0x18, 0x04, 0x10, 0x01, 0x30, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x10, 0x12, 0x0e, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x32, 0xbc, 0x03, + 0x0a, 0x0f, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x12, 0x95, 0x01, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x73, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x4c, 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x41, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0d, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x33, 0x5a, 0x13, 0x12, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, + 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x12, 0x1c, 0x2f, 0x61, 0x70, + 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x2f, 0x7b, + 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x12, 0x7f, 0x0a, 0x0f, 0x47, 0x65, 0x74, + 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, 0x12, 0x21, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, + 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, + 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x25, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0d, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x8f, 0x01, 0x0a, 0x11, 0x47, + 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, + 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, + 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, + 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2f, 0xaa, 0xf8, 0x18, + 0x04, 0x30, 0x03, 0x38, 0x0d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x21, 0x12, 0x1f, 0x2f, 0x61, 0x70, + 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x2f, 0x6e, 0x61, + 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x32, 0xb6, 0x05, 0x0a, + 0x0c, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x86, 0x01, + 0x0a, 0x13, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x55, 0x52, 0x4c, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, + 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x12, 0x12, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, + 0x74, 0x68, 0x2f, 0x75, 0x72, 0x6c, 0x12, 0xac, 0x01, 0x0a, 0x12, 0x53, 0x74, 0x6f, 0x72, 0x65, + 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x24, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x50, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x53, 0x74, 0x6f, 0x72, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, + 0x65, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x49, 0xaa, 0xf8, 0x18, 0x04, + 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3b, 0x3a, 0x01, 0x2a, 0x5a, 0x17, 0x3a, + 0x01, 0x2a, 0x22, 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, + 0x2f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x1d, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, + 0x61, 0x75, 0x74, 0x68, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, + 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0xd2, 0x01, 0x0a, 0x17, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, + 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x72, 0x6f, + 0x6d, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, + 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, + 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x72, 0x6f, 0x6d, - 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, - 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, - 0x46, 0x72, 0x6f, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, - 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x60, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, - 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4f, 0x5a, 0x21, 0x12, 0x1f, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x2f, 0x7b, - 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x7d, 0x12, 0x2a, 0x2f, 0x61, 0x70, 0x69, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x60, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, + 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4f, 0x5a, 0x21, 0x12, 0x1f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x2f, - 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x7b, 0x74, 0x69, 0x6d, 0x65, - 0x73, 0x74, 0x61, 0x6d, 0x70, 0x7d, 0x88, 0x02, 0x01, 0x12, 0x98, 0x01, 0x0a, 0x18, 0x56, 0x65, - 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x72, 0x65, 0x64, - 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x56, + 0x7b, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x7d, 0x12, 0x2a, 0x2f, 0x61, 0x70, + 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, + 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x7b, 0x74, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x7d, 0x88, 0x02, 0x01, 0x12, 0x98, 0x01, 0x0a, 0x18, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x72, 0x65, - 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x12, - 0x13, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, 0x65, - 0x72, 0x69, 0x66, 0x79, 0x32, 0xe9, 0x0a, 0x0a, 0x11, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x6f, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0xc7, 0x01, 0x0a, 0x12, 0x52, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, + 0x65, 0x72, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x72, + 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, + 0x12, 0x13, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, + 0x65, 0x72, 0x69, 0x66, 0x79, 0x32, 0xe9, 0x0a, 0x0a, 0x11, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, + 0x74, 0x6f, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0xc7, 0x01, 0x0a, 0x12, + 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, + 0x72, 0x79, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, - 0x79, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, - 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6f, - 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x64, - 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x56, 0x3a, 0x01, - 0x2a, 0x5a, 0x20, 0x3a, 0x01, 0x2a, 0x22, 0x1b, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, - 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x72, 0x65, 0x67, 0x69, 0x73, - 0x74, 0x65, 0x72, 0x22, 0x2f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, - 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x72, 0x65, 0x67, 0x69, - 0x73, 0x74, 0x65, 0x72, 0x12, 0xf1, 0x01, 0x0a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x6d, + 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x64, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x56, 0x3a, + 0x01, 0x2a, 0x5a, 0x20, 0x3a, 0x01, 0x2a, 0x22, 0x1b, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, + 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x72, 0x65, 0x67, 0x69, + 0x73, 0x74, 0x65, 0x72, 0x22, 0x2f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x72, 0x65, 0x67, + 0x69, 0x73, 0x74, 0x65, 0x72, 0x12, 0xf1, 0x01, 0x0a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, + 0x6d, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, + 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x34, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x46, - 0x72, 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x34, 0x2e, 0x6d, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x6d, 0x6f, - 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x46, 0x72, - 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x35, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, - 0x73, 0x74, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, - 0x72, 0x69, 0x65, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5e, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, - 0x38, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x50, 0x5a, 0x1d, 0x12, 0x1b, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, - 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x12, 0x2f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, - 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x2f, 0x70, 0x72, - 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, - 0x7d, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x12, 0xad, 0x01, 0x0a, 0x10, 0x4c, 0x69, 0x73, - 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x12, 0x22, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, - 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, - 0x73, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x50, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x09, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x42, 0x5a, 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, - 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x12, 0x28, - 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, - 0x72, 0x69, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, - 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x12, 0x95, 0x01, 0x0a, 0x11, 0x47, 0x65, 0x74, - 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x12, 0x23, - 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, - 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, - 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0xaa, 0xf8, 0x18, 0x04, 0x30, - 0x03, 0x38, 0x09, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12, 0x25, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x69, 0x64, - 0x2f, 0x7b, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x69, 0x64, 0x7d, - 0x12, 0xd0, 0x01, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, - 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, - 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, - 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, - 0x09, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5c, 0x5a, 0x23, 0x12, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x6e, 0x61, - 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x12, 0x35, 0x2f, 0x61, - 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, - 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, - 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, - 0x2a, 0x2a, 0x7d, 0x12, 0x9e, 0x01, 0x0a, 0x14, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, - 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x12, 0x26, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, + 0x72, 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x35, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, + 0x69, 0x73, 0x74, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x6f, 0x72, 0x69, 0x65, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5e, 0xaa, 0xf8, 0x18, 0x04, 0x30, + 0x03, 0x38, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x50, 0x5a, 0x1d, 0x12, 0x1b, 0x2f, 0x61, 0x70, + 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, + 0x73, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x12, 0x2f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, + 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x2f, 0x70, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x72, 0x7d, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x12, 0xad, 0x01, 0x0a, 0x10, 0x4c, 0x69, + 0x73, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x12, 0x22, + 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, + 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, + 0x69, 0x73, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x50, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, + 0x09, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x42, 0x5a, 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x12, + 0x28, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x6f, 0x72, 0x69, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, + 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x12, 0x95, 0x01, 0x0a, 0x11, 0x47, 0x65, + 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x12, + 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, - 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x2a, 0x25, 0x2f, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, + 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0xaa, 0xf8, 0x18, 0x04, + 0x30, 0x03, 0x38, 0x09, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12, 0x25, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x69, + 0x64, 0x2f, 0x7b, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x69, 0x64, + 0x7d, 0x12, 0xd0, 0x01, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, + 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, + 0x38, 0x09, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5c, 0x5a, 0x23, 0x12, 0x21, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x6e, + 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x12, 0x35, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, - 0x79, 0x2f, 0x69, 0x64, 0x2f, 0x7b, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, - 0x5f, 0x69, 0x64, 0x7d, 0x12, 0xd9, 0x01, 0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, - 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, - 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, - 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, - 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, - 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x5c, 0x5a, 0x23, 0x2a, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, - 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, - 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x2a, 0x35, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x70, 0x72, - 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, - 0x7d, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, - 0x32, 0xce, 0x04, 0x0a, 0x0b, 0x55, 0x73, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x12, 0x68, 0x0a, 0x0a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1c, - 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, - 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, - 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0xaa, 0xf8, 0x18, - 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x3a, 0x01, 0x2a, 0x22, 0x0c, 0x2f, 0x61, - 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x12, 0x65, 0x0a, 0x0a, 0x44, 0x65, - 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x0e, 0x2a, 0x0c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, - 0x72, 0x12, 0x5c, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x12, 0x19, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x1a, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x0e, 0x12, 0x0c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x12, - 0x80, 0x01, 0x0a, 0x0f, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x12, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x02, - 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, - 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x12, 0x8c, 0x01, 0x0a, 0x11, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x49, 0x6e, - 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x49, 0x6e, 0x76, 0x69, - 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, - 0x65, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x2c, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x20, 0x22, 0x1e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2f, - 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x7b, 0x63, 0x6f, 0x64, 0x65, - 0x7d, 0x32, 0xb7, 0x0e, 0x0a, 0x0e, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x65, 0x72, - 0x76, 0x69, 0x63, 0x65, 0x12, 0x76, 0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, - 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, + 0x3d, 0x2a, 0x2a, 0x7d, 0x12, 0x9e, 0x01, 0x0a, 0x14, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, + 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x12, 0x26, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, + 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, + 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x2a, 0x25, + 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, + 0x72, 0x79, 0x2f, 0x69, 0x64, 0x2f, 0x7b, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, + 0x79, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0xd9, 0x01, 0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, + 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, + 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x5c, 0x5a, 0x23, 0x2a, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, + 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x6e, 0x61, 0x6d, 0x65, + 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x2a, 0x35, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x70, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x72, 0x7d, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, + 0x7d, 0x32, 0xce, 0x04, 0x0a, 0x0b, 0x55, 0x73, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x12, 0x68, 0x0a, 0x0a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, + 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0xaa, 0xf8, + 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x3a, 0x01, 0x2a, 0x22, 0x0c, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x12, 0x65, 0x0a, 0x0a, 0x44, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x0e, 0x2a, 0x0c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, + 0x65, 0x72, 0x12, 0x5c, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x12, 0x19, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, + 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x0e, 0x12, 0x0c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, + 0x12, 0x80, 0x01, 0x0a, 0x0f, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, + 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x12, 0x8c, 0x01, 0x0a, 0x11, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x49, + 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x49, 0x6e, 0x76, + 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, + 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, + 0x76, 0x65, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2c, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x20, 0x22, 0x1e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, + 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x7b, 0x63, 0x6f, 0x64, + 0x65, 0x7d, 0x32, 0xb7, 0x0e, 0x0a, 0x0e, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x76, 0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, + 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, - 0x38, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x3a, 0x01, 0x2a, 0x22, 0x0f, 0x2f, 0x61, 0x70, - 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x76, 0x0a, 0x0d, - 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1f, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, - 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, + 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, + 0x03, 0x38, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x3a, 0x01, 0x2a, 0x22, 0x0f, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x76, 0x0a, + 0x0d, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, - 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, - 0x3a, 0x01, 0x2a, 0x1a, 0x0f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, - 0x66, 0x69, 0x6c, 0x65, 0x12, 0x7c, 0x0a, 0x0c, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, - 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2b, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1f, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x3a, 0x05, 0x70, 0x61, 0x74, 0x63, 0x68, 0x32, 0x14, 0x2f, 0x61, - 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, 0x69, - 0x64, 0x7d, 0x12, 0x78, 0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, - 0x69, 0x6c, 0x65, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x14, 0x3a, 0x01, 0x2a, 0x1a, 0x0f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, + 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x7c, 0x0a, 0x0c, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, + 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2b, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1f, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x3a, 0x05, 0x70, 0x61, 0x74, 0x63, 0x68, 0x32, 0x14, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, + 0x69, 0x64, 0x7d, 0x12, 0x78, 0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, + 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x20, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x2a, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, - 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x71, 0x0a, 0x0c, - 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x1e, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, - 0x66, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, - 0x66, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x12, 0x10, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x12, - 0x7b, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, 0x49, - 0x64, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, - 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1d, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, - 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0xa4, 0x01, 0x0a, - 0x16, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, - 0x73, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, - 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, - 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0xaa, 0xf8, - 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12, 0x25, 0x2f, 0x61, - 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x6e, 0x61, - 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x2f, 0x73, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x12, 0x9e, 0x01, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, - 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, - 0x74, 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, - 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, - 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, - 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, - 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x50, 0x72, 0x6f, - 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, - 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x61, - 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x12, 0x76, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6c, 0x65, - 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, + 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x2a, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, + 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x71, 0x0a, + 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x1e, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, + 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, + 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, + 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x12, 0x10, + 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, + 0x12, 0x7b, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, + 0x49, 0x64, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, + 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, + 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, + 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0xa4, 0x01, + 0x0a, 0x16, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, + 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, + 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0xaa, + 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12, 0x25, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x6e, + 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x2f, 0x73, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x12, 0x9e, 0x01, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, + 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x50, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, + 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, + 0x79, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x2c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, + 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x50, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, + 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x76, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6c, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, - 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x12, 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, - 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x12, 0x90, 0x01, 0x0a, - 0x11, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x4e, 0x61, - 0x6d, 0x65, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, - 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, + 0x03, 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x12, 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x12, 0x90, 0x01, + 0x0a, 0x11, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x4e, + 0x61, 0x6d, 0x65, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x4e, 0x61, 0x6d, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, + 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, + 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22, 0x12, 0x20, + 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, + 0x65, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, + 0x12, 0x80, 0x01, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, + 0x42, 0x79, 0x49, 0x64, 0x12, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x49, 0x64, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, - 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22, 0x12, 0x20, 0x2f, + 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, + 0x04, 0x30, 0x03, 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x61, 0x70, + 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x7b, + 0x69, 0x64, 0x7d, 0x12, 0x7b, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, + 0x30, 0x03, 0x38, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x22, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, - 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x12, - 0x80, 0x01, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, - 0x79, 0x49, 0x64, 0x12, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, - 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x04, - 0x30, 0x03, 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x7b, 0x69, - 0x64, 0x7d, 0x12, 0x7b, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, - 0x54, 0x79, 0x70, 0x65, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, - 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, - 0x03, 0x38, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x22, 0x11, 0x2f, 0x61, - 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x12, - 0x7b, 0x0a, 0x0e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, - 0x65, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, - 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1b, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x1a, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x12, 0x7d, 0x0a, 0x0e, - 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x20, - 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, - 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, - 0x65, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1c, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x18, 0x2a, 0x16, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, - 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x32, 0xb0, 0x02, 0x0a, 0x12, - 0x45, 0x76, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, - 0x63, 0x65, 0x12, 0x8b, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x27, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, - 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x1f, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x12, - 0x0f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, - 0x12, 0x8b, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6e, - 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, - 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x12, 0x0f, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x32, 0x8a, - 0x05, 0x0a, 0x12, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x53, 0x65, - 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x71, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, - 0x65, 0x73, 0x12, 0x1b, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, - 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, - 0x52, 0x6f, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x29, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x05, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1b, 0x12, 0x19, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, - 0x6e, 0x73, 0x2f, 0x72, 0x6f, 0x6c, 0x65, 0x73, 0x12, 0x95, 0x01, 0x0a, 0x13, 0x4c, 0x69, 0x73, - 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, - 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, - 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, 0x69, - 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x2f, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x06, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x21, 0x12, - 0x1f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, - 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, - 0x12, 0x78, 0x0a, 0x0a, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x1c, - 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x73, 0x73, 0x69, 0x67, - 0x6e, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x52, - 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0xaa, 0xf8, 0x18, - 0x04, 0x30, 0x03, 0x38, 0x07, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x3a, 0x01, 0x2a, 0x22, 0x1a, + 0x12, 0x7b, 0x0a, 0x0e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, + 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x1a, 0x11, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x12, 0x7d, 0x0a, + 0x0e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, + 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1c, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x18, 0x2a, 0x16, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, + 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x32, 0xb0, 0x02, 0x0a, + 0x12, 0x45, 0x76, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x53, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x12, 0x8b, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, + 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x27, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, + 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x1f, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, + 0x12, 0x0f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x73, 0x12, 0x8b, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x27, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, + 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, + 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, + 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x12, 0x0f, + 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x32, + 0x8a, 0x05, 0x0a, 0x12, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x71, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, + 0x6c, 0x65, 0x73, 0x12, 0x1b, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, + 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x29, + 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x05, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1b, 0x12, 0x19, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, - 0x6f, 0x6e, 0x73, 0x2f, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x12, 0x78, 0x0a, 0x0a, 0x55, 0x70, - 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x25, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x3a, 0x01, 0x2a, 0x22, 0x1a, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, - 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x75, 0x70, - 0x64, 0x61, 0x74, 0x65, 0x12, 0x75, 0x0a, 0x0a, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x6f, - 0x6c, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, - 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6d, - 0x6f, 0x76, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x2a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x08, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x2a, + 0x6f, 0x6e, 0x73, 0x2f, 0x72, 0x6f, 0x6c, 0x65, 0x73, 0x12, 0x95, 0x01, 0x0a, 0x13, 0x4c, 0x69, + 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, + 0x73, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, + 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x2f, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x06, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x21, + 0x12, 0x1f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, + 0x73, 0x12, 0x78, 0x0a, 0x0a, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x52, 0x6f, 0x6c, 0x65, 0x12, + 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x73, 0x73, 0x69, + 0x67, 0x6e, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, + 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0xaa, 0xf8, + 0x18, 0x04, 0x30, 0x03, 0x38, 0x07, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x3a, 0x01, 0x2a, 0x22, 0x1a, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, - 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x32, 0xc5, 0x07, 0x0a, 0x0f, - 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, - 0x71, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, - 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, - 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, - 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x02, 0x38, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, - 0x12, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, - 0x74, 0x73, 0x12, 0x77, 0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, - 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x12, 0x78, 0x0a, 0x0a, 0x55, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x25, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x3a, 0x01, 0x2a, 0x22, 0x1a, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x75, 0x0a, 0x0a, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, + 0x6f, 0x6c, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, + 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x2a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x08, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, + 0x2a, 0x1a, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x32, 0xc5, 0x07, 0x0a, + 0x0f, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x12, 0x71, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, + 0x12, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, + 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, + 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x02, 0x38, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x12, 0x12, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x73, 0x12, 0x77, 0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x01, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x3a, 0x01, 0x2a, 0x22, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x9e, 0x01, 0x0a, 0x11, - 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, - 0x73, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, - 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, 0x6a, - 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e, 0xaa, 0xf8, - 0x18, 0x04, 0x30, 0x03, 0x38, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, 0x61, - 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2f, 0x7b, - 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, - 0x69, 0x64, 0x7d, 0x2f, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x12, 0x74, 0x0a, 0x0d, - 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, - 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, + 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x3a, 0x01, 0x2a, 0x22, 0x10, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x9e, 0x01, 0x0a, + 0x11, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x73, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, + 0x69, 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e, 0xaa, + 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2f, + 0x7b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x12, 0x74, 0x0a, + 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, - 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x04, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, - 0x2a, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, - 0x74, 0x73, 0x12, 0x77, 0x0a, 0x0d, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, - 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x04, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x12, 0x2a, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x73, 0x12, 0x77, 0x0a, 0x0d, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x03, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x3a, 0x01, 0x2a, 0x1a, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x78, 0x0a, 0x0c, 0x50, - 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1e, 0x2e, 0x6d, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, - 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, - 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x27, 0xaa, 0xf8, - 0x18, 0x04, 0x30, 0x03, 0x38, 0x03, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x3a, 0x05, 0x70, 0x61, - 0x74, 0x63, 0x68, 0x32, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, - 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0xbb, 0x01, 0x0a, 0x1e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, - 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, - 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, - 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x6d, 0x69, 0x6e, - 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, - 0x69, 0x74, 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x23, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x26, 0x3a, 0x01, 0x2a, - 0x22, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, - 0x74, 0x73, 0x2f, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2f, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x63, - 0x69, 0x6c, 0x65, 0x32, 0xd5, 0x09, 0x0a, 0x10, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, - 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x7c, 0x0a, 0x0d, 0x50, 0x61, 0x74, 0x63, - 0x68, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x76, 0x69, - 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, + 0x03, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x3a, 0x01, 0x2a, 0x1a, 0x10, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x78, 0x0a, 0x0c, + 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1e, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x27, 0xaa, + 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x03, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x3a, 0x05, 0x70, + 0x61, 0x74, 0x63, 0x68, 0x32, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0xbb, 0x01, 0x0a, 0x1e, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34, + 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x23, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x26, 0x3a, 0x01, + 0x2a, 0x22, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x73, 0x2f, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2f, 0x72, 0x65, 0x63, 0x6f, 0x6e, + 0x63, 0x69, 0x6c, 0x65, 0x32, 0xd5, 0x09, 0x0a, 0x10, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x72, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x7c, 0x0a, 0x0d, 0x50, 0x61, 0x74, + 0x63, 0x68, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x76, - 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0xaa, 0xf8, - 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x3a, 0x05, 0x70, 0x61, - 0x74, 0x63, 0x68, 0x32, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, - 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x76, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, - 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, - 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x75, - 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, - 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, - 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, - 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x21, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x13, 0x12, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, - 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x7b, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, - 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, - 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, - 0x18, 0x04, 0x30, 0x03, 0x38, 0x16, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x22, - 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x73, 0x12, 0x78, 0x0a, 0x0e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, - 0x69, 0x64, 0x65, 0x72, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x21, 0xaa, 0xf8, 0x18, 0x04, 0x30, - 0x03, 0x38, 0x18, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x13, 0x2a, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x89, 0x01, 0x0a, - 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x42, - 0x79, 0x49, 0x44, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x42, 0x79, - 0x49, 0x44, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, - 0x69, 0x64, 0x65, 0x72, 0x42, 0x79, 0x49, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, - 0x2a, 0x16, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x8e, 0x01, 0x0a, 0x15, 0x47, 0x65, 0x74, - 0x55, 0x6e, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x73, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, - 0x65, 0x74, 0x55, 0x6e, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, - 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x6e, 0x63, 0x6c, 0x61, - 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x79, 0x2f, - 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x8e, 0x01, 0x0a, 0x13, 0x4c, 0x69, - 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, - 0x73, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, - 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x28, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, - 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x12, 0xae, 0x01, 0x0a, 0x1b, 0x52, - 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, - 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x2e, 0x6d, 0x69, 0x6e, + 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0xaa, + 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x3a, 0x05, 0x70, + 0x61, 0x74, 0x63, 0x68, 0x32, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x76, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x50, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, + 0x75, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, + 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, + 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x21, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x13, 0x12, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x7b, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, + 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x16, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, + 0x22, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, + 0x65, 0x72, 0x73, 0x12, 0x78, 0x0a, 0x0e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, + 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x21, 0xaa, 0xf8, 0x18, 0x04, + 0x30, 0x03, 0x38, 0x18, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x13, 0x2a, 0x11, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x89, 0x01, + 0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, + 0x42, 0x79, 0x49, 0x44, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x42, + 0x79, 0x49, 0x44, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x72, 0x42, 0x79, 0x49, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x18, 0x2a, 0x16, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x72, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x8e, 0x01, 0x0a, 0x15, 0x47, 0x65, + 0x74, 0x55, 0x6e, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, + 0x65, 0x72, 0x73, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x47, 0x65, 0x74, 0x55, 0x6e, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x6e, 0x63, 0x6c, + 0x61, 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x79, + 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x8e, 0x01, 0x0a, 0x13, 0x4c, + 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, + 0x65, 0x73, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, + 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, + 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, + 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x28, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x12, 0xae, 0x01, 0x0a, 0x1b, + 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, + 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, + 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x45, - 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0xaa, 0xf8, 0x18, 0x04, 0x30, - 0x03, 0x38, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22, 0x3a, 0x01, 0x2a, 0x22, 0x1d, 0x2f, 0x61, - 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x72, - 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x6c, 0x6c, 0x32, 0x92, 0x01, 0x0a, 0x0d, - 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x80, 0x01, - 0x0a, 0x10, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, - 0x6c, 0x73, 0x12, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, - 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, - 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, 0x18, - 0x02, 0x30, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x2f, 0x7b, 0x63, 0x6f, 0x64, 0x65, 0x7d, - 0x3a, 0x3a, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, - 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, - 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xcd, 0xcb, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x3a, 0x58, 0x0a, 0x0b, - 0x72, 0x70, 0x63, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1e, 0x2e, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, - 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x85, 0x8f, 0x03, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x52, 0x70, 0x63, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x0a, 0x72, 0x70, 0x63, 0x4f, - 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, 0x3a, 0x5a, 0x38, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, - 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x6c, 0x6f, 0x6b, 0x2f, 0x6d, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2f, - 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0xaa, 0xf8, 0x18, 0x04, + 0x30, 0x03, 0x38, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22, 0x3a, 0x01, 0x2a, 0x22, 0x1d, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, + 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x6c, 0x6c, 0x32, 0x92, 0x01, 0x0a, + 0x0d, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x80, + 0x01, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x12, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x47, 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, + 0x18, 0x02, 0x30, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x2f, 0x7b, 0x63, 0x6f, 0x64, 0x65, + 0x7d, 0x3a, 0x3a, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xcd, 0xcb, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x3a, 0x58, 0x0a, + 0x0b, 0x72, 0x70, 0x63, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1e, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, + 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x85, 0x8f, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x52, 0x70, 0x63, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x0a, 0x72, 0x70, 0x63, + 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, 0x3a, 0x5a, 0x38, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x6c, 0x6f, 0x6b, 0x2f, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -15354,40 +15359,40 @@ var file_minder_v1_minder_proto_goTypes = []any{ (*ListEvaluationHistoryRequest)(nil), // 170: minder.v1.ListEvaluationHistoryRequest (*ListEvaluationHistoryResponse)(nil), // 171: minder.v1.ListEvaluationHistoryResponse (*EvaluationHistory)(nil), // 172: minder.v1.EvaluationHistory - (*PrDependencies_ContextualDependency)(nil), // 173: minder.v1.PrDependencies.ContextualDependency - (*PrDependencies_ContextualDependency_FilePatch)(nil), // 174: minder.v1.PrDependencies.ContextualDependency.FilePatch - (*PrContents_File)(nil), // 175: minder.v1.PrContents.File - (*PrContents_File_Line)(nil), // 176: minder.v1.PrContents.File.Line - (*RegisterRepoResult_Status)(nil), // 177: minder.v1.RegisterRepoResult.Status - nil, // 178: minder.v1.RuleEvaluationStatus.EntityInfoEntry - nil, // 179: minder.v1.AutoRegistration.EntitiesEntry - (*ListEvaluationResultsResponse_EntityProfileEvaluationResults)(nil), // 180: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults - (*ListEvaluationResultsResponse_EntityEvaluationResults)(nil), // 181: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults - (*RestType_Fallback)(nil), // 182: minder.v1.RestType.Fallback - (*DiffType_Ecosystem)(nil), // 183: minder.v1.DiffType.Ecosystem - (*RuleType_Definition)(nil), // 184: minder.v1.RuleType.Definition - (*RuleType_Definition_Ingest)(nil), // 185: minder.v1.RuleType.Definition.Ingest - (*RuleType_Definition_Eval)(nil), // 186: minder.v1.RuleType.Definition.Eval - (*RuleType_Definition_Remediate)(nil), // 187: minder.v1.RuleType.Definition.Remediate - (*RuleType_Definition_Alert)(nil), // 188: minder.v1.RuleType.Definition.Alert - (*RuleType_Definition_Eval_JQComparison)(nil), // 189: minder.v1.RuleType.Definition.Eval.JQComparison - (*RuleType_Definition_Eval_Rego)(nil), // 190: minder.v1.RuleType.Definition.Eval.Rego - (*RuleType_Definition_Eval_Vulncheck)(nil), // 191: minder.v1.RuleType.Definition.Eval.Vulncheck - (*RuleType_Definition_Eval_Trusty)(nil), // 192: minder.v1.RuleType.Definition.Eval.Trusty - (*RuleType_Definition_Eval_Homoglyphs)(nil), // 193: minder.v1.RuleType.Definition.Eval.Homoglyphs - (*RuleType_Definition_Eval_JQComparison_Operator)(nil), // 194: minder.v1.RuleType.Definition.Eval.JQComparison.Operator - (*RuleType_Definition_Remediate_GhBranchProtectionType)(nil), // 195: minder.v1.RuleType.Definition.Remediate.GhBranchProtectionType - (*RuleType_Definition_Remediate_PullRequestRemediation)(nil), // 196: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation - (*RuleType_Definition_Remediate_PullRequestRemediation_Content)(nil), // 197: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.Content - (*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha)(nil), // 198: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.ActionsReplaceTagsWithSha - (*RuleType_Definition_Alert_AlertTypeSA)(nil), // 199: minder.v1.RuleType.Definition.Alert.AlertTypeSA - (*Profile_Rule)(nil), // 200: minder.v1.Profile.Rule - (*Profile_Selector)(nil), // 201: minder.v1.Profile.Selector - (*EvaluationHistory_Entity)(nil), // 202: minder.v1.EvaluationHistory.Entity - (*EvaluationHistory_Rule)(nil), // 203: minder.v1.EvaluationHistory.Rule - (*EvaluationHistory_Status)(nil), // 204: minder.v1.EvaluationHistory.Status - (*EvaluationHistory_Remediation)(nil), // 205: minder.v1.EvaluationHistory.Remediation - (*EvaluationHistory_Alert)(nil), // 206: minder.v1.EvaluationHistory.Alert + (*EvaluationHistoryEntity)(nil), // 173: minder.v1.EvaluationHistoryEntity + (*EvaluationHistoryRule)(nil), // 174: minder.v1.EvaluationHistoryRule + (*EvaluationHistoryStatus)(nil), // 175: minder.v1.EvaluationHistoryStatus + (*EvaluationHistoryRemediation)(nil), // 176: minder.v1.EvaluationHistoryRemediation + (*EvaluationHistoryAlert)(nil), // 177: minder.v1.EvaluationHistoryAlert + (*PrDependencies_ContextualDependency)(nil), // 178: minder.v1.PrDependencies.ContextualDependency + (*PrDependencies_ContextualDependency_FilePatch)(nil), // 179: minder.v1.PrDependencies.ContextualDependency.FilePatch + (*PrContents_File)(nil), // 180: minder.v1.PrContents.File + (*PrContents_File_Line)(nil), // 181: minder.v1.PrContents.File.Line + (*RegisterRepoResult_Status)(nil), // 182: minder.v1.RegisterRepoResult.Status + nil, // 183: minder.v1.RuleEvaluationStatus.EntityInfoEntry + nil, // 184: minder.v1.AutoRegistration.EntitiesEntry + (*ListEvaluationResultsResponse_EntityProfileEvaluationResults)(nil), // 185: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults + (*ListEvaluationResultsResponse_EntityEvaluationResults)(nil), // 186: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults + (*RestType_Fallback)(nil), // 187: minder.v1.RestType.Fallback + (*DiffType_Ecosystem)(nil), // 188: minder.v1.DiffType.Ecosystem + (*RuleType_Definition)(nil), // 189: minder.v1.RuleType.Definition + (*RuleType_Definition_Ingest)(nil), // 190: minder.v1.RuleType.Definition.Ingest + (*RuleType_Definition_Eval)(nil), // 191: minder.v1.RuleType.Definition.Eval + (*RuleType_Definition_Remediate)(nil), // 192: minder.v1.RuleType.Definition.Remediate + (*RuleType_Definition_Alert)(nil), // 193: minder.v1.RuleType.Definition.Alert + (*RuleType_Definition_Eval_JQComparison)(nil), // 194: minder.v1.RuleType.Definition.Eval.JQComparison + (*RuleType_Definition_Eval_Rego)(nil), // 195: minder.v1.RuleType.Definition.Eval.Rego + (*RuleType_Definition_Eval_Vulncheck)(nil), // 196: minder.v1.RuleType.Definition.Eval.Vulncheck + (*RuleType_Definition_Eval_Trusty)(nil), // 197: minder.v1.RuleType.Definition.Eval.Trusty + (*RuleType_Definition_Eval_Homoglyphs)(nil), // 198: minder.v1.RuleType.Definition.Eval.Homoglyphs + (*RuleType_Definition_Eval_JQComparison_Operator)(nil), // 199: minder.v1.RuleType.Definition.Eval.JQComparison.Operator + (*RuleType_Definition_Remediate_GhBranchProtectionType)(nil), // 200: minder.v1.RuleType.Definition.Remediate.GhBranchProtectionType + (*RuleType_Definition_Remediate_PullRequestRemediation)(nil), // 201: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation + (*RuleType_Definition_Remediate_PullRequestRemediation_Content)(nil), // 202: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.Content + (*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha)(nil), // 203: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.ActionsReplaceTagsWithSha + (*RuleType_Definition_Alert_AlertTypeSA)(nil), // 204: minder.v1.RuleType.Definition.Alert.AlertTypeSA + (*Profile_Rule)(nil), // 205: minder.v1.Profile.Rule + (*Profile_Selector)(nil), // 206: minder.v1.Profile.Selector (*timestamppb.Timestamp)(nil), // 207: google.protobuf.Timestamp (*structpb.Struct)(nil), // 208: google.protobuf.Struct (*fieldmaskpb.FieldMask)(nil), // 209: google.protobuf.FieldMask @@ -15414,9 +15419,9 @@ var file_minder_v1_minder_proto_depIdxs = []int32{ 94, // 16: minder.v1.PullRequest.context:type_name -> minder.v1.Context 3, // 17: minder.v1.Dependency.ecosystem:type_name -> minder.v1.DepEcosystem 21, // 18: minder.v1.PrDependencies.pr:type_name -> minder.v1.PullRequest - 173, // 19: minder.v1.PrDependencies.deps:type_name -> minder.v1.PrDependencies.ContextualDependency + 178, // 19: minder.v1.PrDependencies.deps:type_name -> minder.v1.PrDependencies.ContextualDependency 21, // 20: minder.v1.PrContents.pr:type_name -> minder.v1.PullRequest - 175, // 21: minder.v1.PrContents.files:type_name -> minder.v1.PrContents.File + 180, // 21: minder.v1.PrContents.files:type_name -> minder.v1.PrContents.File 207, // 22: minder.v1.GetInviteDetailsResponse.expires_at:type_name -> google.protobuf.Timestamp 94, // 23: minder.v1.GetAuthorizationURLRequest.context:type_name -> minder.v1.Context 208, // 24: minder.v1.GetAuthorizationURLRequest.config:type_name -> google.protobuf.Struct @@ -15432,7 +15437,7 @@ var file_minder_v1_minder_proto_depIdxs = []int32{ 36, // 34: minder.v1.RegisterRepositoryRequest.repository:type_name -> minder.v1.UpstreamRepositoryRef 94, // 35: minder.v1.RegisterRepositoryRequest.context:type_name -> minder.v1.Context 37, // 36: minder.v1.RegisterRepoResult.repository:type_name -> minder.v1.Repository - 177, // 37: minder.v1.RegisterRepoResult.status:type_name -> minder.v1.RegisterRepoResult.Status + 182, // 37: minder.v1.RegisterRepoResult.status:type_name -> minder.v1.RegisterRepoResult.Status 39, // 38: minder.v1.RegisterRepositoryResponse.result:type_name -> minder.v1.RegisterRepoResult 94, // 39: minder.v1.GetRepositoryByIdRequest.context:type_name -> minder.v1.Context 37, // 40: minder.v1.GetRepositoryByIdResponse.repository:type_name -> minder.v1.Repository @@ -15471,7 +15476,7 @@ var file_minder_v1_minder_proto_depIdxs = []int32{ 207, // 73: minder.v1.ProfileStatus.last_updated:type_name -> google.protobuf.Timestamp 207, // 74: minder.v1.EvalResultAlert.last_updated:type_name -> google.protobuf.Timestamp 207, // 75: minder.v1.RuleEvaluationStatus.last_updated:type_name -> google.protobuf.Timestamp - 178, // 76: minder.v1.RuleEvaluationStatus.entity_info:type_name -> minder.v1.RuleEvaluationStatus.EntityInfoEntry + 183, // 76: minder.v1.RuleEvaluationStatus.entity_info:type_name -> minder.v1.RuleEvaluationStatus.EntityInfoEntry 207, // 77: minder.v1.RuleEvaluationStatus.remediation_last_updated:type_name -> google.protobuf.Timestamp 79, // 78: minder.v1.RuleEvaluationStatus.alert:type_name -> minder.v1.EvalResultAlert 115, // 79: minder.v1.RuleEvaluationStatus.severity:type_name -> minder.v1.Severity @@ -15482,7 +15487,7 @@ var file_minder_v1_minder_proto_depIdxs = []int32{ 80, // 84: minder.v1.GetProfileStatusByNameResponse.rule_evaluation_status:type_name -> minder.v1.RuleEvaluationStatus 94, // 85: minder.v1.GetProfileStatusByProjectRequest.context:type_name -> minder.v1.Context 78, // 86: minder.v1.GetProfileStatusByProjectResponse.profile_status:type_name -> minder.v1.ProfileStatus - 179, // 87: minder.v1.AutoRegistration.entities:type_name -> minder.v1.AutoRegistration.EntitiesEntry + 184, // 87: minder.v1.AutoRegistration.entities:type_name -> minder.v1.AutoRegistration.EntitiesEntry 87, // 88: minder.v1.ProviderConfig.auto_registration:type_name -> minder.v1.AutoRegistration 94, // 89: minder.v1.ListRuleTypesRequest.context:type_name -> minder.v1.Context 116, // 90: minder.v1.ListRuleTypesResponse.rule_types:type_name -> minder.v1.RuleType @@ -15497,19 +15502,19 @@ var file_minder_v1_minder_proto_depIdxs = []int32{ 94, // 99: minder.v1.DeleteRuleTypeRequest.context:type_name -> minder.v1.Context 94, // 100: minder.v1.ListEvaluationResultsRequest.context:type_name -> minder.v1.Context 81, // 101: minder.v1.ListEvaluationResultsRequest.entity:type_name -> minder.v1.EntityTypedId - 181, // 102: minder.v1.ListEvaluationResultsResponse.entities:type_name -> minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults - 182, // 103: minder.v1.RestType.fallback:type_name -> minder.v1.RestType.Fallback - 183, // 104: minder.v1.DiffType.ecosystems:type_name -> minder.v1.DiffType.Ecosystem + 186, // 102: minder.v1.ListEvaluationResultsResponse.entities:type_name -> minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults + 187, // 103: minder.v1.RestType.fallback:type_name -> minder.v1.RestType.Fallback + 188, // 104: minder.v1.DiffType.ecosystems:type_name -> minder.v1.DiffType.Ecosystem 9, // 105: minder.v1.Severity.value:type_name -> minder.v1.Severity.Value 94, // 106: minder.v1.RuleType.context:type_name -> minder.v1.Context - 184, // 107: minder.v1.RuleType.def:type_name -> minder.v1.RuleType.Definition + 189, // 107: minder.v1.RuleType.def:type_name -> minder.v1.RuleType.Definition 115, // 108: minder.v1.RuleType.severity:type_name -> minder.v1.Severity 94, // 109: minder.v1.Profile.context:type_name -> minder.v1.Context - 200, // 110: minder.v1.Profile.repository:type_name -> minder.v1.Profile.Rule - 200, // 111: minder.v1.Profile.build_environment:type_name -> minder.v1.Profile.Rule - 200, // 112: minder.v1.Profile.artifact:type_name -> minder.v1.Profile.Rule - 200, // 113: minder.v1.Profile.pull_request:type_name -> minder.v1.Profile.Rule - 201, // 114: minder.v1.Profile.selection:type_name -> minder.v1.Profile.Selector + 205, // 110: minder.v1.Profile.repository:type_name -> minder.v1.Profile.Rule + 205, // 111: minder.v1.Profile.build_environment:type_name -> minder.v1.Profile.Rule + 205, // 112: minder.v1.Profile.artifact:type_name -> minder.v1.Profile.Rule + 205, // 113: minder.v1.Profile.pull_request:type_name -> minder.v1.Profile.Rule + 206, // 114: minder.v1.Profile.selection:type_name -> minder.v1.Profile.Selector 33, // 115: minder.v1.ListProjectsResponse.projects:type_name -> minder.v1.Project 94, // 116: minder.v1.CreateProjectRequest.context:type_name -> minder.v1.Context 33, // 117: minder.v1.CreateProjectResponse.project:type_name -> minder.v1.Project @@ -15571,47 +15576,47 @@ var file_minder_v1_minder_proto_depIdxs = []int32{ 11, // 173: minder.v1.ListEvaluationHistoryRequest.cursor:type_name -> minder.v1.Cursor 172, // 174: minder.v1.ListEvaluationHistoryResponse.data:type_name -> minder.v1.EvaluationHistory 12, // 175: minder.v1.ListEvaluationHistoryResponse.page:type_name -> minder.v1.CursorPage - 202, // 176: minder.v1.EvaluationHistory.entity:type_name -> minder.v1.EvaluationHistory.Entity - 203, // 177: minder.v1.EvaluationHistory.rule:type_name -> minder.v1.EvaluationHistory.Rule - 204, // 178: minder.v1.EvaluationHistory.status:type_name -> minder.v1.EvaluationHistory.Status - 206, // 179: minder.v1.EvaluationHistory.alert:type_name -> minder.v1.EvaluationHistory.Alert - 205, // 180: minder.v1.EvaluationHistory.remediation:type_name -> minder.v1.EvaluationHistory.Remediation - 22, // 181: minder.v1.PrDependencies.ContextualDependency.dep:type_name -> minder.v1.Dependency - 174, // 182: minder.v1.PrDependencies.ContextualDependency.file:type_name -> minder.v1.PrDependencies.ContextualDependency.FilePatch - 176, // 183: minder.v1.PrContents.File.patch_lines:type_name -> minder.v1.PrContents.File.Line - 86, // 184: minder.v1.AutoRegistration.EntitiesEntry.value:type_name -> minder.v1.EntityAutoRegistrationConfig - 78, // 185: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults.profile_status:type_name -> minder.v1.ProfileStatus - 80, // 186: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults.results:type_name -> minder.v1.RuleEvaluationStatus - 81, // 187: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults.entity:type_name -> minder.v1.EntityTypedId - 180, // 188: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults.profiles:type_name -> minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults - 208, // 189: minder.v1.RuleType.Definition.rule_schema:type_name -> google.protobuf.Struct - 208, // 190: minder.v1.RuleType.Definition.param_schema:type_name -> google.protobuf.Struct - 185, // 191: minder.v1.RuleType.Definition.ingest:type_name -> minder.v1.RuleType.Definition.Ingest - 186, // 192: minder.v1.RuleType.Definition.eval:type_name -> minder.v1.RuleType.Definition.Eval - 187, // 193: minder.v1.RuleType.Definition.remediate:type_name -> minder.v1.RuleType.Definition.Remediate - 188, // 194: minder.v1.RuleType.Definition.alert:type_name -> minder.v1.RuleType.Definition.Alert - 110, // 195: minder.v1.RuleType.Definition.Ingest.rest:type_name -> minder.v1.RestType - 111, // 196: minder.v1.RuleType.Definition.Ingest.builtin:type_name -> minder.v1.BuiltinType - 112, // 197: minder.v1.RuleType.Definition.Ingest.artifact:type_name -> minder.v1.ArtifactType - 113, // 198: minder.v1.RuleType.Definition.Ingest.git:type_name -> minder.v1.GitType - 114, // 199: minder.v1.RuleType.Definition.Ingest.diff:type_name -> minder.v1.DiffType - 189, // 200: minder.v1.RuleType.Definition.Eval.jq:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison - 190, // 201: minder.v1.RuleType.Definition.Eval.rego:type_name -> minder.v1.RuleType.Definition.Eval.Rego - 191, // 202: minder.v1.RuleType.Definition.Eval.vulncheck:type_name -> minder.v1.RuleType.Definition.Eval.Vulncheck - 192, // 203: minder.v1.RuleType.Definition.Eval.trusty:type_name -> minder.v1.RuleType.Definition.Eval.Trusty - 193, // 204: minder.v1.RuleType.Definition.Eval.homoglyphs:type_name -> minder.v1.RuleType.Definition.Eval.Homoglyphs - 110, // 205: minder.v1.RuleType.Definition.Remediate.rest:type_name -> minder.v1.RestType - 195, // 206: minder.v1.RuleType.Definition.Remediate.gh_branch_protection:type_name -> minder.v1.RuleType.Definition.Remediate.GhBranchProtectionType - 196, // 207: minder.v1.RuleType.Definition.Remediate.pull_request:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation - 199, // 208: minder.v1.RuleType.Definition.Alert.security_advisory:type_name -> minder.v1.RuleType.Definition.Alert.AlertTypeSA - 194, // 209: minder.v1.RuleType.Definition.Eval.JQComparison.ingested:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison.Operator - 194, // 210: minder.v1.RuleType.Definition.Eval.JQComparison.profile:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison.Operator - 197, // 211: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.contents:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.Content - 198, // 212: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.actions_replace_tags_with_sha:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.ActionsReplaceTagsWithSha - 208, // 213: minder.v1.Profile.Rule.params:type_name -> google.protobuf.Struct - 208, // 214: minder.v1.Profile.Rule.def:type_name -> google.protobuf.Struct - 4, // 215: minder.v1.EvaluationHistory.Entity.type:type_name -> minder.v1.Entity - 207, // 216: minder.v1.EvaluationHistory.Status.evaluated_at:type_name -> google.protobuf.Timestamp + 173, // 176: minder.v1.EvaluationHistory.entity:type_name -> minder.v1.EvaluationHistoryEntity + 174, // 177: minder.v1.EvaluationHistory.rule:type_name -> minder.v1.EvaluationHistoryRule + 175, // 178: minder.v1.EvaluationHistory.status:type_name -> minder.v1.EvaluationHistoryStatus + 177, // 179: minder.v1.EvaluationHistory.alert:type_name -> minder.v1.EvaluationHistoryAlert + 176, // 180: minder.v1.EvaluationHistory.remediation:type_name -> minder.v1.EvaluationHistoryRemediation + 4, // 181: minder.v1.EvaluationHistoryEntity.type:type_name -> minder.v1.Entity + 207, // 182: minder.v1.EvaluationHistoryStatus.evaluated_at:type_name -> google.protobuf.Timestamp + 22, // 183: minder.v1.PrDependencies.ContextualDependency.dep:type_name -> minder.v1.Dependency + 179, // 184: minder.v1.PrDependencies.ContextualDependency.file:type_name -> minder.v1.PrDependencies.ContextualDependency.FilePatch + 181, // 185: minder.v1.PrContents.File.patch_lines:type_name -> minder.v1.PrContents.File.Line + 86, // 186: minder.v1.AutoRegistration.EntitiesEntry.value:type_name -> minder.v1.EntityAutoRegistrationConfig + 78, // 187: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults.profile_status:type_name -> minder.v1.ProfileStatus + 80, // 188: minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults.results:type_name -> minder.v1.RuleEvaluationStatus + 81, // 189: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults.entity:type_name -> minder.v1.EntityTypedId + 185, // 190: minder.v1.ListEvaluationResultsResponse.EntityEvaluationResults.profiles:type_name -> minder.v1.ListEvaluationResultsResponse.EntityProfileEvaluationResults + 208, // 191: minder.v1.RuleType.Definition.rule_schema:type_name -> google.protobuf.Struct + 208, // 192: minder.v1.RuleType.Definition.param_schema:type_name -> google.protobuf.Struct + 190, // 193: minder.v1.RuleType.Definition.ingest:type_name -> minder.v1.RuleType.Definition.Ingest + 191, // 194: minder.v1.RuleType.Definition.eval:type_name -> minder.v1.RuleType.Definition.Eval + 192, // 195: minder.v1.RuleType.Definition.remediate:type_name -> minder.v1.RuleType.Definition.Remediate + 193, // 196: minder.v1.RuleType.Definition.alert:type_name -> minder.v1.RuleType.Definition.Alert + 110, // 197: minder.v1.RuleType.Definition.Ingest.rest:type_name -> minder.v1.RestType + 111, // 198: minder.v1.RuleType.Definition.Ingest.builtin:type_name -> minder.v1.BuiltinType + 112, // 199: minder.v1.RuleType.Definition.Ingest.artifact:type_name -> minder.v1.ArtifactType + 113, // 200: minder.v1.RuleType.Definition.Ingest.git:type_name -> minder.v1.GitType + 114, // 201: minder.v1.RuleType.Definition.Ingest.diff:type_name -> minder.v1.DiffType + 194, // 202: minder.v1.RuleType.Definition.Eval.jq:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison + 195, // 203: minder.v1.RuleType.Definition.Eval.rego:type_name -> minder.v1.RuleType.Definition.Eval.Rego + 196, // 204: minder.v1.RuleType.Definition.Eval.vulncheck:type_name -> minder.v1.RuleType.Definition.Eval.Vulncheck + 197, // 205: minder.v1.RuleType.Definition.Eval.trusty:type_name -> minder.v1.RuleType.Definition.Eval.Trusty + 198, // 206: minder.v1.RuleType.Definition.Eval.homoglyphs:type_name -> minder.v1.RuleType.Definition.Eval.Homoglyphs + 110, // 207: minder.v1.RuleType.Definition.Remediate.rest:type_name -> minder.v1.RestType + 200, // 208: minder.v1.RuleType.Definition.Remediate.gh_branch_protection:type_name -> minder.v1.RuleType.Definition.Remediate.GhBranchProtectionType + 201, // 209: minder.v1.RuleType.Definition.Remediate.pull_request:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation + 204, // 210: minder.v1.RuleType.Definition.Alert.security_advisory:type_name -> minder.v1.RuleType.Definition.Alert.AlertTypeSA + 199, // 211: minder.v1.RuleType.Definition.Eval.JQComparison.ingested:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison.Operator + 199, // 212: minder.v1.RuleType.Definition.Eval.JQComparison.profile:type_name -> minder.v1.RuleType.Definition.Eval.JQComparison.Operator + 202, // 213: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.contents:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.Content + 203, // 214: minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.actions_replace_tags_with_sha:type_name -> minder.v1.RuleType.Definition.Remediate.PullRequestRemediation.ActionsReplaceTagsWithSha + 208, // 215: minder.v1.Profile.Rule.params:type_name -> google.protobuf.Struct + 208, // 216: minder.v1.Profile.Rule.def:type_name -> google.protobuf.Struct 210, // 217: minder.v1.name:extendee -> google.protobuf.EnumValueOptions 211, // 218: minder.v1.rpc_options:extendee -> google.protobuf.MethodOptions 10, // 219: minder.v1.rpc_options:type_name -> minder.v1.RpcOptions @@ -17701,7 +17706,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[163].Exporter = func(v any, i int) any { - switch v := v.(*PrDependencies_ContextualDependency); i { + switch v := v.(*EvaluationHistoryEntity); i { case 0: return &v.state case 1: @@ -17713,7 +17718,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[164].Exporter = func(v any, i int) any { - switch v := v.(*PrDependencies_ContextualDependency_FilePatch); i { + switch v := v.(*EvaluationHistoryRule); i { case 0: return &v.state case 1: @@ -17725,7 +17730,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[165].Exporter = func(v any, i int) any { - switch v := v.(*PrContents_File); i { + switch v := v.(*EvaluationHistoryStatus); i { case 0: return &v.state case 1: @@ -17737,7 +17742,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[166].Exporter = func(v any, i int) any { - switch v := v.(*PrContents_File_Line); i { + switch v := v.(*EvaluationHistoryRemediation); i { case 0: return &v.state case 1: @@ -17749,7 +17754,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[167].Exporter = func(v any, i int) any { - switch v := v.(*RegisterRepoResult_Status); i { + switch v := v.(*EvaluationHistoryAlert); i { case 0: return &v.state case 1: @@ -17760,8 +17765,8 @@ func file_minder_v1_minder_proto_init() { return nil } } - file_minder_v1_minder_proto_msgTypes[170].Exporter = func(v any, i int) any { - switch v := v.(*ListEvaluationResultsResponse_EntityProfileEvaluationResults); i { + file_minder_v1_minder_proto_msgTypes[168].Exporter = func(v any, i int) any { + switch v := v.(*PrDependencies_ContextualDependency); i { case 0: return &v.state case 1: @@ -17772,8 +17777,8 @@ func file_minder_v1_minder_proto_init() { return nil } } - file_minder_v1_minder_proto_msgTypes[171].Exporter = func(v any, i int) any { - switch v := v.(*ListEvaluationResultsResponse_EntityEvaluationResults); i { + file_minder_v1_minder_proto_msgTypes[169].Exporter = func(v any, i int) any { + switch v := v.(*PrDependencies_ContextualDependency_FilePatch); i { case 0: return &v.state case 1: @@ -17784,8 +17789,8 @@ func file_minder_v1_minder_proto_init() { return nil } } - file_minder_v1_minder_proto_msgTypes[172].Exporter = func(v any, i int) any { - switch v := v.(*RestType_Fallback); i { + file_minder_v1_minder_proto_msgTypes[170].Exporter = func(v any, i int) any { + switch v := v.(*PrContents_File); i { case 0: return &v.state case 1: @@ -17796,8 +17801,8 @@ func file_minder_v1_minder_proto_init() { return nil } } - file_minder_v1_minder_proto_msgTypes[173].Exporter = func(v any, i int) any { - switch v := v.(*DiffType_Ecosystem); i { + file_minder_v1_minder_proto_msgTypes[171].Exporter = func(v any, i int) any { + switch v := v.(*PrContents_File_Line); i { case 0: return &v.state case 1: @@ -17808,8 +17813,8 @@ func file_minder_v1_minder_proto_init() { return nil } } - file_minder_v1_minder_proto_msgTypes[174].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition); i { + file_minder_v1_minder_proto_msgTypes[172].Exporter = func(v any, i int) any { + switch v := v.(*RegisterRepoResult_Status); i { case 0: return &v.state case 1: @@ -17821,7 +17826,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[175].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Ingest); i { + switch v := v.(*ListEvaluationResultsResponse_EntityProfileEvaluationResults); i { case 0: return &v.state case 1: @@ -17833,7 +17838,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[176].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Eval); i { + switch v := v.(*ListEvaluationResultsResponse_EntityEvaluationResults); i { case 0: return &v.state case 1: @@ -17845,7 +17850,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[177].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Remediate); i { + switch v := v.(*RestType_Fallback); i { case 0: return &v.state case 1: @@ -17857,7 +17862,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[178].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Alert); i { + switch v := v.(*DiffType_Ecosystem); i { case 0: return &v.state case 1: @@ -17869,7 +17874,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[179].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Eval_JQComparison); i { + switch v := v.(*RuleType_Definition); i { case 0: return &v.state case 1: @@ -17881,7 +17886,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[180].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Eval_Rego); i { + switch v := v.(*RuleType_Definition_Ingest); i { case 0: return &v.state case 1: @@ -17893,7 +17898,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[181].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Eval_Vulncheck); i { + switch v := v.(*RuleType_Definition_Eval); i { case 0: return &v.state case 1: @@ -17905,7 +17910,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[182].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Eval_Trusty); i { + switch v := v.(*RuleType_Definition_Remediate); i { case 0: return &v.state case 1: @@ -17917,7 +17922,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[183].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Eval_Homoglyphs); i { + switch v := v.(*RuleType_Definition_Alert); i { case 0: return &v.state case 1: @@ -17929,7 +17934,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[184].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Eval_JQComparison_Operator); i { + switch v := v.(*RuleType_Definition_Eval_JQComparison); i { case 0: return &v.state case 1: @@ -17941,7 +17946,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[185].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Remediate_GhBranchProtectionType); i { + switch v := v.(*RuleType_Definition_Eval_Rego); i { case 0: return &v.state case 1: @@ -17953,7 +17958,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[186].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Remediate_PullRequestRemediation); i { + switch v := v.(*RuleType_Definition_Eval_Vulncheck); i { case 0: return &v.state case 1: @@ -17965,7 +17970,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[187].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Remediate_PullRequestRemediation_Content); i { + switch v := v.(*RuleType_Definition_Eval_Trusty); i { case 0: return &v.state case 1: @@ -17977,7 +17982,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[188].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha); i { + switch v := v.(*RuleType_Definition_Eval_Homoglyphs); i { case 0: return &v.state case 1: @@ -17989,7 +17994,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[189].Exporter = func(v any, i int) any { - switch v := v.(*RuleType_Definition_Alert_AlertTypeSA); i { + switch v := v.(*RuleType_Definition_Eval_JQComparison_Operator); i { case 0: return &v.state case 1: @@ -18001,7 +18006,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[190].Exporter = func(v any, i int) any { - switch v := v.(*Profile_Rule); i { + switch v := v.(*RuleType_Definition_Remediate_GhBranchProtectionType); i { case 0: return &v.state case 1: @@ -18013,7 +18018,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[191].Exporter = func(v any, i int) any { - switch v := v.(*Profile_Selector); i { + switch v := v.(*RuleType_Definition_Remediate_PullRequestRemediation); i { case 0: return &v.state case 1: @@ -18025,7 +18030,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[192].Exporter = func(v any, i int) any { - switch v := v.(*EvaluationHistory_Entity); i { + switch v := v.(*RuleType_Definition_Remediate_PullRequestRemediation_Content); i { case 0: return &v.state case 1: @@ -18037,7 +18042,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[193].Exporter = func(v any, i int) any { - switch v := v.(*EvaluationHistory_Rule); i { + switch v := v.(*RuleType_Definition_Remediate_PullRequestRemediation_ActionsReplaceTagsWithSha); i { case 0: return &v.state case 1: @@ -18049,7 +18054,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[194].Exporter = func(v any, i int) any { - switch v := v.(*EvaluationHistory_Status); i { + switch v := v.(*RuleType_Definition_Alert_AlertTypeSA); i { case 0: return &v.state case 1: @@ -18061,7 +18066,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[195].Exporter = func(v any, i int) any { - switch v := v.(*EvaluationHistory_Remediation); i { + switch v := v.(*Profile_Rule); i { case 0: return &v.state case 1: @@ -18073,7 +18078,7 @@ func file_minder_v1_minder_proto_init() { } } file_minder_v1_minder_proto_msgTypes[196].Exporter = func(v any, i int) any { - switch v := v.(*EvaluationHistory_Alert); i { + switch v := v.(*Profile_Selector); i { case 0: return &v.state case 1: @@ -18110,15 +18115,15 @@ func file_minder_v1_minder_proto_init() { file_minder_v1_minder_proto_msgTypes[157].OneofWrappers = []any{ (*ProviderParameter_GithubApp)(nil), } - file_minder_v1_minder_proto_msgTypes[167].OneofWrappers = []any{} - file_minder_v1_minder_proto_msgTypes[174].OneofWrappers = []any{} - file_minder_v1_minder_proto_msgTypes[175].OneofWrappers = []any{} - file_minder_v1_minder_proto_msgTypes[176].OneofWrappers = []any{} - file_minder_v1_minder_proto_msgTypes[177].OneofWrappers = []any{} - file_minder_v1_minder_proto_msgTypes[178].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[172].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[179].OneofWrappers = []any{} file_minder_v1_minder_proto_msgTypes[180].OneofWrappers = []any{} - file_minder_v1_minder_proto_msgTypes[186].OneofWrappers = []any{} - file_minder_v1_minder_proto_msgTypes[187].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[181].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[182].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[183].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[185].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[191].OneofWrappers = []any{} + file_minder_v1_minder_proto_msgTypes[192].OneofWrappers = []any{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ diff --git a/proto/minder/v1/minder.proto b/proto/minder/v1/minder.proto index 44afc73680..ca23a07d02 100644 --- a/proto/minder/v1/minder.proto +++ b/proto/minder/v1/minder.proto @@ -2563,73 +2563,73 @@ message ListEvaluationHistoryResponse { } message EvaluationHistory { - message Entity { - // id is the ID of the entity. - string id = 1; + // entity contains details of the entity which was evaluated. + EvaluationHistoryEntity entity = 1; - // type is the entity type. - minder.v1.Entity type = 2; + // rule contains details of the rule which the entity was evaluated against. + EvaluationHistoryRule rule = 2; - // name is the entity name. - string name = 3; - } + // status contains the evaluation status. + EvaluationHistoryStatus status = 3; - message Rule { - // name is the name of the rule instance. - string name = 1; + // alert contains details of the alerts for this evaluation. + EvaluationHistoryAlert alert = 4; - // type is the name of the rule type. - string type = 2; + // remediation contains details of the remediation for this evaluation. + EvaluationHistoryRemediation remediation = 5; +} - // profile is the name of the profile which contains the rule. - string profile = 3; - } +message EvaluationHistoryEntity { + // id is the ID of the entity. + string id = 1; - message Status { - // status is one of (success, error, failure, skipped) - // not using enums to mirror the behaviour of the existing API contracts. - string status = 1; + // type is the entity type. + Entity type = 2; - // details contains optional details about the evaluation. - // the structure and contents are rule type specific, and are subject to change. - string details = 2; + // name is the entity name. + string name = 3; +} - // created_at is the timestamp of creation of this evaluation - google.protobuf.Timestamp evaluated_at = 3; - } +message EvaluationHistoryRule { + // name is the name of the rule instance. + string name = 1; - message Remediation { - // status is one of (success, error, failure, skipped, not available) - // not using enums to mirror the behaviour of the existing API contracts. - string status = 1; + // type is the name of the rule type. + string type = 2; - // details contains optional details about the remediation. - // the structure and contents are remediation specific, and are subject to change. - string details = 2; - } + // profile is the name of the profile which contains the rule. + string profile = 3; +} - message Alert { - // status is one of (on, off, error, skipped, not available) - // not using enums to mirror the behaviour of the existing API contracts. - string status = 1; +message EvaluationHistoryStatus { + // status is one of (success, error, failure, skipped) + // not using enums to mirror the behaviour of the existing API contracts. + string status = 1; - // details contains optional details about the alert. - // the structure and contents are alert specific, and are subject to change. - string details = 2; - } + // details contains optional details about the evaluation. + // the structure and contents are rule type specific, and are subject to change. + string details = 2; - // entity contains details of the entity which was evaluated. - EvaluationHistory.Entity entity = 1; + // created_at is the timestamp of creation of this evaluation + google.protobuf.Timestamp evaluated_at = 3; +} - // rule contains details of the rule which the entity was evaluated against. - EvaluationHistory.Rule rule = 2; +message EvaluationHistoryRemediation { + // status is one of (success, error, failure, skipped, not available) + // not using enums to mirror the behaviour of the existing API contracts. + string status = 1; - // status contains the evaluation status. - EvaluationHistory.Status status = 3; + // details contains optional details about the remediation. + // the structure and contents are remediation specific, and are subject to change. + string details = 2; +} - // alert contains details of the alerts for this evaluation. - EvaluationHistory.Alert alert = 4; +message EvaluationHistoryAlert { + // status is one of (on, off, error, skipped, not available) + // not using enums to mirror the behaviour of the existing API contracts. + string status = 1; - // remediation contains details of the remediation for this evaluation. - EvaluationHistory.Remediation remediation = 5; + // details contains optional details about the alert. + // the structure and contents are alert specific, and are subject to change. + string details = 2; } From c9b4400363871faed282a8f827254b21798d2e8a Mon Sep 17 00:00:00 2001 From: Michelangelo Mori Date: Tue, 9 Jul 2024 14:47:22 +0200 Subject: [PATCH 12/13] Added project id as mandatory filter. --- database/query/eval_history.sql | 14 +- internal/controlplane/handlers_evalstatus.go | 53 ++++- .../controlplane/handlers_evalstatus_test.go | 197 ++++++++++++++++++ internal/db/eval_history.sql.go | 30 ++- internal/history/models.go | 59 ++++++ internal/history/models_test.go | 115 +++++++++- internal/history/service.go | 11 + internal/history/service_test.go | 26 ++- 8 files changed, 479 insertions(+), 26 deletions(-) diff --git a/database/query/eval_history.sql b/database/query/eval_history.sql index d2f777cafc..90a260bf92 100644 --- a/database/query/eval_history.sql +++ b/database/query/eval_history.sql @@ -107,11 +107,12 @@ SELECT s.id::uuid AS evaluation_id, WHEN ere.pull_request_id IS NOT NULL THEN pr.id WHEN ere.artifact_id IS NOT NULL THEN a.id END AS entity_id, - -- entity name - CASE WHEN ere.repository_id IS NOT NULL THEN r.repo_name - WHEN ere.pull_request_id IS NOT NULL THEN pr.pr_number::text - WHEN ere.artifact_id IS NOT NULL THEN a.artifact_name - END AS entity_name, + -- raw fields for entity names + r.repo_owner, + r.repo_name, + pr.pr_number, + a.artifact_name, + j.id as project_id, -- rule type, name, and profile rt.name AS rule_type, ri.name AS rule_name, @@ -135,6 +136,7 @@ SELECT s.id::uuid AS evaluation_id, LEFT JOIN artifacts a ON ere.artifact_id = a.id LEFT JOIN remediation_events re ON re.evaluation_id = s.id LEFT JOIN alert_events ae ON ae.evaluation_id = s.id + LEFT JOIN projects j ON r.project_id = j.id WHERE (sqlc.narg(next)::timestamp without time zone IS NULL OR sqlc.narg(next) > s.most_recent_evaluation) AND (sqlc.narg(prev)::timestamp without time zone IS NULL OR sqlc.narg(prev) < s.most_recent_evaluation) -- inclusion filters @@ -159,5 +161,7 @@ SELECT s.id::uuid AS evaluation_id, AND (sqlc.narg(fromts)::timestamp without time zone IS NULL OR sqlc.narg(tots)::timestamp without time zone IS NULL OR s.most_recent_evaluation BETWEEN sqlc.narg(fromts) AND sqlc.narg(tots)) + -- implicit filter by project id + AND j.id = sqlc.arg(projectId) ORDER BY s.most_recent_evaluation DESC LIMIT sqlc.arg(size)::integer; diff --git a/internal/controlplane/handlers_evalstatus.go b/internal/controlplane/handlers_evalstatus.go index 18278f3d76..787cc03480 100644 --- a/internal/controlplane/handlers_evalstatus.go +++ b/internal/controlplane/handlers_evalstatus.go @@ -79,6 +79,9 @@ func (s *Server) ListEvaluationHistory( opts = append(opts, history.WithTo(in.GetTo().AsTime())) } + // we always filter by project id + opts = append(opts, history.WithProjectIDStr(in.GetContext().GetProject())) + filter, err := history.NewListEvaluationFilter(opts...) if err != nil { return nil, status.Error(codes.InvalidArgument, "invalid filter") @@ -138,10 +141,9 @@ func fromEvaluationHistoryRow( return nil, errors.New("internal error") } entityType := dbEntityToEntity(dbEntityType) - - entityName, ok := row.EntityName.(string) - if !ok { - return nil, errors.New("internal error") + entityName, err := getEntityName(dbEntityType, row) + if err != nil { + return nil, err } var alert *minderv1.EvaluationHistoryAlert @@ -589,3 +591,46 @@ func dbEntityToEntity(dbEnt db.Entities) minderv1.Entity { return minderv1.Entity_ENTITY_UNSPECIFIED } } + +func getEntityName( + dbEnt db.Entities, + row db.ListEvaluationHistoryRow, +) (string, error) { + switch dbEnt { + case db.EntitiesPullRequest: + if !row.RepoOwner.Valid { + return "", errors.New("repo_owner is missing") + } + if !row.RepoName.Valid { + return "", errors.New("repo_name is missing") + } + if !row.PrNumber.Valid { + return "", errors.New("pr_number is missing") + } + return fmt.Sprintf("%s/%s#%d", + row.RepoOwner.String, + row.RepoName.String, + row.PrNumber.Int64, + ), nil + case db.EntitiesArtifact: + if !row.ArtifactName.Valid { + return "", errors.New("artifact_name is missing") + } + return row.ArtifactName.String, nil + case db.EntitiesRepository: + if !row.RepoOwner.Valid { + return "", errors.New("repo_owner is missing") + } + if !row.RepoName.Valid { + return "", errors.New("repo_name is missing") + } + return fmt.Sprintf("%s/%s", + row.RepoOwner.String, + row.RepoName.String, + ), nil + case db.EntitiesBuildEnvironment: + return "", errors.New("invalid entity type") + default: + return "", errors.New("invalid entity type") + } +} diff --git a/internal/controlplane/handlers_evalstatus_test.go b/internal/controlplane/handlers_evalstatus_test.go index 266cdb3fbe..ed9a4dcfb9 100644 --- a/internal/controlplane/handlers_evalstatus_test.go +++ b/internal/controlplane/handlers_evalstatus_test.go @@ -120,3 +120,200 @@ func TestBuildEvalResultAlertFromLRERow(t *testing.T) { }) } } + +func TestDBEntityToEntity(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + input db.Entities + output minderv1.Entity + }{ + { + name: "pull request", + input: db.EntitiesPullRequest, + output: minderv1.Entity_ENTITY_PULL_REQUESTS, + }, + { + name: "artifact", + input: db.EntitiesArtifact, + output: minderv1.Entity_ENTITY_ARTIFACTS, + }, + { + name: "repository", + input: db.EntitiesRepository, + output: minderv1.Entity_ENTITY_REPOSITORIES, + }, + { + name: "build environments", + input: db.EntitiesBuildEnvironment, + output: minderv1.Entity_ENTITY_BUILD_ENVIRONMENTS, + }, + { + name: "default", + input: db.Entities("whatever"), + output: minderv1.Entity_ENTITY_UNSPECIFIED, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + res := dbEntityToEntity(tt.input) + require.Equal(t, tt.output, res) + }) + } +} + +func TestGetEntityName(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + dbEnt db.Entities + row db.ListEvaluationHistoryRow + output string + err bool + }{ + { + name: "pull request", + dbEnt: db.EntitiesPullRequest, + row: db.ListEvaluationHistoryRow{ + RepoOwner: sql.NullString{ + Valid: true, + String: "stacklok", + }, + RepoName: sql.NullString{ + Valid: true, + String: "minder", + }, + PrNumber: sql.NullInt64{ + Valid: true, + Int64: 12345, + }, + }, + output: "stacklok/minder#12345", + }, + { + name: "pull request no repo owner", + dbEnt: db.EntitiesPullRequest, + row: db.ListEvaluationHistoryRow{ + RepoName: sql.NullString{ + Valid: true, + String: "minder", + }, + PrNumber: sql.NullInt64{ + Valid: true, + Int64: 12345, + }, + }, + err: true, + }, + { + name: "pull request no repo name", + dbEnt: db.EntitiesPullRequest, + row: db.ListEvaluationHistoryRow{ + RepoOwner: sql.NullString{ + Valid: true, + String: "stacklok", + }, + PrNumber: sql.NullInt64{ + Valid: true, + Int64: 12345, + }, + }, + err: true, + }, + { + name: "pull request no pr number", + dbEnt: db.EntitiesPullRequest, + row: db.ListEvaluationHistoryRow{ + RepoOwner: sql.NullString{ + Valid: true, + String: "stacklok", + }, + RepoName: sql.NullString{ + Valid: true, + String: "minder", + }, + }, + err: true, + }, + { + name: "artifact", + dbEnt: db.EntitiesArtifact, + row: db.ListEvaluationHistoryRow{ + ArtifactName: sql.NullString{ + Valid: true, + String: "artifact name", + }, + }, + output: "artifact name", + }, + { + name: "repository", + dbEnt: db.EntitiesRepository, + row: db.ListEvaluationHistoryRow{ + RepoOwner: sql.NullString{ + Valid: true, + String: "stacklok", + }, + RepoName: sql.NullString{ + Valid: true, + String: "minder", + }, + }, + output: "stacklok/minder", + }, + { + name: "repository no repo owner", + dbEnt: db.EntitiesRepository, + row: db.ListEvaluationHistoryRow{ + RepoName: sql.NullString{ + Valid: true, + String: "minder", + }, + }, + err: true, + }, + { + name: "repository no repo name", + dbEnt: db.EntitiesRepository, + row: db.ListEvaluationHistoryRow{ + RepoOwner: sql.NullString{ + Valid: true, + String: "stacklok", + }, + }, + err: true, + }, + { + name: "build environments", + dbEnt: db.EntitiesBuildEnvironment, + row: db.ListEvaluationHistoryRow{}, + err: true, + }, + { + name: "default", + dbEnt: db.Entities("whatever"), + row: db.ListEvaluationHistoryRow{}, + err: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + res, err := getEntityName(tt.dbEnt, tt.row) + + if tt.err { + require.Error(t, err) + require.Equal(t, "", res) + return + } + + require.NoError(t, err) + require.Equal(t, tt.output, res) + }) + } +} diff --git a/internal/db/eval_history.sql.go b/internal/db/eval_history.sql.go index 5e77b00911..431fd59d5b 100644 --- a/internal/db/eval_history.sql.go +++ b/internal/db/eval_history.sql.go @@ -203,11 +203,12 @@ SELECT s.id::uuid AS evaluation_id, WHEN ere.pull_request_id IS NOT NULL THEN pr.id WHEN ere.artifact_id IS NOT NULL THEN a.id END AS entity_id, - -- entity name - CASE WHEN ere.repository_id IS NOT NULL THEN r.repo_name - WHEN ere.pull_request_id IS NOT NULL THEN pr.pr_number::text - WHEN ere.artifact_id IS NOT NULL THEN a.artifact_name - END AS entity_name, + -- raw fields for entity names + r.repo_owner, + r.repo_name, + pr.pr_number, + a.artifact_name, + j.id as project_id, -- rule type, name, and profile rt.name AS rule_type, ri.name AS rule_name, @@ -231,6 +232,7 @@ SELECT s.id::uuid AS evaluation_id, LEFT JOIN artifacts a ON ere.artifact_id = a.id LEFT JOIN remediation_events re ON re.evaluation_id = s.id LEFT JOIN alert_events ae ON ae.evaluation_id = s.id + LEFT JOIN projects j ON r.project_id = j.id WHERE ($1::timestamp without time zone IS NULL OR $1 > s.most_recent_evaluation) AND ($2::timestamp without time zone IS NULL OR $2 < s.most_recent_evaluation) -- inclusion filters @@ -255,8 +257,10 @@ SELECT s.id::uuid AS evaluation_id, AND ($15::timestamp without time zone IS NULL OR $16::timestamp without time zone IS NULL OR s.most_recent_evaluation BETWEEN $15 AND $16) + -- implicit filter by project id + AND j.id = $17 ORDER BY s.most_recent_evaluation DESC - LIMIT $17::integer + LIMIT $18::integer ` type ListEvaluationHistoryParams struct { @@ -276,6 +280,7 @@ type ListEvaluationHistoryParams struct { Notstatuses []EvalStatusTypes `json:"notstatuses"` Fromts sql.NullTime `json:"fromts"` Tots sql.NullTime `json:"tots"` + Projectid uuid.UUID `json:"projectid"` Size int32 `json:"size"` } @@ -284,7 +289,11 @@ type ListEvaluationHistoryRow struct { EvaluatedAt time.Time `json:"evaluated_at"` EntityType interface{} `json:"entity_type"` EntityID interface{} `json:"entity_id"` - EntityName interface{} `json:"entity_name"` + RepoOwner sql.NullString `json:"repo_owner"` + RepoName sql.NullString `json:"repo_name"` + PrNumber sql.NullInt64 `json:"pr_number"` + ArtifactName sql.NullString `json:"artifact_name"` + ProjectID uuid.NullUUID `json:"project_id"` RuleType string `json:"rule_type"` RuleName string `json:"rule_name"` ProfileName string `json:"profile_name"` @@ -314,6 +323,7 @@ func (q *Queries) ListEvaluationHistory(ctx context.Context, arg ListEvaluationH pq.Array(arg.Notstatuses), arg.Fromts, arg.Tots, + arg.Projectid, arg.Size, ) if err != nil { @@ -328,7 +338,11 @@ func (q *Queries) ListEvaluationHistory(ctx context.Context, arg ListEvaluationH &i.EvaluatedAt, &i.EntityType, &i.EntityID, - &i.EntityName, + &i.RepoOwner, + &i.RepoName, + &i.PrNumber, + &i.ArtifactName, + &i.ProjectID, &i.RuleType, &i.RuleName, &i.ProfileName, diff --git a/internal/history/models.go b/internal/history/models.go index f7cc659f9a..052f4410c8 100644 --- a/internal/history/models.go +++ b/internal/history/models.go @@ -22,12 +22,17 @@ import ( "strings" "time" + "github.com/google/uuid" + "github.com/stacklok/minder/internal/db" ) var ( // ErrMalformedCursor represents errors in the cursor payload. ErrMalformedCursor = errors.New("malformed cursor") + // ErrInvalidProjectID is returned when project id is missing + // or malformed form the filter. + ErrInvalidProjectID = errors.New("invalid project id") // ErrInvalidTimeRange is returned the time range from-to is // either missing one end or from is greater than to. ErrInvalidTimeRange = errors.New("invalid time range") @@ -123,6 +128,15 @@ type Filter interface{} // FilterOpt is the option type used to configure filters. type FilterOpt func(Filter) error +// ProjectFilter interface should be implemented by types implementing +// a filter on project id. +type ProjectFilter interface { + // AddProjectID adds a project id for inclusion in the filter. + AddProjectID(uuid.UUID) error + // GetProjectID returns the included project id. + GetProjectID() uuid.UUID +} + // EntityTypeFilter interface should be implemented by types // implementing a filter on entity types. type EntityTypeFilter interface { @@ -219,6 +233,7 @@ type TimeRangeFilter interface { // ListEvaluationFilter is a filter to be used when listing historical // evaluations. type ListEvaluationFilter interface { + ProjectFilter EntityTypeFilter EntityNameFilter ProfileNameFilter @@ -229,6 +244,8 @@ type ListEvaluationFilter interface { } type listEvaluationFilter struct { + // Project ID to include in the selection + projectID uuid.UUID // List of entity types to include in the selection includedEntityTypes []string // List of entity types to exclude from the selection @@ -259,6 +276,17 @@ type listEvaluationFilter struct { to *time.Time } +func (filter *listEvaluationFilter) AddProjectID(projectID uuid.UUID) error { + if projectID == uuid.Nil { + return fmt.Errorf("%w: project id", ErrInvalidIdentifier) + } + filter.projectID = projectID + return nil +} +func (filter *listEvaluationFilter) GetProjectID() uuid.UUID { + return filter.projectID +} + func (filter *listEvaluationFilter) AddEntityType(entityType string) error { if strings.HasPrefix(entityType, "!") { entityType = strings.Split(entityType, "!")[1] // guaranteed to exist @@ -415,6 +443,34 @@ func (filter *listEvaluationFilter) GetTo() *time.Time { var _ Filter = (*listEvaluationFilter)(nil) var _ ListEvaluationFilter = (*listEvaluationFilter)(nil) +// WithProjectIDStr adds a project id (string) to the filter. Whether +// a null uuid is valid or not is determined on a per-endpoint basis. +func WithProjectIDStr(projectID string) FilterOpt { + return func(filter Filter) error { + uuid, err := uuid.Parse(projectID) + if err != nil { + return fmt.Errorf("%w: project id", ErrInvalidIdentifier) + } + inner, ok := filter.(ProjectFilter) + if !ok { + return fmt.Errorf("%w: wrong filter type", ErrInvalidIdentifier) + } + return inner.AddProjectID(uuid) + } +} + +// WithProjectID adds a project id (uuid) to the filter. Whether a +// null uuid is valid or not is determined on a per-endpoint basis. +func WithProjectID(projectID uuid.UUID) FilterOpt { + return func(filter Filter) error { + inner, ok := filter.(ProjectFilter) + if !ok { + return fmt.Errorf("%w: wrong filter type", ErrInvalidIdentifier) + } + return inner.AddProjectID(projectID) + } +} + // WithEntityType adds an entity type string to the filter. The entity // type is added for inclusion unless it starts with a `!` characters, // in which case it is added for exclusion. @@ -552,6 +608,9 @@ func NewListEvaluationFilter(opts ...FilterOpt) (ListEvaluationFilter, error) { // Following we check that time range based filtering is // sound. + if filter.projectID == uuid.Nil { + return nil, fmt.Errorf("%w: missing", ErrInvalidProjectID) + } if filter.to != nil && filter.from == nil { return nil, fmt.Errorf("%w: from is missing", ErrInvalidTimeRange) } diff --git a/internal/history/models_test.go b/internal/history/models_test.go index d5a810058b..ee1d1df9fc 100644 --- a/internal/history/models_test.go +++ b/internal/history/models_test.go @@ -19,6 +19,7 @@ import ( "testing" "time" + "github.com/google/uuid" "github.com/stretchr/testify/require" ) @@ -161,6 +162,7 @@ func TestListEvaluationFilter(t *testing.T) { filter: func(t *testing.T) (ListEvaluationFilter, error) { t.Helper() return NewListEvaluationFilter( + WithProjectIDStr("deadbeef-0000-0000-0000-000000000000"), WithEntityType("repository"), ) }, @@ -169,6 +171,26 @@ func TestListEvaluationFilter(t *testing.T) { require.Equal(t, []string{"repository"}, filter.IncludedEntityTypes()) }, }, + { + name: "mandatory project id", + filter: func(t *testing.T) (ListEvaluationFilter, error) { + t.Helper() + return NewListEvaluationFilter( + WithEntityType("repository"), + ) + }, + err: true, + }, + { + name: "non-empty project id", + filter: func(t *testing.T) (ListEvaluationFilter, error) { + t.Helper() + return NewListEvaluationFilter( + WithProjectID(uuid.Nil), + ) + }, + err: true, + }, { name: "bogus", filter: func(t *testing.T) (ListEvaluationFilter, error) { @@ -184,14 +206,13 @@ func TestListEvaluationFilter(t *testing.T) { filter: func(t *testing.T) (ListEvaluationFilter, error) { t.Helper() return NewListEvaluationFilter( - WithEntityType("repository"), + WithProjectIDStr("deadbeef-0000-0000-0000-000000000000"), WithFrom(now), WithTo(now), ) }, check: func(t *testing.T, filter ListEvaluationFilter) { t.Helper() - require.Equal(t, []string{"repository"}, filter.IncludedEntityTypes()) require.Equal(t, now, *filter.GetFrom()) require.Equal(t, now, *filter.GetTo()) }, @@ -201,7 +222,7 @@ func TestListEvaluationFilter(t *testing.T) { filter: func(t *testing.T) (ListEvaluationFilter, error) { t.Helper() return NewListEvaluationFilter( - WithEntityType("repository"), + WithProjectIDStr("deadbeef-0000-0000-0000-000000000000"), WithTo(now), ) }, @@ -212,7 +233,7 @@ func TestListEvaluationFilter(t *testing.T) { filter: func(t *testing.T) (ListEvaluationFilter, error) { t.Helper() return NewListEvaluationFilter( - WithEntityType("repository"), + WithProjectIDStr("deadbeef-0000-0000-0000-000000000000"), WithFrom(now), ) }, @@ -223,6 +244,7 @@ func TestListEvaluationFilter(t *testing.T) { filter: func(t *testing.T) (ListEvaluationFilter, error) { t.Helper() return NewListEvaluationFilter( + WithProjectIDStr("deadbeef-0000-0000-0000-000000000000"), WithEntityType("repository"), WithFrom(now.Add(1*time.Millisecond)), WithTo(now), @@ -324,6 +346,9 @@ func TestFilterOptions(t *testing.T) { now := time.Now() + uuidstr := "deadbeef-0000-0000-0000-000000000000" + uuidval := uuid.MustParse(uuidstr) + tests := []struct { name string option func(*testing.T) FilterOpt @@ -331,6 +356,88 @@ func TestFilterOptions(t *testing.T) { check func(*testing.T, Filter) err bool }{ + // project id + { + name: "project id string", + option: func(t *testing.T) FilterOpt { + t.Helper() + return WithProjectIDStr(uuidstr) + }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(ProjectFilter) + require.Equal(t, uuidval, f.GetProjectID()) + }, + }, + { + name: "project id uuid", + option: func(t *testing.T) FilterOpt { + t.Helper() + return WithProjectID(uuidval) + }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + check: func(t *testing.T, filter Filter) { + t.Helper() + f := filter.(ProjectFilter) + require.Equal(t, uuidval, f.GetProjectID()) + }, + }, + { + name: "project id nil", + option: func(t *testing.T) FilterOpt { + t.Helper() + return WithProjectID(uuid.Nil) + }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + err: true, + }, + { + name: "project id malformed", + option: func(t *testing.T) FilterOpt { + t.Helper() + return WithProjectIDStr("malformed") + }, + filter: func(t *testing.T) Filter { + t.Helper() + return &listEvaluationFilter{} + }, + err: true, + }, + { + name: "wrong project filter", + option: func(t *testing.T) FilterOpt { + t.Helper() + return WithProjectIDStr(uuidstr) + }, + filter: func(t *testing.T) Filter { + t.Helper() + return foo + }, + err: true, + }, + { + name: "wrong project filter", + option: func(t *testing.T) FilterOpt { + t.Helper() + return WithProjectID(uuidval) + }, + filter: func(t *testing.T) Filter { + t.Helper() + return foo + }, + err: true, + }, + // entity type { name: "entity type in filter", diff --git a/internal/history/service.go b/internal/history/service.go index f9f44edfd5..8c3982bcc3 100644 --- a/internal/history/service.go +++ b/internal/history/service.go @@ -279,6 +279,9 @@ func toSQLFilter( return nil } + if err := paramsFromProjectFilter(filter, params); err != nil { + return err + } if err := paramsFromEntityTypeFilter(filter, params); err != nil { return err } @@ -300,6 +303,14 @@ func toSQLFilter( return paramsFromTimeRangeFilter(filter, params) } +func paramsFromProjectFilter( + filter ProjectFilter, + params *db.ListEvaluationHistoryParams, +) error { + params.Projectid = filter.GetProjectID() + return nil +} + func paramsFromEntityTypeFilter( filter EntityTypeFilter, params *db.ListEvaluationHistoryParams, diff --git a/internal/history/service_test.go b/internal/history/service_test.go index 9614097556..bd575159e2 100644 --- a/internal/history/service_test.go +++ b/internal/history/service_test.go @@ -696,11 +696,27 @@ func makeHistoryRow( alert db.NullAlertStatusTypes, ) db.ListEvaluationHistoryRow { return db.ListEvaluationHistoryRow{ - EvaluationID: id, - EvaluatedAt: evaluatedAt, - EntityType: entityType, - EntityID: id, - EntityName: "repo1", + EvaluationID: id, + EvaluatedAt: evaluatedAt, + EntityType: entityType, + EntityID: id, + RepoOwner: sql.NullString{ + Valid: true, + String: "stacklok", + }, + RepoName: sql.NullString{ + Valid: true, + String: "minder", + }, + PrNumber: sql.NullInt64{ + Valid: true, + Int64: 12345, + }, + ArtifactName: sql.NullString{ + Valid: true, + String: "artifact1", + }, + // EntityName: "repo1", RuleType: "rule_type", RuleName: "rule_name", ProfileName: "profile_name", From e1c933d794484b7a7b0fb939cd46d4125eaecda0 Mon Sep 17 00:00:00 2001 From: Michelangelo Mori Date: Tue, 9 Jul 2024 18:43:05 +0200 Subject: [PATCH 13/13] Minor tweaks to protobuf messages. --- docs/docs/ref/proto.md | 6 +- internal/controlplane/handlers_evalstatus.go | 12 +- pkg/api/openapi/minder/v1/minder.swagger.json | 14 +- pkg/api/protobuf/go/minder/v1/minder.pb.go | 1565 +++++++++-------- proto/minder/v1/minder.proto | 10 +- 5 files changed, 804 insertions(+), 803 deletions(-) diff --git a/docs/docs/ref/proto.md b/docs/docs/ref/proto.md index b269f6ec09..4036771945 100644 --- a/docs/docs/ref/proto.md +++ b/docs/docs/ref/proto.md @@ -803,6 +803,7 @@ EvalResultAlert holds the alert details for a given rule evaluation | status | EvaluationHistoryStatus | | status contains the evaluation status. | | alert | EvaluationHistoryAlert | | alert contains details of the alerts for this evaluation. | | remediation | EvaluationHistoryRemediation | | remediation contains details of the remediation for this evaluation. | +| evaluated_at | google.protobuf.Timestamp | | created_at is the timestamp of creation of this evaluation | @@ -825,7 +826,7 @@ EvalResultAlert holds the alert details for a given rule evaluation | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | -| id | string | | id is the ID of the entity. | +| id | string | | id is the unique identifier of the entity. | | type | Entity | | type is the entity type. | | name | string | | name is the entity name. | @@ -851,7 +852,7 @@ EvalResultAlert holds the alert details for a given rule evaluation | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | | name | string | | name is the name of the rule instance. | -| type | string | | type is the name of the rule type. | +| rule_type | string | | type is the name of the rule type. | | profile | string | | profile is the name of the profile which contains the rule. | @@ -865,7 +866,6 @@ EvalResultAlert holds the alert details for a given rule evaluation | ----- | ---- | ----- | ----------- | | status | string | | status is one of (success, error, failure, skipped) not using enums to mirror the behaviour of the existing API contracts. | | details | string | | details contains optional details about the evaluation. the structure and contents are rule type specific, and are subject to change. | -| evaluated_at | google.protobuf.Timestamp | | created_at is the timestamp of creation of this evaluation | diff --git a/internal/controlplane/handlers_evalstatus.go b/internal/controlplane/handlers_evalstatus.go index 787cc03480..e932c64549 100644 --- a/internal/controlplane/handlers_evalstatus.go +++ b/internal/controlplane/handlers_evalstatus.go @@ -162,20 +162,20 @@ func fromEvaluationHistoryRow( } res = append(res, &minderv1.EvaluationHistory{ + EvaluatedAt: timestamppb.New(row.EvaluatedAt), Entity: &minderv1.EvaluationHistoryEntity{ Id: row.EvaluationID.String(), Type: entityType, Name: entityName, }, Rule: &minderv1.EvaluationHistoryRule{ - Name: row.RuleName, - Type: row.RuleType, - Profile: row.ProfileName, + Name: row.RuleName, + RuleType: row.RuleType, + Profile: row.ProfileName, }, Status: &minderv1.EvaluationHistoryStatus{ - Status: string(row.EvaluationStatus), - Details: row.EvaluationDetails, - EvaluatedAt: timestamppb.New(row.EvaluatedAt), + Status: string(row.EvaluationStatus), + Details: row.EvaluationDetails, }, Alert: alert, Remediation: remediation, diff --git a/pkg/api/openapi/minder/v1/minder.swagger.json b/pkg/api/openapi/minder/v1/minder.swagger.json index c0fdecfbb9..5fadb407f3 100644 --- a/pkg/api/openapi/minder/v1/minder.swagger.json +++ b/pkg/api/openapi/minder/v1/minder.swagger.json @@ -3637,6 +3637,11 @@ "remediation": { "$ref": "#/definitions/v1EvaluationHistoryRemediation", "description": "remediation contains details of the remediation for this evaluation." + }, + "evaluatedAt": { + "type": "string", + "format": "date-time", + "title": "created_at is the timestamp of creation of this evaluation" } } }, @@ -3658,7 +3663,7 @@ "properties": { "id": { "type": "string", - "description": "id is the ID of the entity." + "description": "id is the unique identifier of the entity." }, "type": { "$ref": "#/definitions/v1Entity", @@ -3690,7 +3695,7 @@ "type": "string", "description": "name is the name of the rule instance." }, - "type": { + "ruleType": { "type": "string", "description": "type is the name of the rule type." }, @@ -3710,11 +3715,6 @@ "details": { "type": "string", "description": "details contains optional details about the evaluation.\nthe structure and contents are rule type specific, and are subject to change." - }, - "evaluatedAt": { - "type": "string", - "format": "date-time", - "title": "created_at is the timestamp of creation of this evaluation" } } }, diff --git a/pkg/api/protobuf/go/minder/v1/minder.pb.go b/pkg/api/protobuf/go/minder/v1/minder.pb.go index e53749f9b9..24f34c0177 100644 --- a/pkg/api/protobuf/go/minder/v1/minder.pb.go +++ b/pkg/api/protobuf/go/minder/v1/minder.pb.go @@ -10676,6 +10676,8 @@ type EvaluationHistory struct { Alert *EvaluationHistoryAlert `protobuf:"bytes,4,opt,name=alert,proto3" json:"alert,omitempty"` // remediation contains details of the remediation for this evaluation. Remediation *EvaluationHistoryRemediation `protobuf:"bytes,5,opt,name=remediation,proto3" json:"remediation,omitempty"` + // created_at is the timestamp of creation of this evaluation + EvaluatedAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=evaluated_at,json=evaluatedAt,proto3" json:"evaluated_at,omitempty"` } func (x *EvaluationHistory) Reset() { @@ -10745,12 +10747,19 @@ func (x *EvaluationHistory) GetRemediation() *EvaluationHistoryRemediation { return nil } +func (x *EvaluationHistory) GetEvaluatedAt() *timestamppb.Timestamp { + if x != nil { + return x.EvaluatedAt + } + return nil +} + type EvaluationHistoryEntity struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // id is the ID of the entity. + // id is the unique identifier of the entity. Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // type is the entity type. Type Entity `protobuf:"varint,2,opt,name=type,proto3,enum=minder.v1.Entity" json:"type,omitempty"` @@ -10819,7 +10828,7 @@ type EvaluationHistoryRule struct { // name is the name of the rule instance. Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // type is the name of the rule type. - Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"` + RuleType string `protobuf:"bytes,2,opt,name=rule_type,json=ruleType,proto3" json:"rule_type,omitempty"` // profile is the name of the profile which contains the rule. Profile string `protobuf:"bytes,3,opt,name=profile,proto3" json:"profile,omitempty"` } @@ -10863,9 +10872,9 @@ func (x *EvaluationHistoryRule) GetName() string { return "" } -func (x *EvaluationHistoryRule) GetType() string { +func (x *EvaluationHistoryRule) GetRuleType() string { if x != nil { - return x.Type + return x.RuleType } return "" } @@ -10888,8 +10897,6 @@ type EvaluationHistoryStatus struct { // details contains optional details about the evaluation. // the structure and contents are rule type specific, and are subject to change. Details string `protobuf:"bytes,2,opt,name=details,proto3" json:"details,omitempty"` - // created_at is the timestamp of creation of this evaluation - EvaluatedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=evaluated_at,json=evaluatedAt,proto3" json:"evaluated_at,omitempty"` } func (x *EvaluationHistoryStatus) Reset() { @@ -10938,13 +10945,6 @@ func (x *EvaluationHistoryStatus) GetDetails() string { return "" } -func (x *EvaluationHistoryStatus) GetEvaluatedAt() *timestamppb.Timestamp { - if x != nil { - return x.EvaluatedAt - } - return nil -} - type EvaluationHistoryRemediation struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -14371,8 +14371,8 @@ var file_minder_v1_minder_proto_rawDesc = []byte{ 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x29, 0x0a, 0x04, 0x70, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x75, - 0x72, 0x73, 0x6f, 0x72, 0x50, 0x61, 0x67, 0x65, 0x52, 0x04, 0x70, 0x61, 0x67, 0x65, 0x22, 0xc5, - 0x02, 0x0a, 0x11, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, + 0x72, 0x73, 0x6f, 0x72, 0x50, 0x61, 0x67, 0x65, 0x52, 0x04, 0x70, 0x61, 0x67, 0x65, 0x22, 0x84, + 0x03, 0x0a, 0x11, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x3a, 0x0a, 0x06, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, @@ -14392,783 +14392,784 @@ var file_minder_v1_minder_proto_rawDesc = []byte{ 0x32, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x72, 0x65, 0x6d, 0x65, 0x64, - 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x64, 0x0a, 0x17, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x45, 0x6e, 0x74, 0x69, 0x74, - 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, - 0x64, 0x12, 0x25, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, - 0x11, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x74, 0x69, - 0x74, 0x79, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x59, 0x0a, 0x15, + 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3d, 0x0a, 0x0c, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, + 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, + 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, + 0x74, 0x65, 0x64, 0x41, 0x74, 0x22, 0x64, 0x0a, 0x17, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, + 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, + 0x12, 0x25, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x11, + 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x62, 0x0a, 0x15, 0x45, + 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, + 0x52, 0x75, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x75, 0x6c, 0x65, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x72, 0x75, 0x6c, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x22, + 0x4b, 0x0a, 0x17, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, + 0x74, 0x6f, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x50, 0x0a, 0x1c, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, - 0x79, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, - 0x07, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, - 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x22, 0x8a, 0x01, 0x0a, 0x17, 0x45, 0x76, 0x61, 0x6c, - 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x53, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x64, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, - 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x3d, 0x0a, 0x0c, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, - 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, - 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, - 0x65, 0x64, 0x41, 0x74, 0x22, 0x50, 0x0a, 0x1c, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, - 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x4a, 0x0a, 0x16, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x41, 0x6c, 0x65, 0x72, 0x74, - 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, - 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, - 0x6c, 0x73, 0x2a, 0x62, 0x0a, 0x0b, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4f, 0x77, 0x6e, 0x65, - 0x72, 0x12, 0x1c, 0x0a, 0x18, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, - 0x52, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, - 0x18, 0x0a, 0x14, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, 0x52, 0x5f, - 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x10, 0x02, 0x12, 0x15, 0x0a, 0x11, 0x4f, 0x42, 0x4a, - 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, 0x52, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x10, 0x03, - 0x22, 0x04, 0x08, 0x01, 0x10, 0x01, 0x2a, 0x95, 0x0e, 0x0a, 0x08, 0x52, 0x65, 0x6c, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, - 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1f, 0x0a, - 0x0f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, - 0x10, 0x01, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x19, - 0x0a, 0x0c, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x02, - 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x67, 0x65, 0x74, 0x12, 0x1f, 0x0a, 0x0f, 0x52, 0x45, 0x4c, - 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x03, 0x1a, 0x0a, - 0xea, 0xdc, 0x14, 0x06, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0f, 0x52, 0x45, - 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x04, 0x1a, - 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, 0x52, - 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x4c, 0x49, 0x53, - 0x54, 0x10, 0x05, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6c, 0x69, - 0x73, 0x74, 0x12, 0x3b, 0x0a, 0x1d, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, - 0x4f, 0x4c, 0x45, 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x4c, - 0x49, 0x53, 0x54, 0x10, 0x06, 0x1a, 0x18, 0xea, 0xdc, 0x14, 0x14, 0x72, 0x6f, 0x6c, 0x65, 0x5f, - 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x12, - 0x3f, 0x0a, 0x1f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, - 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x41, - 0x54, 0x45, 0x10, 0x07, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, - 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, - 0x12, 0x3f, 0x0a, 0x1f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, - 0x45, 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x52, 0x45, 0x4d, - 0x4f, 0x56, 0x45, 0x10, 0x08, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, - 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x6d, 0x6f, 0x76, - 0x65, 0x12, 0x23, 0x0a, 0x11, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, - 0x50, 0x4f, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x09, 0x1a, 0x0c, 0xea, 0xdc, 0x14, 0x08, 0x72, 0x65, - 0x70, 0x6f, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, - 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x0a, - 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, - 0x65, 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, - 0x50, 0x4f, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x0b, 0x1a, 0x0f, 0xea, 0xdc, 0x14, - 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x14, - 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x44, 0x45, - 0x4c, 0x45, 0x54, 0x45, 0x10, 0x0c, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, 0x70, 0x6f, - 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x15, 0x52, 0x45, 0x4c, 0x41, 0x54, - 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x47, 0x45, 0x54, - 0x10, 0x0d, 0x1a, 0x10, 0xea, 0xdc, 0x14, 0x0c, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, - 0x5f, 0x67, 0x65, 0x74, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, - 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, - 0x10, 0x0e, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, - 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, - 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x55, 0x50, 0x44, - 0x41, 0x54, 0x45, 0x10, 0x0f, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, 0x74, 0x69, 0x66, - 0x61, 0x63, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, - 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, - 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x10, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, - 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1f, 0x0a, - 0x0f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x47, 0x45, 0x54, - 0x10, 0x11, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x70, 0x72, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x25, - 0x0a, 0x12, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x43, 0x52, - 0x45, 0x41, 0x54, 0x45, 0x10, 0x12, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x70, 0x72, 0x5f, 0x63, - 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, - 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x13, 0x1a, 0x0d, 0xea, - 0xdc, 0x14, 0x09, 0x70, 0x72, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, - 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x44, 0x45, 0x4c, 0x45, - 0x54, 0x45, 0x10, 0x14, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x70, 0x72, 0x5f, 0x64, 0x65, 0x6c, - 0x65, 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x15, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, - 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x15, 0x1a, 0x10, - 0xea, 0xdc, 0x14, 0x0c, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x67, 0x65, 0x74, - 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, - 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x16, 0x1a, 0x13, - 0xea, 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x72, 0x65, - 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, - 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, - 0x17, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, - 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, - 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x44, 0x45, 0x4c, 0x45, - 0x54, 0x45, 0x10, 0x18, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x2d, 0x0a, 0x16, 0x52, 0x45, 0x4c, - 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, - 0x47, 0x45, 0x54, 0x10, 0x19, 0x1a, 0x11, 0xea, 0xdc, 0x14, 0x0d, 0x72, 0x75, 0x6c, 0x65, 0x5f, - 0x74, 0x79, 0x70, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, - 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, - 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x1a, 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x72, 0x75, 0x6c, - 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x33, 0x0a, - 0x19, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, - 0x59, 0x50, 0x45, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x1b, 0x1a, 0x14, 0xea, 0xdc, - 0x14, 0x10, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x70, 0x64, 0x61, - 0x74, 0x65, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, - 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, - 0x1c, 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, - 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, - 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x47, 0x45, 0x54, 0x10, - 0x1d, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x67, - 0x65, 0x74, 0x12, 0x2f, 0x0a, 0x17, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, - 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x1e, 0x1a, - 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x63, 0x72, 0x65, - 0x61, 0x74, 0x65, 0x12, 0x2f, 0x0a, 0x17, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, - 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x1f, - 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x75, 0x70, - 0x64, 0x61, 0x74, 0x65, 0x12, 0x2f, 0x0a, 0x17, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, - 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, - 0x20, 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x64, - 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x37, 0x0a, 0x1b, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, - 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, - 0x5f, 0x47, 0x45, 0x54, 0x10, 0x21, 0x1a, 0x16, 0xea, 0xdc, 0x14, 0x12, 0x70, 0x72, 0x6f, 0x66, - 0x69, 0x6c, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x31, - 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x4d, 0x4f, 0x54, - 0x45, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x22, 0x1a, 0x13, 0xea, 0xdc, - 0x14, 0x0f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x67, 0x65, - 0x74, 0x12, 0x55, 0x0a, 0x2a, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x4e, - 0x54, 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x43, 0x4f, 0x4e, 0x43, 0x49, 0x4c, 0x49, 0x41, 0x54, - 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x41, 0x53, 0x4b, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, - 0x23, 0x1a, 0x25, 0xea, 0xdc, 0x14, 0x21, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x72, 0x65, - 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x61, 0x73, - 0x6b, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, - 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x43, 0x4f, - 0x4e, 0x43, 0x49, 0x4c, 0x45, 0x10, 0x24, 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x65, 0x6e, 0x74, - 0x69, 0x74, 0x79, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x12, 0x3f, 0x0a, - 0x1f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x41, - 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, - 0x10, 0x25, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, 0x73, 0x73, - 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2a, 0x82, - 0x01, 0x0a, 0x0e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x12, 0x1f, 0x0a, 0x1b, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, 0x4f, - 0x55, 0x52, 0x43, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, - 0x10, 0x00, 0x12, 0x18, 0x0a, 0x14, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, - 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x01, 0x12, 0x18, 0x0a, 0x14, - 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, - 0x55, 0x53, 0x45, 0x52, 0x10, 0x02, 0x12, 0x1b, 0x0a, 0x17, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, - 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, - 0x54, 0x10, 0x03, 0x2a, 0x72, 0x0a, 0x0c, 0x44, 0x65, 0x70, 0x45, 0x63, 0x6f, 0x73, 0x79, 0x73, - 0x74, 0x65, 0x6d, 0x12, 0x1d, 0x0a, 0x19, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, - 0x53, 0x54, 0x45, 0x4d, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, - 0x10, 0x00, 0x12, 0x15, 0x0a, 0x11, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, - 0x54, 0x45, 0x4d, 0x5f, 0x4e, 0x50, 0x4d, 0x10, 0x01, 0x12, 0x14, 0x0a, 0x10, 0x44, 0x45, 0x50, - 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x5f, 0x47, 0x4f, 0x10, 0x02, 0x12, - 0x16, 0x0a, 0x12, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, - 0x5f, 0x50, 0x59, 0x50, 0x49, 0x10, 0x03, 0x2a, 0x88, 0x01, 0x0a, 0x06, 0x45, 0x6e, 0x74, 0x69, - 0x74, 0x79, 0x12, 0x16, 0x0a, 0x12, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x55, 0x4e, 0x53, - 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x45, 0x4e, - 0x54, 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x53, 0x49, 0x54, 0x4f, 0x52, 0x49, 0x45, - 0x53, 0x10, 0x01, 0x12, 0x1d, 0x0a, 0x19, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x42, 0x55, - 0x49, 0x4c, 0x44, 0x5f, 0x45, 0x4e, 0x56, 0x49, 0x52, 0x4f, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x53, - 0x10, 0x02, 0x12, 0x14, 0x0a, 0x10, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x41, 0x52, 0x54, - 0x49, 0x46, 0x41, 0x43, 0x54, 0x53, 0x10, 0x03, 0x12, 0x18, 0x0a, 0x14, 0x45, 0x4e, 0x54, 0x49, - 0x54, 0x59, 0x5f, 0x50, 0x55, 0x4c, 0x4c, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x45, 0x53, 0x54, 0x53, - 0x10, 0x04, 0x2a, 0x97, 0x02, 0x0a, 0x0c, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, - 0x79, 0x70, 0x65, 0x12, 0x1d, 0x0a, 0x19, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, - 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, - 0x10, 0x00, 0x12, 0x24, 0x0a, 0x14, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, - 0x59, 0x50, 0x45, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x10, 0x01, 0x1a, 0x0a, 0xea, 0xdc, - 0x14, 0x06, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x12, 0x20, 0x0a, 0x12, 0x50, 0x52, 0x4f, 0x56, - 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x52, 0x45, 0x53, 0x54, 0x10, 0x02, - 0x1a, 0x08, 0xea, 0xdc, 0x14, 0x04, 0x72, 0x65, 0x73, 0x74, 0x12, 0x1e, 0x0a, 0x11, 0x50, 0x52, - 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x47, 0x49, 0x54, 0x10, - 0x03, 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x67, 0x69, 0x74, 0x12, 0x1e, 0x0a, 0x11, 0x50, 0x52, - 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4f, 0x43, 0x49, 0x10, - 0x04, 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x6f, 0x63, 0x69, 0x12, 0x2e, 0x0a, 0x19, 0x50, 0x52, - 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x52, 0x45, 0x50, 0x4f, - 0x5f, 0x4c, 0x49, 0x53, 0x54, 0x45, 0x52, 0x10, 0x05, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, - 0x65, 0x70, 0x6f, 0x2d, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x72, 0x12, 0x30, 0x0a, 0x1a, 0x50, 0x52, - 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4d, 0x41, 0x47, - 0x45, 0x5f, 0x4c, 0x49, 0x53, 0x54, 0x45, 0x52, 0x10, 0x06, 0x1a, 0x10, 0xea, 0xdc, 0x14, 0x0c, - 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2d, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x72, 0x2a, 0xd5, 0x01, 0x0a, - 0x0d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x1e, - 0x0a, 0x1a, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, - 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x25, - 0x0a, 0x15, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, - 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x10, 0x01, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x67, - 0x69, 0x74, 0x68, 0x75, 0x62, 0x12, 0x2d, 0x0a, 0x19, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, - 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x5f, 0x41, - 0x50, 0x50, 0x10, 0x02, 0x1a, 0x0e, 0xea, 0xdc, 0x14, 0x0a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, - 0x2d, 0x61, 0x70, 0x70, 0x12, 0x21, 0x0a, 0x13, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, - 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x47, 0x48, 0x43, 0x52, 0x10, 0x03, 0x1a, 0x08, 0xea, - 0xdc, 0x14, 0x04, 0x67, 0x68, 0x63, 0x72, 0x12, 0x2b, 0x0a, 0x18, 0x50, 0x52, 0x4f, 0x56, 0x49, - 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x44, 0x4f, 0x43, 0x4b, 0x45, 0x52, - 0x48, 0x55, 0x42, 0x10, 0x04, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x64, 0x6f, 0x63, 0x6b, 0x65, - 0x72, 0x68, 0x75, 0x62, 0x2a, 0xa9, 0x02, 0x0a, 0x11, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, - 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x6c, 0x6f, 0x77, 0x12, 0x22, 0x0a, 0x1e, 0x41, 0x55, - 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, - 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x25, - 0x0a, 0x17, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, - 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x01, 0x1a, 0x08, 0xea, 0xdc, 0x14, - 0x04, 0x6e, 0x6f, 0x6e, 0x65, 0x12, 0x31, 0x0a, 0x1d, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, - 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x55, 0x53, 0x45, 0x52, - 0x5f, 0x49, 0x4e, 0x50, 0x55, 0x54, 0x10, 0x02, 0x1a, 0x0e, 0xea, 0xdc, 0x14, 0x0a, 0x75, 0x73, - 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x12, 0x59, 0x0a, 0x31, 0x41, 0x55, 0x54, 0x48, - 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x4f, - 0x41, 0x55, 0x54, 0x48, 0x32, 0x5f, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, - 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x10, 0x03, 0x1a, - 0x22, 0xea, 0xdc, 0x14, 0x1e, 0x6f, 0x61, 0x75, 0x74, 0x68, 0x32, 0x5f, 0x61, 0x75, 0x74, 0x68, - 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x66, - 0x6c, 0x6f, 0x77, 0x12, 0x3b, 0x0a, 0x22, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, - 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, - 0x5f, 0x41, 0x50, 0x50, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x10, 0x04, 0x1a, 0x13, 0xea, 0xdc, 0x14, - 0x0f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x5f, 0x61, 0x70, 0x70, 0x5f, 0x66, 0x6c, 0x6f, 0x77, - 0x2a, 0xbb, 0x01, 0x0a, 0x10, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, - 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x21, 0x0a, 0x1d, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, - 0x49, 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, - 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x22, 0x0a, 0x15, 0x43, 0x52, 0x45, 0x44, - 0x45, 0x4e, 0x54, 0x49, 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x45, - 0x54, 0x10, 0x01, 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x73, 0x65, 0x74, 0x12, 0x26, 0x0a, 0x17, + 0x79, 0x52, 0x65, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x4a, + 0x0a, 0x16, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, + 0x6f, 0x72, 0x79, 0x41, 0x6c, 0x65, 0x72, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2a, 0x62, 0x0a, 0x0b, 0x4f, 0x62, + 0x6a, 0x65, 0x63, 0x74, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x12, 0x1c, 0x0a, 0x18, 0x4f, 0x42, 0x4a, + 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, 0x52, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, + 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x18, 0x0a, 0x14, 0x4f, 0x42, 0x4a, 0x45, 0x43, + 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, 0x52, 0x5f, 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x10, + 0x02, 0x12, 0x15, 0x0a, 0x11, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x57, 0x4e, 0x45, + 0x52, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x10, 0x03, 0x22, 0x04, 0x08, 0x01, 0x10, 0x01, 0x2a, 0x95, + 0x0e, 0x0a, 0x08, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x14, 0x52, + 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, + 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1f, 0x0a, 0x0f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, + 0x4e, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x01, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, + 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x0c, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x02, 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x67, 0x65, + 0x74, 0x12, 0x1f, 0x0a, 0x0f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x50, + 0x44, 0x41, 0x54, 0x45, 0x10, 0x03, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x75, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, + 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x04, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x64, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, + 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x4c, 0x49, 0x53, 0x54, 0x10, 0x05, 0x1a, 0x0d, 0xea, 0xdc, 0x14, + 0x09, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x12, 0x3b, 0x0a, 0x1d, 0x52, 0x45, + 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x41, 0x53, 0x53, 0x49, + 0x47, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x4c, 0x49, 0x53, 0x54, 0x10, 0x06, 0x1a, 0x18, 0xea, + 0xdc, 0x14, 0x14, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, + 0x6e, 0x74, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x12, 0x3f, 0x0a, 0x1f, 0x52, 0x45, 0x4c, 0x41, 0x54, + 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, + 0x45, 0x4e, 0x54, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x07, 0x1a, 0x1a, 0xea, 0xdc, + 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, + 0x74, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x3f, 0x0a, 0x1f, 0x52, 0x45, 0x4c, 0x41, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, + 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x52, 0x45, 0x4d, 0x4f, 0x56, 0x45, 0x10, 0x08, 0x1a, 0x1a, 0xea, + 0xdc, 0x14, 0x16, 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, + 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x12, 0x23, 0x0a, 0x11, 0x52, 0x45, 0x4c, + 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x09, + 0x1a, 0x0c, 0xea, 0xdc, 0x14, 0x08, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x29, + 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, + 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x0a, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, + 0x70, 0x6f, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, + 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, + 0x45, 0x10, 0x0b, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, + 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x0c, 0x1a, 0x0f, + 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, + 0x2b, 0x0a, 0x15, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, + 0x46, 0x41, 0x43, 0x54, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x0d, 0x1a, 0x10, 0xea, 0xdc, 0x14, 0x0c, + 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x31, 0x0a, 0x18, + 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, + 0x54, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x0e, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, + 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, + 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x52, 0x54, 0x49, + 0x46, 0x41, 0x43, 0x54, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x0f, 0x1a, 0x13, 0xea, + 0xdc, 0x14, 0x0f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, + 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x10, + 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x5f, 0x64, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, + 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x11, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, + 0x70, 0x72, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x25, 0x0a, 0x12, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x12, 0x1a, 0x0d, + 0xea, 0xdc, 0x14, 0x09, 0x70, 0x72, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x25, 0x0a, + 0x12, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x5f, 0x55, 0x50, 0x44, + 0x41, 0x54, 0x45, 0x10, 0x13, 0x1a, 0x0d, 0xea, 0xdc, 0x14, 0x09, 0x70, 0x72, 0x5f, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x12, 0x25, 0x0a, 0x12, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, + 0x5f, 0x50, 0x52, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x14, 0x1a, 0x0d, 0xea, 0xdc, + 0x14, 0x09, 0x70, 0x72, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x15, 0x52, + 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, + 0x5f, 0x47, 0x45, 0x54, 0x10, 0x15, 0x1a, 0x10, 0xea, 0xdc, 0x14, 0x0c, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x52, + 0x45, 0x41, 0x54, 0x45, 0x10, 0x16, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x31, 0x0a, 0x18, 0x52, + 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, + 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x17, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x70, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x31, + 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x56, 0x49, + 0x44, 0x45, 0x52, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x18, 0x1a, 0x13, 0xea, 0xdc, + 0x14, 0x0f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, + 0x65, 0x12, 0x2d, 0x0a, 0x16, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, + 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x19, 0x1a, 0x11, 0xea, + 0xdc, 0x14, 0x0d, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x67, 0x65, 0x74, + 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, + 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x1a, 0x1a, + 0x14, 0xea, 0xdc, 0x14, 0x10, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, + 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x50, 0x44, 0x41, + 0x54, 0x45, 0x10, 0x1b, 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, + 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x54, 0x59, 0x50, 0x45, + 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x1c, 0x1a, 0x14, 0xea, 0xdc, 0x14, 0x10, 0x72, + 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, + 0x29, 0x0a, 0x14, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x46, + 0x49, 0x4c, 0x45, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x1d, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x70, + 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x2f, 0x0a, 0x17, 0x52, 0x45, + 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, 0x43, + 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x1e, 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, 0x6f, + 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x2f, 0x0a, 0x17, 0x52, + 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, 0x5f, + 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x1f, 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, 0x72, + 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x2f, 0x0a, 0x17, + 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, 0x45, + 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x20, 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x70, + 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x37, 0x0a, + 0x1b, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x46, 0x49, 0x4c, + 0x45, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x47, 0x45, 0x54, 0x10, 0x21, 0x1a, 0x16, + 0xea, 0xdc, 0x14, 0x12, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x31, 0x0a, 0x18, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, + 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x4d, 0x4f, 0x54, 0x45, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x47, + 0x45, 0x54, 0x10, 0x22, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, + 0x5f, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x67, 0x65, 0x74, 0x12, 0x55, 0x0a, 0x2a, 0x52, 0x45, 0x4c, + 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x43, + 0x4f, 0x4e, 0x43, 0x49, 0x4c, 0x49, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x54, 0x41, 0x53, 0x4b, + 0x5f, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x10, 0x23, 0x1a, 0x25, 0xea, 0xdc, 0x14, 0x21, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x12, 0x33, 0x0a, 0x19, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x45, 0x4e, 0x54, + 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x43, 0x4f, 0x4e, 0x43, 0x49, 0x4c, 0x45, 0x10, 0x24, 0x1a, + 0x14, 0xea, 0xdc, 0x14, 0x10, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x72, 0x65, 0x63, 0x6f, + 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x12, 0x3f, 0x0a, 0x1f, 0x52, 0x45, 0x4c, 0x41, 0x54, 0x49, 0x4f, + 0x4e, 0x5f, 0x52, 0x4f, 0x4c, 0x45, 0x5f, 0x41, 0x53, 0x53, 0x49, 0x47, 0x4e, 0x4d, 0x45, 0x4e, + 0x54, 0x5f, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x25, 0x1a, 0x1a, 0xea, 0xdc, 0x14, 0x16, + 0x72, 0x6f, 0x6c, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x5f, + 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2a, 0x82, 0x01, 0x0a, 0x0e, 0x54, 0x61, 0x72, 0x67, 0x65, + 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x1f, 0x0a, 0x1b, 0x54, 0x41, 0x52, + 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x55, 0x4e, 0x53, + 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x18, 0x0a, 0x14, 0x54, 0x41, + 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x4e, 0x4f, + 0x4e, 0x45, 0x10, 0x01, 0x12, 0x18, 0x0a, 0x14, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, + 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x10, 0x02, 0x12, 0x1b, + 0x0a, 0x17, 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, + 0x45, 0x5f, 0x50, 0x52, 0x4f, 0x4a, 0x45, 0x43, 0x54, 0x10, 0x03, 0x2a, 0x72, 0x0a, 0x0c, 0x44, + 0x65, 0x70, 0x45, 0x63, 0x6f, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x12, 0x1d, 0x0a, 0x19, 0x44, + 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x5f, 0x55, 0x4e, 0x53, + 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x15, 0x0a, 0x11, 0x44, 0x45, + 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x5f, 0x4e, 0x50, 0x4d, 0x10, + 0x01, 0x12, 0x14, 0x0a, 0x10, 0x44, 0x45, 0x50, 0x5f, 0x45, 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, + 0x45, 0x4d, 0x5f, 0x47, 0x4f, 0x10, 0x02, 0x12, 0x16, 0x0a, 0x12, 0x44, 0x45, 0x50, 0x5f, 0x45, + 0x43, 0x4f, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x5f, 0x50, 0x59, 0x50, 0x49, 0x10, 0x03, 0x2a, + 0x88, 0x01, 0x0a, 0x06, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x16, 0x0a, 0x12, 0x45, 0x4e, + 0x54, 0x49, 0x54, 0x59, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, + 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x52, 0x45, 0x50, + 0x4f, 0x53, 0x49, 0x54, 0x4f, 0x52, 0x49, 0x45, 0x53, 0x10, 0x01, 0x12, 0x1d, 0x0a, 0x19, 0x45, + 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x42, 0x55, 0x49, 0x4c, 0x44, 0x5f, 0x45, 0x4e, 0x56, 0x49, + 0x52, 0x4f, 0x4e, 0x4d, 0x45, 0x4e, 0x54, 0x53, 0x10, 0x02, 0x12, 0x14, 0x0a, 0x10, 0x45, 0x4e, + 0x54, 0x49, 0x54, 0x59, 0x5f, 0x41, 0x52, 0x54, 0x49, 0x46, 0x41, 0x43, 0x54, 0x53, 0x10, 0x03, + 0x12, 0x18, 0x0a, 0x14, 0x45, 0x4e, 0x54, 0x49, 0x54, 0x59, 0x5f, 0x50, 0x55, 0x4c, 0x4c, 0x5f, + 0x52, 0x45, 0x51, 0x55, 0x45, 0x53, 0x54, 0x53, 0x10, 0x04, 0x2a, 0x97, 0x02, 0x0a, 0x0c, 0x50, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1d, 0x0a, 0x19, 0x50, + 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, + 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x24, 0x0a, 0x14, 0x50, 0x52, + 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x47, 0x49, 0x54, 0x48, + 0x55, 0x42, 0x10, 0x01, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x12, 0x20, 0x0a, 0x12, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, + 0x45, 0x5f, 0x52, 0x45, 0x53, 0x54, 0x10, 0x02, 0x1a, 0x08, 0xea, 0xdc, 0x14, 0x04, 0x72, 0x65, + 0x73, 0x74, 0x12, 0x1e, 0x0a, 0x11, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x47, 0x49, 0x54, 0x10, 0x03, 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x67, + 0x69, 0x74, 0x12, 0x1e, 0x0a, 0x11, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x4f, 0x43, 0x49, 0x10, 0x04, 0x1a, 0x07, 0xea, 0xdc, 0x14, 0x03, 0x6f, + 0x63, 0x69, 0x12, 0x2e, 0x0a, 0x19, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x52, 0x45, 0x50, 0x4f, 0x5f, 0x4c, 0x49, 0x53, 0x54, 0x45, 0x52, 0x10, + 0x05, 0x1a, 0x0f, 0xea, 0xdc, 0x14, 0x0b, 0x72, 0x65, 0x70, 0x6f, 0x2d, 0x6c, 0x69, 0x73, 0x74, + 0x65, 0x72, 0x12, 0x30, 0x0a, 0x1a, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4d, 0x41, 0x47, 0x45, 0x5f, 0x4c, 0x49, 0x53, 0x54, 0x45, 0x52, + 0x10, 0x06, 0x1a, 0x10, 0xea, 0xdc, 0x14, 0x0c, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2d, 0x6c, 0x69, + 0x73, 0x74, 0x65, 0x72, 0x2a, 0xd5, 0x01, 0x0a, 0x0d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x1e, 0x0a, 0x1a, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, + 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, + 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x25, 0x0a, 0x15, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, + 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x10, + 0x01, 0x1a, 0x0a, 0xea, 0xdc, 0x14, 0x06, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x12, 0x2d, 0x0a, + 0x19, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, + 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x5f, 0x41, 0x50, 0x50, 0x10, 0x02, 0x1a, 0x0e, 0xea, 0xdc, + 0x14, 0x0a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2d, 0x61, 0x70, 0x70, 0x12, 0x21, 0x0a, 0x13, + 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, 0x53, 0x5f, 0x47, + 0x48, 0x43, 0x52, 0x10, 0x03, 0x1a, 0x08, 0xea, 0xdc, 0x14, 0x04, 0x67, 0x68, 0x63, 0x72, 0x12, + 0x2b, 0x0a, 0x18, 0x50, 0x52, 0x4f, 0x56, 0x49, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4c, 0x41, 0x53, + 0x53, 0x5f, 0x44, 0x4f, 0x43, 0x4b, 0x45, 0x52, 0x48, 0x55, 0x42, 0x10, 0x04, 0x1a, 0x0d, 0xea, + 0xdc, 0x14, 0x09, 0x64, 0x6f, 0x63, 0x6b, 0x65, 0x72, 0x68, 0x75, 0x62, 0x2a, 0xa9, 0x02, 0x0a, + 0x11, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x6c, + 0x6f, 0x77, 0x12, 0x22, 0x0a, 0x1e, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, + 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, + 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x25, 0x0a, 0x17, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, + 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x4e, 0x4f, 0x4e, + 0x45, 0x10, 0x01, 0x1a, 0x08, 0xea, 0xdc, 0x14, 0x04, 0x6e, 0x6f, 0x6e, 0x65, 0x12, 0x31, 0x0a, + 0x1d, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, + 0x4c, 0x4f, 0x57, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x5f, 0x49, 0x4e, 0x50, 0x55, 0x54, 0x10, 0x02, + 0x1a, 0x0e, 0xea, 0xdc, 0x14, 0x0a, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, + 0x12, 0x59, 0x0a, 0x31, 0x41, 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, + 0x4e, 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x5f, 0x4f, 0x41, 0x55, 0x54, 0x48, 0x32, 0x5f, 0x41, 0x55, + 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x44, 0x45, + 0x5f, 0x46, 0x4c, 0x4f, 0x57, 0x10, 0x03, 0x1a, 0x22, 0xea, 0xdc, 0x14, 0x1e, 0x6f, 0x61, 0x75, + 0x74, 0x68, 0x32, 0x5f, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x66, 0x6c, 0x6f, 0x77, 0x12, 0x3b, 0x0a, 0x22, 0x41, + 0x55, 0x54, 0x48, 0x4f, 0x52, 0x49, 0x5a, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x46, 0x4c, 0x4f, + 0x57, 0x5f, 0x47, 0x49, 0x54, 0x48, 0x55, 0x42, 0x5f, 0x41, 0x50, 0x50, 0x5f, 0x46, 0x4c, 0x4f, + 0x57, 0x10, 0x04, 0x1a, 0x13, 0xea, 0xdc, 0x14, 0x0f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x5f, + 0x61, 0x70, 0x70, 0x5f, 0x66, 0x6c, 0x6f, 0x77, 0x2a, 0xbb, 0x01, 0x0a, 0x10, 0x43, 0x72, 0x65, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x21, 0x0a, + 0x1d, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, + 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, + 0x12, 0x22, 0x0a, 0x15, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, 0x41, 0x4c, 0x53, 0x5f, + 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x45, 0x54, 0x10, 0x01, 0x1a, 0x07, 0xea, 0xdc, 0x14, + 0x03, 0x73, 0x65, 0x74, 0x12, 0x26, 0x0a, 0x17, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, + 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x45, 0x54, 0x10, + 0x02, 0x1a, 0x09, 0xea, 0xdc, 0x14, 0x05, 0x75, 0x6e, 0x73, 0x65, 0x74, 0x12, 0x38, 0x0a, 0x20, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, - 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x45, 0x54, 0x10, 0x02, 0x1a, 0x09, 0xea, 0xdc, 0x14, 0x05, 0x75, - 0x6e, 0x73, 0x65, 0x74, 0x12, 0x38, 0x0a, 0x20, 0x43, 0x52, 0x45, 0x44, 0x45, 0x4e, 0x54, 0x49, - 0x41, 0x4c, 0x53, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x41, 0x50, - 0x50, 0x4c, 0x49, 0x43, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x03, 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, - 0x6e, 0x6f, 0x74, 0x5f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x7d, - 0x0a, 0x0d, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, - 0x6c, 0x0a, 0x0b, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x1d, - 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, - 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, - 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1e, 0xaa, - 0xf8, 0x18, 0x04, 0x10, 0x01, 0x30, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x10, 0x12, 0x0e, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x32, 0xbc, 0x03, - 0x0a, 0x0f, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, - 0x65, 0x12, 0x95, 0x01, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, - 0x63, 0x74, 0x73, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x4c, 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x41, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0d, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x33, 0x5a, 0x13, 0x12, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, - 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x12, 0x1c, 0x2f, 0x61, 0x70, - 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x2f, 0x7b, - 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x12, 0x7f, 0x0a, 0x0f, 0x47, 0x65, 0x74, - 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, 0x12, 0x21, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, - 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, - 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x25, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0d, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, - 0x69, 0x66, 0x61, 0x63, 0x74, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x8f, 0x01, 0x0a, 0x11, 0x47, - 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, - 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, - 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, - 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2f, 0xaa, 0xf8, 0x18, - 0x04, 0x30, 0x03, 0x38, 0x0d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x21, 0x12, 0x1f, 0x2f, 0x61, 0x70, - 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x2f, 0x6e, 0x61, - 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x32, 0xb6, 0x05, 0x0a, - 0x0c, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x86, 0x01, - 0x0a, 0x13, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x55, 0x52, 0x4c, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, - 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x12, 0x12, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, - 0x74, 0x68, 0x2f, 0x75, 0x72, 0x6c, 0x12, 0xac, 0x01, 0x0a, 0x12, 0x53, 0x74, 0x6f, 0x72, 0x65, - 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x24, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x50, - 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x53, 0x74, 0x6f, 0x72, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, - 0x65, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x49, 0xaa, 0xf8, 0x18, 0x04, - 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3b, 0x3a, 0x01, 0x2a, 0x5a, 0x17, 0x3a, - 0x01, 0x2a, 0x22, 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, - 0x2f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x1d, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, - 0x61, 0x75, 0x74, 0x68, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, - 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0xd2, 0x01, 0x0a, 0x17, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, - 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x72, 0x6f, - 0x6d, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, - 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, - 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, - 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x72, 0x6f, 0x6d, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x60, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, - 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4f, 0x5a, 0x21, 0x12, 0x1f, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x2f, - 0x7b, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x7d, 0x12, 0x2a, 0x2f, 0x61, 0x70, - 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, - 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x7b, 0x74, 0x69, 0x6d, - 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x7d, 0x88, 0x02, 0x01, 0x12, 0x98, 0x01, 0x0a, 0x18, 0x56, - 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x72, 0x65, - 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x72, - 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, - 0x12, 0x13, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, - 0x65, 0x72, 0x69, 0x66, 0x79, 0x32, 0xe9, 0x0a, 0x0a, 0x11, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x6f, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0xc7, 0x01, 0x0a, 0x12, - 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, - 0x72, 0x79, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, - 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, - 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x64, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x56, 0x3a, - 0x01, 0x2a, 0x5a, 0x20, 0x3a, 0x01, 0x2a, 0x22, 0x1b, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, - 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x72, 0x65, 0x67, 0x69, - 0x73, 0x74, 0x65, 0x72, 0x22, 0x2f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, - 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x72, 0x65, 0x67, - 0x69, 0x73, 0x74, 0x65, 0x72, 0x12, 0xf1, 0x01, 0x0a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, - 0x6d, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, - 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x34, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x6d, - 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x46, - 0x72, 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x35, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, - 0x69, 0x73, 0x74, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x6f, 0x72, 0x69, 0x65, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5e, 0xaa, 0xf8, 0x18, 0x04, 0x30, - 0x03, 0x38, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x50, 0x5a, 0x1d, 0x12, 0x1b, 0x2f, 0x61, 0x70, - 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, - 0x73, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x12, 0x2f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, - 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x2f, 0x70, - 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x7d, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x12, 0xad, 0x01, 0x0a, 0x10, 0x4c, 0x69, - 0x73, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x12, 0x22, - 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, - 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, - 0x69, 0x73, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x50, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, - 0x09, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x42, 0x5a, 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x12, - 0x28, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x6f, 0x72, 0x69, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, - 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x12, 0x95, 0x01, 0x0a, 0x11, 0x47, 0x65, - 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x12, - 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, - 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, - 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0xaa, 0xf8, 0x18, 0x04, - 0x30, 0x03, 0x38, 0x09, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12, 0x25, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x69, - 0x64, 0x2f, 0x7b, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x69, 0x64, - 0x7d, 0x12, 0xd0, 0x01, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, - 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, - 0x38, 0x09, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5c, 0x5a, 0x23, 0x12, 0x21, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x6e, - 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x12, 0x35, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, - 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, - 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, - 0x3d, 0x2a, 0x2a, 0x7d, 0x12, 0x9e, 0x01, 0x0a, 0x14, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, - 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x12, 0x26, 0x2e, + 0x45, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x41, 0x50, 0x50, 0x4c, 0x49, 0x43, 0x41, 0x42, 0x4c, 0x45, + 0x10, 0x03, 0x1a, 0x12, 0xea, 0xdc, 0x14, 0x0e, 0x6e, 0x6f, 0x74, 0x5f, 0x61, 0x70, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x32, 0x7d, 0x0a, 0x0d, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, + 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x6c, 0x0a, 0x0b, 0x43, 0x68, 0x65, 0x63, 0x6b, + 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1e, 0xaa, 0xf8, 0x18, 0x04, 0x10, 0x01, 0x30, 0x01, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x10, 0x12, 0x0e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x68, + 0x65, 0x61, 0x6c, 0x74, 0x68, 0x32, 0xbc, 0x03, 0x0a, 0x0f, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x95, 0x01, 0x0a, 0x0d, 0x4c, 0x69, + 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x12, 0x1f, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, 0x69, + 0x66, 0x61, 0x63, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x41, + 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x33, 0x5a, 0x13, + 0x12, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x73, 0x12, 0x1c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x73, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, + 0x7d, 0x12, 0x7f, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x42, 0x79, 0x49, 0x64, 0x12, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x49, 0x64, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, + 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x25, 0xaa, 0xf8, 0x18, + 0x04, 0x30, 0x03, 0x38, 0x0d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x61, 0x70, + 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, 0x2f, 0x7b, 0x69, + 0x64, 0x7d, 0x12, 0x8f, 0x01, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, + 0x63, 0x74, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, 0x69, 0x66, 0x61, 0x63, 0x74, + 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x2f, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0d, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x21, 0x12, 0x1f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x72, 0x74, + 0x69, 0x66, 0x61, 0x63, 0x74, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, + 0x3d, 0x2a, 0x2a, 0x7d, 0x32, 0xb6, 0x05, 0x0a, 0x0c, 0x4f, 0x41, 0x75, 0x74, 0x68, 0x53, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x86, 0x01, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, + 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x52, 0x4c, 0x12, 0x25, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, + 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x55, 0x52, 0x4c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0xaa, 0xf8, + 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x12, 0x10, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x75, 0x72, 0x6c, 0x12, 0xac, + 0x01, 0x0a, 0x12, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, + 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, + 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x50, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x49, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x3b, 0x3a, 0x01, 0x2a, 0x5a, 0x17, 0x3a, 0x01, 0x2a, 0x22, 0x12, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x1d, + 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x7b, 0x70, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0xd2, 0x01, + 0x0a, 0x17, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, + 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x54, + 0x6f, 0x6b, 0x65, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x60, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4f, + 0x5a, 0x21, 0x12, 0x1f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, + 0x2f, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x2f, 0x7b, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x7d, 0x12, 0x2a, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, + 0x68, 0x2f, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, + 0x65, 0x72, 0x7d, 0x2f, 0x7b, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x7d, 0x88, + 0x02, 0x01, 0x12, 0x98, 0x01, 0x0a, 0x18, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, + 0x2a, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, 0x69, + 0x66, 0x79, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x50, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, + 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x12, 0x13, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, + 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x32, 0xe9, 0x0a, + 0x0a, 0x11, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x12, 0xc7, 0x01, 0x0a, 0x12, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, + 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, + 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, + 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x64, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, + 0x0a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x56, 0x3a, 0x01, 0x2a, 0x5a, 0x20, 0x3a, 0x01, 0x2a, 0x22, + 0x1b, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x6f, 0x72, 0x79, 0x2f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x22, 0x2f, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, + 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x12, 0xf1, 0x01, + 0x0a, 0x22, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x12, 0x34, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, + 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x35, 0x2e, 0x6d, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x6d, 0x6f, 0x74, + 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x46, 0x72, 0x6f, + 0x6d, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x5e, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x50, 0x5a, 0x1d, 0x12, 0x1b, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, + 0x12, 0x2f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, + 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, + 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x74, + 0x65, 0x12, 0xad, 0x01, 0x0a, 0x10, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, + 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x12, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, + 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6d, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, + 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x50, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x09, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x42, 0x5a, + 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, + 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x12, 0x28, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, + 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x2f, 0x70, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, + 0x7d, 0x12, 0x95, 0x01, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, + 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x35, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x09, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x27, 0x12, 0x25, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x69, 0x64, 0x2f, 0x7b, 0x72, 0x65, 0x70, 0x6f, 0x73, + 0x69, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0xd0, 0x01, 0x0a, 0x13, 0x47, 0x65, + 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, + 0x65, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, + 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, + 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, + 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x6a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x09, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5c, + 0x5a, 0x23, 0x12, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, + 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x12, 0x35, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, + 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, + 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x6e, 0x61, + 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x12, 0x9e, 0x01, 0x0a, + 0x14, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, + 0x79, 0x42, 0x79, 0x49, 0x64, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, + 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, - 0x72, 0x79, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, - 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x2a, 0x25, - 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, - 0x72, 0x79, 0x2f, 0x69, 0x64, 0x2f, 0x7b, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, - 0x79, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0xd9, 0x01, 0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, - 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, - 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, - 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, - 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6e, - 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x5c, 0x5a, 0x23, 0x2a, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, - 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x6e, 0x61, 0x6d, 0x65, - 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x2a, 0x35, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x70, - 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x7d, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, - 0x7d, 0x32, 0xce, 0x04, 0x0a, 0x0b, 0x55, 0x73, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, - 0x65, 0x12, 0x68, 0x0a, 0x0a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, - 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, - 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, - 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0xaa, 0xf8, - 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x3a, 0x01, 0x2a, 0x22, 0x0c, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x12, 0x65, 0x0a, 0x0a, 0x44, - 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x0e, 0x2a, 0x0c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, - 0x65, 0x72, 0x12, 0x5c, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x12, 0x19, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, - 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x0e, 0x12, 0x0c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, - 0x12, 0x80, 0x01, 0x0a, 0x0f, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, - 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x12, 0x8c, 0x01, 0x0a, 0x11, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x49, - 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x49, 0x6e, 0x76, - 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, - 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, - 0x76, 0x65, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2c, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x20, 0x22, 0x1e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, - 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x7b, 0x63, 0x6f, 0x64, - 0x65, 0x7d, 0x32, 0xb7, 0x0e, 0x0a, 0x0e, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x65, - 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x76, 0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x2a, 0x25, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, + 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x69, 0x64, 0x2f, 0x7b, 0x72, + 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0xd9, 0x01, + 0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, + 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, + 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x42, + 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x6a, 0xaa, + 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x5c, 0x5a, 0x23, 0x2a, + 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x6f, 0x72, 0x79, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, + 0x2a, 0x7d, 0x2a, 0x35, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, + 0x7b, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x7d, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, + 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x32, 0xce, 0x04, 0x0a, 0x0b, 0x55, 0x73, + 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x68, 0x0a, 0x0a, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1d, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x11, 0x3a, 0x01, 0x2a, 0x22, 0x0c, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, + 0x73, 0x65, 0x72, 0x12, 0x65, 0x0a, 0x0a, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, + 0x72, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, + 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x0e, 0x2a, 0x0c, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x12, 0x5c, 0x0a, 0x07, 0x47, 0x65, + 0x74, 0x55, 0x73, 0x65, 0x72, 0x12, 0x19, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1a, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, + 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1a, 0xaa, 0xf8, + 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x0e, 0x12, 0x0c, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x12, 0x80, 0x01, 0x0a, 0x0f, 0x4c, 0x69, 0x73, + 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x21, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, + 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2f, + 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x8c, 0x01, 0x0a, 0x11, + 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, + 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2c, 0xaa, 0xf8, + 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x20, 0x22, 0x1e, 0x2f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x2f, 0x7b, 0x63, 0x6f, 0x64, 0x65, 0x7d, 0x32, 0xb7, 0x0e, 0x0a, 0x0e, 0x50, + 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x76, 0x0a, + 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1f, + 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x14, 0x3a, 0x01, 0x2a, 0x22, 0x0f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, + 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x76, 0x0a, 0x0d, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, + 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, + 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, - 0x03, 0x38, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x3a, 0x01, 0x2a, 0x22, 0x0f, 0x2f, 0x61, - 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x76, 0x0a, - 0x0d, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1f, - 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, - 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, - 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x14, 0x3a, 0x01, 0x2a, 0x1a, 0x0f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, - 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x7c, 0x0a, 0x0c, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, - 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, + 0x03, 0x38, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x3a, 0x01, 0x2a, 0x1a, 0x0f, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x7c, 0x0a, + 0x0c, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1e, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, + 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, + 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2b, + 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x3a, 0x05, + 0x70, 0x61, 0x74, 0x63, 0x68, 0x32, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, + 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x78, 0x0a, 0x0d, 0x44, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1f, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, + 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x2a, + 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, + 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x71, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, + 0x66, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2b, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1f, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x3a, 0x05, 0x70, 0x61, 0x74, 0x63, 0x68, 0x32, 0x14, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, - 0x69, 0x64, 0x7d, 0x12, 0x78, 0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, - 0x66, 0x69, 0x6c, 0x65, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, - 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x2a, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, - 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x71, 0x0a, - 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x1e, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, - 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, - 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, - 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x12, 0x10, - 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, - 0x12, 0x7b, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, - 0x49, 0x64, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, - 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, - 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, - 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0xa4, 0x01, - 0x0a, 0x16, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, - 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, - 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12, 0x25, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x6e, - 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x2f, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x12, 0x9e, 0x01, 0x0a, 0x19, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, - 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x50, 0x72, 0x6f, 0x6a, 0x65, - 0x63, 0x74, 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, - 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, - 0x79, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x2c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, - 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x50, 0x72, - 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x73, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x76, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6c, - 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, + 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1d, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x12, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, + 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x7b, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x50, + 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x42, 0x79, 0x49, 0x64, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, + 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, + 0x69, 0x6c, 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x12, + 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, + 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0xa4, 0x01, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, + 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, + 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, + 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x4e, + 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, + 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12, 0x25, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, + 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, + 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x9e, 0x01, 0x0a, + 0x19, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x42, 0x79, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, + 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x42, 0x79, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, + 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x76, 0x0a, + 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x1f, + 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, + 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x14, 0x12, 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x73, 0x12, 0x90, 0x01, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, + 0x79, 0x70, 0x65, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, + 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x19, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22, 0x12, 0x20, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, + 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, + 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, 0x12, 0x80, 0x01, 0x0a, 0x0f, 0x47, 0x65, 0x74, + 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x49, 0x64, 0x12, 0x21, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, + 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, + 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x19, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, + 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x7b, 0x0a, 0x0e, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x20, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1a, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x22, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, + 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x12, 0x7b, 0x0a, 0x0e, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, + 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, + 0x01, 0x2a, 0x1a, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, + 0x5f, 0x74, 0x79, 0x70, 0x65, 0x12, 0x7d, 0x0a, 0x0e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, + 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, + 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, + 0x18, 0x04, 0x30, 0x03, 0x38, 0x1c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x2a, 0x16, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x2f, + 0x7b, 0x69, 0x64, 0x7d, 0x32, 0xb0, 0x02, 0x0a, 0x12, 0x45, 0x76, 0x61, 0x6c, 0x52, 0x65, 0x73, + 0x75, 0x6c, 0x74, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x8b, 0x01, 0x0a, 0x15, + 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, + 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, + 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, + 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x12, 0x0f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, + 0x31, 0x2f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x8b, 0x01, 0x0a, 0x15, 0x4c, 0x69, + 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, + 0x6f, 0x72, 0x79, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, + 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, + 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x12, 0x0f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, + 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x32, 0x8a, 0x05, 0x0a, 0x12, 0x50, 0x65, 0x72, 0x6d, + 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x71, + 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x73, 0x12, 0x1b, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x29, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x05, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1b, 0x12, 0x19, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, + 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x72, 0x6f, 0x6c, 0x65, + 0x73, 0x12, 0x95, 0x01, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, + 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, + 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, + 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2f, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, + 0x38, 0x06, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x21, 0x12, 0x1f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, + 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x61, 0x73, + 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x78, 0x0a, 0x0a, 0x41, 0x73, 0x73, + 0x69, 0x67, 0x6e, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x07, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x1f, 0x3a, 0x01, 0x2a, 0x22, 0x1a, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, + 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x61, 0x73, 0x73, + 0x69, 0x67, 0x6e, 0x12, 0x78, 0x0a, 0x0a, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, + 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, + 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x25, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x3a, 0x01, + 0x2a, 0x22, 0x1a, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x75, 0x0a, + 0x0a, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x6f, + 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x6f, 0x6c, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, + 0x38, 0x08, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x2a, 0x1a, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, + 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x72, 0x65, + 0x6d, 0x6f, 0x76, 0x65, 0x32, 0xc5, 0x07, 0x0a, 0x0f, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x71, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, + 0x02, 0x38, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x12, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x77, 0x0a, 0x0d, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x3a, + 0x01, 0x2a, 0x22, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x73, 0x12, 0x9e, 0x01, 0x0a, 0x11, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x69, + 0x6c, 0x64, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, + 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x02, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2f, 0x7b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, + 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x63, 0x68, 0x69, + 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x12, 0x74, 0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, - 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x04, 0x30, - 0x03, 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x14, 0x12, 0x12, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x12, 0x90, 0x01, - 0x0a, 0x11, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x4e, - 0x61, 0x6d, 0x65, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x4e, 0x61, 0x6d, - 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, - 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, - 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22, 0x12, 0x20, - 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, - 0x65, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x2a, 0x2a, 0x7d, - 0x12, 0x80, 0x01, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, - 0x42, 0x79, 0x49, 0x64, 0x12, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, 0x79, 0x49, 0x64, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x42, - 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, - 0x04, 0x30, 0x03, 0x38, 0x19, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x12, 0x16, 0x2f, 0x61, 0x70, - 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x7b, - 0x69, 0x64, 0x7d, 0x12, 0x7b, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, - 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, - 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, - 0x30, 0x03, 0x38, 0x1a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x22, 0x11, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, - 0x12, 0x7b, 0x0a, 0x0e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, - 0x70, 0x65, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, - 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, - 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x1a, 0x11, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x12, 0x7d, 0x0a, - 0x0e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, - 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, - 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, - 0x6c, 0x65, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x1c, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x18, 0x2a, 0x16, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x75, - 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x32, 0xb0, 0x02, 0x0a, - 0x12, 0x45, 0x76, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x53, 0x65, 0x72, 0x76, - 0x69, 0x63, 0x65, 0x12, 0x8b, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, - 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x27, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, - 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x1f, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, - 0x12, 0x0f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, - 0x73, 0x12, 0x8b, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x27, 0x2e, 0x6d, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, - 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x45, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, - 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1f, - 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x11, 0x12, 0x0f, - 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x32, - 0x8a, 0x05, 0x0a, 0x12, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x53, - 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x71, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, - 0x6c, 0x65, 0x73, 0x12, 0x1b, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, - 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x29, - 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x05, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1b, 0x12, 0x19, - 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, - 0x6f, 0x6e, 0x73, 0x2f, 0x72, 0x6f, 0x6c, 0x65, 0x73, 0x12, 0x95, 0x01, 0x0a, 0x13, 0x4c, 0x69, - 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, - 0x73, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, - 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x6f, 0x6c, 0x65, 0x41, 0x73, 0x73, - 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x2f, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x06, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x21, - 0x12, 0x1f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, - 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, - 0x73, 0x12, 0x78, 0x0a, 0x0a, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x52, 0x6f, 0x6c, 0x65, 0x12, - 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x73, 0x73, 0x69, - 0x67, 0x6e, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, - 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, - 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0xaa, 0xf8, - 0x18, 0x04, 0x30, 0x03, 0x38, 0x07, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x3a, 0x01, 0x2a, 0x22, - 0x1a, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, - 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x12, 0x78, 0x0a, 0x0a, 0x55, - 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x25, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1f, 0x3a, 0x01, 0x2a, 0x22, 0x1a, 0x2f, 0x61, 0x70, 0x69, 0x2f, - 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x75, - 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x75, 0x0a, 0x0a, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, - 0x6f, 0x6c, 0x65, 0x12, 0x1c, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, - 0x6d, 0x6f, 0x76, 0x65, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x2a, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x08, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, - 0x2a, 0x1a, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, - 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x32, 0xc5, 0x07, 0x0a, - 0x0f, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x12, 0x71, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, - 0x12, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, - 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, - 0x74, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x02, 0x38, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x12, 0x12, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, - 0x63, 0x74, 0x73, 0x12, 0x77, 0x0a, 0x0d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, - 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, - 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x3a, 0x01, 0x2a, 0x22, 0x10, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x9e, 0x01, 0x0a, - 0x11, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, - 0x74, 0x73, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, - 0x69, 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x50, 0x72, 0x6f, - 0x6a, 0x65, 0x63, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2f, - 0x7b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, - 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x12, 0x74, 0x0a, - 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, - 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, - 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, - 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x04, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x12, 0x2a, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, - 0x63, 0x74, 0x73, 0x12, 0x77, 0x0a, 0x0d, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, - 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, - 0x03, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x3a, 0x01, 0x2a, 0x1a, 0x10, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x78, 0x0a, 0x0c, - 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1e, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, - 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, - 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x27, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x03, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x3a, 0x05, 0x70, - 0x61, 0x74, 0x63, 0x68, 0x32, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, - 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0xbb, 0x01, 0x0a, 0x1e, 0x43, 0x72, 0x65, 0x61, 0x74, - 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6e, 0x64, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, 0x69, - 0x74, 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x6d, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6e, - 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34, - 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x23, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x26, 0x3a, 0x01, - 0x2a, 0x22, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, - 0x63, 0x74, 0x73, 0x2f, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2f, 0x72, 0x65, 0x63, 0x6f, 0x6e, - 0x63, 0x69, 0x6c, 0x65, 0x32, 0xd5, 0x09, 0x0a, 0x10, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, - 0x72, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x7c, 0x0a, 0x0d, 0x50, 0x61, 0x74, - 0x63, 0x68, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, - 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x76, - 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, + 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0xaa, 0xf8, 0x18, 0x04, 0x30, + 0x03, 0x38, 0x04, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x12, 0x2a, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0x77, 0x0a, 0x0d, 0x55, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1f, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, + 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x23, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x03, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x3a, + 0x01, 0x2a, 0x1a, 0x10, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x73, 0x12, 0x78, 0x0a, 0x0c, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x27, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x03, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x3a, 0x05, 0x70, 0x61, 0x74, 0x63, 0x68, 0x32, 0x10, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x12, 0xbb, + 0x01, 0x0a, 0x1e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, + 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x73, + 0x6b, 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, + 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x63, 0x6f, + 0x6e, 0x63, 0x69, 0x6c, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x23, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x26, 0x3a, 0x01, 0x2a, 0x22, 0x21, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2f, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x2f, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x32, 0xd5, 0x09, 0x0a, + 0x10, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x12, 0x7c, 0x0a, 0x0d, 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, + 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, + 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x50, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x3a, 0x05, 0x70, 0x61, 0x74, 0x63, 0x68, 0x32, 0x11, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, + 0x76, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x1d, + 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x17, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x3a, 0x05, 0x70, - 0x61, 0x74, 0x63, 0x68, 0x32, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, - 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x76, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x50, 0x72, - 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x1d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, - 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, - 0x75, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, - 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, - 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, - 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x21, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x13, 0x12, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, - 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x7b, 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, - 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, - 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, - 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, - 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, - 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x16, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, - 0x22, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x73, 0x12, 0x78, 0x0a, 0x0e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, - 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x21, 0xaa, 0xf8, 0x18, 0x04, - 0x30, 0x03, 0x38, 0x18, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x13, 0x2a, 0x11, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x89, 0x01, - 0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, - 0x42, 0x79, 0x49, 0x44, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x42, - 0x79, 0x49, 0x44, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, - 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, - 0x76, 0x69, 0x64, 0x65, 0x72, 0x42, 0x79, 0x49, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x0c, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x18, 0x2a, 0x16, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, - 0x64, 0x65, 0x72, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x8e, 0x01, 0x0a, 0x15, 0x47, 0x65, - 0x74, 0x55, 0x6e, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x73, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x47, 0x65, 0x74, 0x55, 0x6e, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, - 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x6e, 0x63, 0x6c, - 0x61, 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x79, - 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x8e, 0x01, 0x0a, 0x13, 0x4c, - 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, - 0x65, 0x73, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, - 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, - 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, + 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, + 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x7d, 0x12, 0x75, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x50, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x1f, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x28, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, - 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x12, 0xae, 0x01, 0x0a, 0x1b, - 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, - 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x2e, 0x6d, 0x69, - 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, + 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x21, 0xaa, 0xf8, 0x18, + 0x04, 0x30, 0x03, 0x38, 0x15, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x13, 0x12, 0x11, 0x2f, 0x61, 0x70, + 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x7b, + 0x0a, 0x0e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, + 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x16, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x3a, 0x01, 0x2a, 0x22, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, + 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x78, 0x0a, 0x0e, 0x44, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x20, 0x2e, + 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x21, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, + 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x21, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x18, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x13, 0x2a, 0x11, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x89, 0x01, 0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x42, 0x79, 0x49, 0x44, 0x12, 0x24, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x42, 0x79, 0x49, 0x44, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x42, 0x79, 0x49, + 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x26, 0xaa, 0xf8, 0x18, 0x04, 0x30, + 0x03, 0x38, 0x0c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x2a, 0x16, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x2f, 0x7b, 0x69, 0x64, + 0x7d, 0x12, 0x8e, 0x01, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x55, 0x6e, 0x63, 0x6c, 0x61, 0x69, 0x6d, + 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x12, 0x27, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x6e, 0x63, 0x6c, 0x61, + 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x74, 0x55, 0x6e, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x65, 0x64, 0x50, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, + 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x02, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, 0x12, 0x14, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x79, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, + 0x72, 0x73, 0x12, 0x8e, 0x01, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6e, + 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, + 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0xaa, 0xf8, 0x18, 0x04, 0x30, + 0x03, 0x38, 0x15, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x65, 0x73, 0x12, 0xae, 0x01, 0x0a, 0x1b, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, 0x69, 0x6e, - 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, - 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0xaa, 0xf8, 0x18, 0x04, - 0x30, 0x03, 0x38, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x22, 0x3a, 0x01, 0x2a, 0x22, 0x1d, 0x2f, - 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, - 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x61, 0x6c, 0x6c, 0x32, 0x92, 0x01, 0x0a, - 0x0d, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x80, - 0x01, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, - 0x69, 0x6c, 0x73, 0x12, 0x22, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x47, 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, - 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, - 0x18, 0x02, 0x30, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x17, 0x12, 0x15, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x76, 0x31, 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x2f, 0x7b, 0x63, 0x6f, 0x64, 0x65, - 0x7d, 0x3a, 0x3a, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, - 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, - 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xcd, 0xcb, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x88, 0x01, 0x01, 0x3a, 0x58, 0x0a, - 0x0b, 0x72, 0x70, 0x63, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1e, 0x2e, 0x67, - 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, - 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x85, 0x8f, 0x03, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x52, 0x70, 0x63, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x0a, 0x72, 0x70, 0x63, - 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, 0x3a, 0x5a, 0x38, 0x67, 0x69, 0x74, 0x68, 0x75, - 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x74, 0x61, 0x63, 0x6b, 0x6c, 0x6f, 0x6b, 0x2f, 0x6d, - 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, - 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, + 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, + 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x30, 0xaa, 0xf8, 0x18, 0x04, 0x30, 0x03, 0x38, 0x24, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x22, 0x3a, 0x01, 0x2a, 0x22, 0x1d, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x70, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x2f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, + 0x5f, 0x61, 0x6c, 0x6c, 0x32, 0x92, 0x01, 0x0a, 0x0d, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x80, 0x01, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x49, 0x6e, + 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x22, 0x2e, 0x6d, 0x69, + 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x76, 0x69, 0x74, + 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x23, 0x2e, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x49, + 0x6e, 0x76, 0x69, 0x74, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0xaa, 0xf8, 0x18, 0x02, 0x30, 0x01, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x17, 0x12, 0x15, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x69, 0x6e, 0x76, 0x69, + 0x74, 0x65, 0x2f, 0x7b, 0x63, 0x6f, 0x64, 0x65, 0x7d, 0x3a, 0x3a, 0x0a, 0x04, 0x6e, 0x61, 0x6d, + 0x65, 0x12, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xcd, 0xcb, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x88, 0x01, 0x01, 0x3a, 0x58, 0x0a, 0x0b, 0x72, 0x70, 0x63, 0x5f, 0x6f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x85, 0x8f, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, + 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x70, 0x63, 0x4f, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x52, 0x0a, 0x72, 0x70, 0x63, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, + 0x3a, 0x5a, 0x38, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x74, + 0x61, 0x63, 0x6b, 0x6c, 0x6f, 0x6b, 0x2f, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2f, 0x70, 0x6b, + 0x67, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x67, + 0x6f, 0x2f, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, } var ( @@ -15581,8 +15582,8 @@ var file_minder_v1_minder_proto_depIdxs = []int32{ 175, // 178: minder.v1.EvaluationHistory.status:type_name -> minder.v1.EvaluationHistoryStatus 177, // 179: minder.v1.EvaluationHistory.alert:type_name -> minder.v1.EvaluationHistoryAlert 176, // 180: minder.v1.EvaluationHistory.remediation:type_name -> minder.v1.EvaluationHistoryRemediation - 4, // 181: minder.v1.EvaluationHistoryEntity.type:type_name -> minder.v1.Entity - 207, // 182: minder.v1.EvaluationHistoryStatus.evaluated_at:type_name -> google.protobuf.Timestamp + 207, // 181: minder.v1.EvaluationHistory.evaluated_at:type_name -> google.protobuf.Timestamp + 4, // 182: minder.v1.EvaluationHistoryEntity.type:type_name -> minder.v1.Entity 22, // 183: minder.v1.PrDependencies.ContextualDependency.dep:type_name -> minder.v1.Dependency 179, // 184: minder.v1.PrDependencies.ContextualDependency.file:type_name -> minder.v1.PrDependencies.ContextualDependency.FilePatch 181, // 185: minder.v1.PrContents.File.patch_lines:type_name -> minder.v1.PrContents.File.Line diff --git a/proto/minder/v1/minder.proto b/proto/minder/v1/minder.proto index ca23a07d02..4125ced695 100644 --- a/proto/minder/v1/minder.proto +++ b/proto/minder/v1/minder.proto @@ -2577,10 +2577,13 @@ message EvaluationHistory { // remediation contains details of the remediation for this evaluation. EvaluationHistoryRemediation remediation = 5; + + // created_at is the timestamp of creation of this evaluation + google.protobuf.Timestamp evaluated_at = 6; } message EvaluationHistoryEntity { - // id is the ID of the entity. + // id is the unique identifier of the entity. string id = 1; // type is the entity type. @@ -2595,7 +2598,7 @@ message EvaluationHistoryRule { string name = 1; // type is the name of the rule type. - string type = 2; + string rule_type = 2; // profile is the name of the profile which contains the rule. string profile = 3; @@ -2609,9 +2612,6 @@ message EvaluationHistoryStatus { // details contains optional details about the evaluation. // the structure and contents are rule type specific, and are subject to change. string details = 2; - - // created_at is the timestamp of creation of this evaluation - google.protobuf.Timestamp evaluated_at = 3; } message EvaluationHistoryRemediation {