Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
fix(api): check the create permission on allow_missing updates (T11) (#21284)
Danny Xu477d34ad321b
diff --git a/backend/api/mcp/gen/openapi.yaml b/backend/api/mcp/gen/openapi.yamlindex 812642750f..2598036d87 100644--- a/backend/api/mcp/gen/openapi.yaml+++ b/backend/api/mcp/gen/openapi.yaml@@ -21415,12 +21415,6 @@ components:title: update_maskdescription: The list of fields to update.$ref: '#/components/schemas/google.protobuf.FieldMask'- allowMissing:- type: boolean- title: allow_missing- description: |-- If set to true, and the database is not found, a new database will be created.- In this situation, `update_mask` is ignored.title: UpdateDatabaseRequestadditionalProperties: falsebytebase.v1.UpdateEmailRequest:diff --git a/backend/api/v1/acl.go b/backend/api/v1/acl.goindex cd5d22fef5..45501e27bc 100644--- a/backend/api/v1/acl.go+++ b/backend/api/v1/acl.go@@ -185,10 +185,12 @@ func (in *ACLInterceptor) doACLCheck(ctx context.Context, request any, fullMethoreturn err}- // Check allow_missing secondary permission if applicable- // This handles Update methods that can create resources via allow_missing=true- // When allow_missing is set, we additionally require create permission- if hasAllowMissingEnabled(request) {+ // An Update that creates via allow_missing=true also needs the create permission.+ // IAM only: doIAMPermissionCheck returns true for every other auth method, so+ // running this on a CUSTOM method would verify nothing while reading as+ // protection. CUSTOM handlers check for themselves, pinned by+ // TestAllowMissingCreatePermission.+ if authContext.AuthMethod == common.AuthMethodIAM && hasAllowMissingEnabled(request) {// Derive create permission by replacing ".update" with ".create"// Example: "bb.roles.update" -> "bb.roles.create"createPerm := strings.Replace(string(authContext.Permission), ".update", ".create", 1)diff --git a/backend/api/v1/acl_allow_missing_test.go b/backend/api/v1/acl_allow_missing_test.gonew file mode 100644index 0000000000..81abdb63d1--- /dev/null+++ b/backend/api/v1/acl_allow_missing_test.go@@ -0,0 +1,233 @@+package v1++import (+ "fmt"+ "slices"+ "strings"+ "testing"++ "github.com/stretchr/testify/require"+ "google.golang.org/protobuf/proto"+ "google.golang.org/protobuf/reflect/protoreflect"+ "google.golang.org/protobuf/reflect/protoregistry"+ "google.golang.org/protobuf/types/descriptorpb"++ "github.com/bytebase/bytebase/backend/common/permission"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+)++// An allow_missing Update creates the resource when it is absent, so it needs+// the create permission too. Two mechanisms supply that check, each failing+// silently:+//+// - The ACL interceptor covers IAM methods, deriving the permission by+// rewriting ".update" to ".create". That guess can leave the string+// unchanged (re-checking what was already checked) or invent one no role+// holds (denying every caller, as the dead flag on UpdateDatabaseCatalog did).+// - CUSTOM methods it does not cover at all, and a handler that forgets to+// check leaves nothing to notice — how UpdateGroup shipped an unchecked+// create path.+//+// So each allow_missing RPC is listed with what authorizes its create path.+// Gaining or losing the flag fails the build.+var allowMissingCreateChecks = map[string]allowMissingCreateCheck{+ // Interceptor-enforced: the permission the rewrite must produce. The test+ // proves it exists and differs from the declared one.+ "bytebase.v1.InstanceService.UpdateInstance": {createPermission: permission.InstancesCreate},+ "bytebase.v1.InstanceService.UpdateDataSource": {createPermission: permission.InstancesCreate},+ "bytebase.v1.RoleService.UpdateRole": {createPermission: permission.RolesCreate},+ "bytebase.v1.IssueService.UpdateIssue": {createPermission: permission.IssuesCreate},+ "bytebase.v1.IssueService.UpdateIssueComment": {createPermission: permission.IssueCommentsCreate},+ "bytebase.v1.ReviewConfigService.UpdateReviewConfig": {createPermission: permission.ReviewConfigsCreate},+ "bytebase.v1.IdentityProviderService.UpdateIdentityProvider": {createPermission: permission.IdentityProvidersCreate},+ "bytebase.v1.DatabaseGroupService.UpdateDatabaseGroup": {createPermission: permission.DatabaseGroupsCreate},+ "bytebase.v1.ProjectService.UpdateProject": {createPermission: permission.ProjectsCreate},+ "bytebase.v1.ProjectService.UpdateWebhook": {createPermission: permission.ProjectsCreate},+ // Nested: the flag rides on the sub-request, which the interceptor reads only+ // because hasAllowMissingEnabled names this type by hand. Proven, not assumed.+ "bytebase.v1.InstanceService.BatchUpdateInstances": {createPermission: permission.InstancesCreate},++ // Handler-enforced: CUSTOM auth, so the note names the call that checks.+ "bytebase.v1.OrgPolicyService.UpdatePolicy": {+ handlerCheck: "org_policy_service.go createPolicyMessage -> checkPolicyPermission(PoliciesCreate, or the MASKING_RULE/MASKING_EXEMPTION variant)",+ },+ "bytebase.v1.PlanService.UpdatePlan": {+ handlerCheck: "plan_service.go UpdatePlan checks permission.PlansCreate before delegating to CreatePlan",+ },+ "bytebase.v1.GroupService.UpdateGroup": {+ handlerCheck: "group_service.go UpdateGroup checks permission.GroupsCreate before delegating to CreateGroup",+ },+ "bytebase.v1.UserService.UpdateUser": {+ handlerCheck: "user_service.go UpdateUser checks permission.UsersCreate before delegating to CreateUser",+ },+ "bytebase.v1.SettingService.UpdateSetting": {+ handlerCheck: "setting_service.go UpdateSetting checks the bb.settings.set family before the existence lookup; a setting has one write permission covering create and update",+ },+}++// allowMissingCreateCheck names how one RPC authorizes its create path. Exactly+// one field is set.+type allowMissingCreateCheck struct {+ createPermission string+ handlerCheck string+}++// TestAllowMissingCreatePermission fails when an allow_missing create path is+// authorized by nobody, or by a permission that cannot deny or cannot grant.+func TestAllowMissingCreatePermission(t *testing.T) {+ found := allowMissingMethods(t)++ var undeclared []string+ for name, method := range found {+ check, ok := allowMissingCreateChecks[name]+ if !ok {+ shape := "allow_missing"+ if method.nested {+ shape = "a nested allow_missing sub-request, which hasAllowMissingEnabled reads only for the types it names by hand"+ }+ undeclared = append(undeclared, fmt.Sprintf("%s takes %s (auth_method=%s, permission=%q)", name, shape, method.authMethod, method.permission))+ continue+ }++ if check.handlerCheck != "" {+ require.Empty(t, check.createPermission, "%s lists both mechanisms; set exactly one", name)+ require.Equal(t, v1pb.AuthMethod_CUSTOM, method.authMethod,+ "%s is listed as handler-enforced but is %s-authed, so the interceptor covers it — list its derived create permission instead", name, method.authMethod)+ continue+ }++ require.NotEmpty(t, check.createPermission, "%s lists neither mechanism; set exactly one", name)+ require.Equal(t, v1pb.AuthMethod_IAM, method.authMethod,+ "%s is listed as interceptor-enforced but is %s-authed; doIAMPermissionCheck returns true for every non-IAM method, so nothing is verified", name, method.authMethod)+ require.NotEmpty(t, method.permission,+ "%s declares no permission, so the interceptor derives the empty string and denies every caller", name)++ derived := strings.Replace(method.permission, ".update", ".create", 1)+ require.NotEqual(t, method.permission, derived,+ "%s declares %q, which the interceptor's .update -> .create rewrite leaves unchanged, so the secondary check re-checks the permission already checked", name, method.permission)+ require.True(t, permission.Exist(derived),+ "%s derives %q, which is not in permission.yaml; CheckPermission never matches an unknown string, so allow_missing=true denies every caller", name, derived)+ require.Equal(t, check.createPermission, derived,+ "%s derives a different create permission than the one listed here", name)++ requireInterceptorSeesAllowMissing(t, name, method)+ }++ var stale []string+ for name := range allowMissingCreateChecks {+ if _, ok := found[name]; !ok {+ stale = append(stale, name)+ }+ }++ slices.Sort(undeclared)+ slices.Sort(stale)+ require.Empty(t, undeclared, "these RPCs take allow_missing but no one has said what authorizes the create path:\n %s", strings.Join(undeclared, "\n "))+ require.Empty(t, stale, "these listed RPCs no longer take allow_missing; drop the entries:\n %s", strings.Join(stale, "\n "))+}++type allowMissingMethod struct {+ authMethod v1pb.AuthMethod+ permission string+ // nested: the flag is on a sub-request, the BatchUpdateInstances shape.+ nested bool+ input protoreflect.FullName+}++// allowMissingMethods returns every bytebase.v1 RPC carrying allow_missing,+// keyed by full method name.+func allowMissingMethods(t *testing.T) map[string]allowMissingMethod {+ t.Helper()+ methods := map[string]allowMissingMethod{}+ protoregistry.GlobalFiles.RangeFiles(func(fd protoreflect.FileDescriptor) bool {+ if fd.Package() != "bytebase.v1" {+ return true+ }+ services := fd.Services()+ for i := range services.Len() {+ sd := services.Get(i)+ descriptors := sd.Methods()+ for j := range descriptors.Len() {+ md := descriptors.Get(j)+ direct, nested := allowMissingShape(md.Input())+ if !direct && !nested {+ continue+ }+ method := allowMissingMethod{nested: !direct, input: md.Input().FullName()}+ if options, ok := md.Options().(*descriptorpb.MethodOptions); ok {+ if p, ok := proto.GetExtension(options, v1pb.E_Permission).(string); ok {+ method.permission = p+ }+ if a, ok := proto.GetExtension(options, v1pb.E_AuthMethod).(v1pb.AuthMethod); ok {+ method.authMethod = a+ }+ }+ methods[string(sd.FullName())+"."+string(md.Name())] = method+ }+ }+ return true+ })+ require.NotEmpty(t, methods, "no allow_missing RPCs found; the descriptor walk is broken, not the API")+ return methods+}++// requireInterceptorSeesAllowMissing sets allow_missing on the real request and+// asserts hasAllowMissingEnabled reads it. This is the point for nested shapes:+// the interceptor reaches a sub-request only via its hand-written type switch,+// so a batch RPC missing from that switch reports false here.+func requireInterceptorSeesAllowMissing(t *testing.T, name string, method allowMissingMethod) {+ t.Helper()++ mt, err := protoregistry.GlobalTypes.FindMessageByName(method.input)+ require.NoError(t, err, "%s: cannot resolve request type %s", name, method.input)+ msg := mt.New()++ if method.nested {+ fd := nestedAllowMissingField(msg.Descriptor())+ require.NotNil(t, fd, "%s: no nested allow_missing field", name)+ sub := msg.Mutable(fd)+ if fd.IsList() {+ sub = sub.List().AppendMutable()+ }+ subMsg := sub.Message()+ subMsg.Set(subMsg.Descriptor().Fields().ByName("allow_missing"), protoreflect.ValueOfBool(true))+ } else {+ msg.Set(msg.Descriptor().Fields().ByName("allow_missing"), protoreflect.ValueOfBool(true))+ }++ require.True(t, hasAllowMissingEnabled(msg.Interface()),+ "%s sets allow_missing but hasAllowMissingEnabled does not see it, so the create permission is never checked; add the request type to its type switch", name)+}++// nestedAllowMissingField returns the sub-request field carrying allow_missing,+// or nil. allowMissingShape defers to it so the two cannot disagree.+func nestedAllowMissingField(md protoreflect.MessageDescriptor) protoreflect.FieldDescriptor {+ fields := md.Fields()+ for i := range fields.Len() {+ fd := fields.Get(i)+ if fd.Kind() != protoreflect.MessageKind || fd.IsMap() {+ continue+ }+ if hasAllowMissingField(fd.Message()) {+ return fd+ }+ }+ return nil+}++// allowMissingShape reports how a request carries allow_missing: directly, or on+// a sub-request one level down. Listing both is what surfaces a new batch RPC+// the interceptor's type switch does not name.+func allowMissingShape(md protoreflect.MessageDescriptor) (direct, nested bool) {+ if hasAllowMissingField(md) {+ return true, false+ }+ return false, nestedAllowMissingField(md) != nil+}++// hasAllowMissingField mirrors hasAllowMissingEnabled's lookup: a bool named+// exactly allow_missing.+func hasAllowMissingField(md protoreflect.MessageDescriptor) bool {+ fd := md.Fields().ByName("allow_missing")+ return fd != nil && fd.Kind() == protoreflect.BoolKind+}diff --git a/backend/api/v1/group_service.go b/backend/api/v1/group_service.goindex 636d51f8e2..3ba324d244 100644--- a/backend/api/v1/group_service.go+++ b/backend/api/v1/group_service.go@@ -163,14 +163,27 @@ func (s *GroupService) UpdateGroup(ctx context.Context, req *connect.Request[v1pif err != nil {return nil, connect.NewError(connect.CodeInternal, err)}+ user, ok := GetUserFromContext(ctx)+ if !ok {+ return nil, connect.NewError(connect.CodeInternal, errors.New("user not found"))+ }+if group == nil {if req.Msg.AllowMissing {groupEmail, err := common.GetGroupEmail(req.Msg.Group.Name)if err != nil {return nil, connect.NewError(connect.CodeInvalidArgument, err)}- // Permission check is now handled by the ACL interceptor- // which verifies both bb.groups.update and bb.groups.create+ // Checked here, not by the ACL interceptor: UpdateGroup is CUSTOM-authed,+ // and the CreateGroup call below is in-process, so neither path reaches+ // the interceptor. No group exists yet, so no owner bypass applies.+ ok, err := s.iamManager.CheckPermission(ctx, permission.GroupsCreate, user, common.GetWorkspaceIDFromContext(ctx))+ if err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to check permission"))+ }+ if !ok {+ return nil, connect.NewError(connect.CodePermissionDenied, errors.Errorf("user does not have permission %q", permission.GroupsCreate))+ }return s.CreateGroup(ctx, connect.NewRequest(&v1pb.CreateGroupRequest{Group: req.Msg.Group,GroupEmail: groupEmail,@@ -182,10 +195,6 @@ func (s *GroupService) UpdateGroup(ctx context.Context, req *connect.Request[v1preturn nil, connect.NewError(connect.CodeFailedPrecondition, errors.Errorf("not support update external group %q", req.Msg.Group.Name))}- user, ok := GetUserFromContext(ctx)- if !ok {- return nil, connect.NewError(connect.CodeInternal, errors.New("user not found"))- }if err := s.checkPermission(ctx, group, user, permission.GroupsUpdate); err != nil {return nil, err}diff --git a/backend/generated-go/v1/database_service.pb.go b/backend/generated-go/v1/database_service.pb.goindex c025b8eb52..379c6f878d 100644--- a/backend/generated-go/v1/database_service.pb.go+++ b/backend/generated-go/v1/database_service.pb.go@@ -864,10 +864,7 @@ type UpdateDatabaseRequest struct {// Format: instances/{instance}/databases/{database} or projects/{project}/instances/{instance}/databases/{database}Database *Database `protobuf:"bytes,1,opt,name=database,proto3" json:"database,omitempty"`// The list of fields to update.- UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`- // If set to true, and the database is not found, a new database will be created.- // In this situation, `update_mask` is ignored.- AllowMissing bool `protobuf:"varint,3,opt,name=allow_missing,json=allowMissing,proto3" json:"allow_missing,omitempty"`+ UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`unknownFields protoimpl.UnknownFieldssizeCache protoimpl.SizeCache}@@ -916,13 +913,6 @@ func (x *UpdateDatabaseRequest) GetUpdateMask() *fieldmaskpb.FieldMask {return nil}-func (x *UpdateDatabaseRequest) GetAllowMissing() bool {- if x != nil {- return x.AllowMissing- }- return false-}-type BatchUpdateDatabasesRequest struct {state protoimpl.MessageState `protogen:"open.v1"`// The parent resource shared by all databases being updated.@@ -5480,12 +5470,11 @@ const file_v1_database_service_proto_rawDesc = "" +"\border_by\x18\x06 \x01(\tR\aorderBy\"t\n" +"\x15ListDatabasesResponse\x123\n" +"\tdatabases\x18\x01 \x03(\v2\x15.bytebase.v1.DatabaseR\tdatabases\x12&\n" +- "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"\xb1\x01\n" ++ "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"\x8c\x01\n" +"\x15UpdateDatabaseRequest\x126\n" +"\bdatabase\x18\x01 \x01(\v2\x15.bytebase.v1.DatabaseB\x03\xe0A\x02R\bdatabase\x12;\n" +"\vupdate_mask\x18\x02 \x01(\v2\x1a.google.protobuf.FieldMaskR\n" +- "updateMask\x12#\n" +- "\rallow_missing\x18\x03 \x01(\bR\fallowMissing\"z\n" ++ "updateMask\"z\n" +"\x1bBatchUpdateDatabasesRequest\x12\x16\n" +"\x06parent\x18\x01 \x01(\tR\x06parent\x12C\n" +"\brequests\x18\x02 \x03(\v2\".bytebase.v1.UpdateDatabaseRequestB\x03\xe0A\x02R\brequests\"S\n" +diff --git a/backend/generated-go/v1/database_service_equal.pb.go b/backend/generated-go/v1/database_service_equal.pb.goindex 4f003a06a1..9a32cff918 100644--- a/backend/generated-go/v1/database_service_equal.pb.go+++ b/backend/generated-go/v1/database_service_equal.pb.go@@ -127,9 +127,6 @@ func (x *UpdateDatabaseRequest) Equal(y *UpdateDatabaseRequest) bool {} else if !proto.Equal(x.UpdateMask, y.UpdateMask) {return false}- if x.AllowMissing != y.AllowMissing {- return false- }return true}diff --git a/backend/tests/group_allow_missing_test.go b/backend/tests/group_allow_missing_test.gonew file mode 100644index 0000000000..6b2857d34e--- /dev/null+++ b/backend/tests/group_allow_missing_test.go@@ -0,0 +1,92 @@+package tests++import (+ "context"+ "fmt"+ "testing"++ "connectrpc.com/connect"+ "github.com/stretchr/testify/require"++ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+)++// TestUpdateGroupAllowMissingRequiresCreatePermission pins the create check on+// UpdateGroup's allow_missing path. Neither the ACL interceptor (CUSTOM auth) nor+// CreateGroup (called in-process) covers it, so for a while a caller with no group+// permission could create one — and name itself OWNER, which checkPermission honors.+func TestUpdateGroupAllowMissingRequiresCreatePermission(t *testing.T) {+ t.Parallel()+ a := require.New(t)+ ctx := context.Background()+ ctl := &controller{}+ ctx, err := ctl.StartServerWithExternalPg(ctx)+ a.NoError(err)+ defer ctl.Close(ctx)++ adminToken := ctl.authInterceptor.token+ const password = "1024bytebase"++ login := func(email string) string {+ resp, err := ctl.authServiceClient.Login(ctx, connect.NewRequest(&v1pb.LoginRequest{+ Email: email,+ Password: password,+ }))+ a.NoError(err)+ return resp.Msg.Token+ }+ createUserWithRole := func(prefix, role string) string {+ email := fmt.Sprintf("%s-%[email protected]", prefix, generateRandomString("u"))+ created, err := ctl.userServiceClient.CreateUser(ctx, connect.NewRequest(&v1pb.CreateUserRequest{+ User: &v1pb.User{Email: email, Password: password, Title: prefix},+ }))+ a.NoError(err)+ _, err = ctl.addMemberToWorkspaceIAM(ctx, created.Msg.Workspace, "user:"+email, role)+ a.NoError(err)+ return email+ }++ // Workspace DBA holds neither bb.groups.create nor bb.groups.update.+ dbaEmail := createUserWithRole("dba", "roles/workspaceDBA")+ dbaToken := login(dbaEmail)++ // Fixture check: if this ever passes, the role gained bb.groups.create and the+ // denial below would prove nothing.+ ctl.authInterceptor.token = dbaToken+ _, err = ctl.groupServiceClient.CreateGroup(ctx, connect.NewRequest(&v1pb.CreateGroupRequest{+ Group: &v1pb.Group{Title: "Front door"},+ GroupEmail: fmt.Sprintf("front-%[email protected]", generateRandomString("g")),+ }))+ a.Error(err)+ a.Equal(connect.CodePermissionDenied, connect.CodeOf(err), "workspace DBA must not hold bb.groups.create")++ // The regression: no back door to creation either.+ deniedGroupEmail := fmt.Sprintf("denied-%[email protected]", generateRandomString("g"))+ deniedGroupName := "groups/" + deniedGroupEmail+ _, err = ctl.groupServiceClient.UpdateGroup(ctx, connect.NewRequest(&v1pb.UpdateGroupRequest{+ Group: &v1pb.Group{Name: deniedGroupName, Title: "Back door"},+ AllowMissing: true,+ }))+ a.Error(err)+ a.Equal(connect.CodePermissionDenied, connect.CodeOf(err), "UpdateGroup(allow_missing) must require bb.groups.create")++ // And nothing was written on the way to the denial.+ ctl.authInterceptor.token = adminToken+ _, err = ctl.groupServiceClient.GetGroup(ctx, connect.NewRequest(&v1pb.GetGroupRequest{Name: deniedGroupName}))+ a.Error(err)+ a.Equal(connect.CodeNotFound, connect.CodeOf(err), "the denied UpdateGroup must not have created the group")++ // Positive control: Workspace Member holds bb.groups.create, so allow_missing+ // still creates. Also proves the denial above is the permission, not the+ // USER_GROUPS license guard, which runs first and would deny both alike.+ memberEmail := createUserWithRole("member", "roles/workspaceMember")+ ctl.authInterceptor.token = login(memberEmail)++ allowedGroupEmail := fmt.Sprintf("allowed-%[email protected]", generateRandomString("g"))+ created, err := ctl.groupServiceClient.UpdateGroup(ctx, connect.NewRequest(&v1pb.UpdateGroupRequest{+ Group: &v1pb.Group{Name: "groups/" + allowedGroupEmail, Title: "Allowed"},+ AllowMissing: true,+ }))+ a.NoError(err)+ a.Equal(allowedGroupEmail, created.Msg.Email)+}diff --git a/docs/design/v1-api-audit-2026-08.md b/docs/design/v1-api-audit-2026-08.mdindex ba497f9e35..cfaa45f75c 100644--- a/docs/design/v1-api-audit-2026-08.md+++ b/docs/design/v1-api-audit-2026-08.md@@ -12,7 +12,6 @@ noted. Fixed findings are removed and listed at the end.|---|---|---|| T12 | Anonymous callers can enumerate emails, relay mail, and read your LDAP config | MED || T16 | Four `BatchGet` RPCs behave four different ways when an item is missing | MED |-| T11 | A create-permission check is skipped on `allow_missing` updates | MED || T18c | Three smaller ones: broken filter, unpaginated list, half-finished delete | MED |---@@ -40,16 +39,6 @@ call was authorized against the workspace. Both are fixed and listed at the end.generalizes — the next request field that departs from the convention arrives unchecked, silently,and only a sweep like this one finds it.-### T11 · A create check is skipped on `allow_missing` updates — MED--`UpdateGroup(allow_missing=true)` creates a group when none exists, but the create-permission check-is short-circuited for CUSTOM-auth RPCs, so nothing is verified. Harmless today only because every-member can create groups anyway — but the code comment right above it claims the check happens,-which is how this survives review.--Same root cause, wider: 15 of the 45 CUSTOM RPCs declare a `permission` annotation that is never-enforced. It's decorative, and it reads as protection. `acl.go:251-253`, `group_service.go:167-177`----## The API says OK and does nothing@@ -142,8 +131,9 @@ constraints.failure instead of a silent scope change.2. **Fail closed on auth annotations, and put api-linter in CI.** Reject`AUTH_METHOD_UNSPECIFIED` at startup; make a `permission` on a CUSTOM RPC either enforced or a- build error, since 15 are decorative. None of Tier 5 was visible to `buf lint`'s BASIC profile,- which is why it accumulated.+ build error, since 16 of the 52 are decorative — `TestAllowMissingCreatePermission`, added with+ T11, is the descriptor-walking shape to generalize. None of Tier 5 was visible to `buf lint`'s+ BASIC profile, which is why it accumulated.---@@ -155,6 +145,7 @@ constraints.| T2 (INPUT_ONLY) | Read-path fix || T2 `DiffSchema` | `DiffSchema` rejects a changelog target owned by another project before any read, matching how every other second-resource handler closes it. Not the general interceptor change: the resource the caller names must simply belong to the project they were authorized on, which is also the only thing a cross-project diff could have meant. A missing target and a foreign one return the same error, so neither confirms what lives in the other project. Accepted with it: the class stays latent — a future second-resource field still arrives unchecked || T19 `UpdateDatabaseCatalog` | The interceptor now reads `catalog.name`, so the permission is checked against the named database's project instead of the workspace — the route resolver already drops the trailing `/catalog`. Strictly additive: workspace holders are unaffected and Project Owner, whose role carries `bb.databaseCatalogs.update`, is no longer denied. Separate and still open: `bb.databaseCatalogs.create` does not exist, so the `allow_missing` secondary check denies every caller. Dead rather than harmful — no UI sets the flag and the RPC is MCP-`EXCLUDED` |+| T11 | `UpdateGroup(allow_missing=true)` now checks `bb.groups.create` itself, the shape `UpdatePlan` and `UpdateUser` already had. The interceptor never covered it: `doIAMPermissionCheck` returns true for every non-IAM auth method, so the `allow_missing` secondary block evaluated to nothing on a CUSTOM RPC, and the create path calls `CreateGroup` in-process, which bypasses the interceptor anyway — while the comment above it claimed both permissions were verified. The exposure was narrower and differently shaped than first written: Workspace Member does hold `bb.groups.create`, but Workspace DBA and every project role do not, so a DBA-only principal could create a group and name itself OWNER, which `checkPermission` then honors for that group. It stops there — a group confers nothing until someone with IAM-policy rights binds a role to it. The interceptor's block is now gated on `AuthMethod == IAM` so it no longer reads as protection where it verifies nothing (behavior-preserving: it already returned true there). Found tracing the same mechanism, and fixed with it: the `.update` → `.create` string rewrite is unvalidated, and `UpdateDatabase` derived `bb.databases.create`, which does not exist — `CheckPermission` never matches an unknown string, so `allow_missing=true` denied every caller including Workspace Admin, on a flag `database_service.go` never read and the proto documented as working. The field is removed and the proto now says never to add it back, since a database is not independently creatable. `TestAllowMissingCreatePermission` walks the descriptors and makes all four silent failure modes a build failure — an RPC that gains the flag with nothing authorizing its create path, a derived permission that does not exist, a declared permission the rewrite leaves unchanged (`bb.settings.set` is one, and vacuous if it ever went IAM), and a nested `allow_missing` sub-request the interceptor's hand-written type switch does not name, which it proves by building the request and asserting `hasAllowMissingEnabled` reads it. Still open, and the other half of the original finding: 16 of the 52 CUSTOM RPCs declare a `permission` annotation that nothing ties to enforcement, so it remains documentation that reads as protection || T5, T6 | [#21143](https://github.com/bytebase/bytebase/pull/21143) — `sheet_blob_ref` gives sheets per-project ownership; `BatchCreateRevisions` rejects foreign-project provenance without echoing the hash || T7 | [#21102](https://github.com/bytebase/bytebase/pull/21102) — every `CheckRelease` target validated against the parent project before any schema read (its error codes still leak existence — T18c-iii) || T8 `CreateWorksheet` | [#21169](https://github.com/bytebase/bytebase/pull/21169) — `CreateSavedQuery` is now IAM-enforced; Workspace Member holds no saved-query permission, and new queries start creator-private |diff --git a/frontend/src/types/proto-es/v1/database_service_pb.d.ts b/frontend/src/types/proto-es/v1/database_service_pb.d.tsindex 4ccbc85469..b6d073bfb5 100644--- a/frontend/src/types/proto-es/v1/database_service_pb.d.ts+++ b/frontend/src/types/proto-es/v1/database_service_pb.d.ts@@ -224,14 +224,6 @@ export declare type UpdateDatabaseRequest = Message<"bytebase.v1.UpdateDatabaseR* @generated from field: google.protobuf.FieldMask update_mask = 2;*/updateMask?: FieldMask | undefined;-- /**- * If set to true, and the database is not found, a new database will be created.- * In this situation, `update_mask` is ignored.- *- * @generated from field: bool allow_missing = 3;- */- allowMissing: boolean;};/**diff --git a/frontend/src/types/proto-es/v1/database_service_pb.js b/frontend/src/types/proto-es/v1/database_service_pb.jsindex 39e51b7e76..68dfdeacd2 100644--- a/frontend/src/types/proto-es/v1/database_service_pb.js+++ b/frontend/src/types/proto-es/v1/database_service_pb.js@@ -16,7 +16,7 @@ import { file_v1_instance_service } from "./instance_service_pb";* Describes the file v1/database_service.proto.*/export const file_v1_database_service = /*@__PURE__*/- fileDesc("Chl2MS9kYXRhYmFzZV9zZXJ2aWNlLnByb3RvEgtieXRlYmFzZS52MSJBChJHZXREYXRhYmFzZVJlcXVlc3QSKwoEbmFtZRgBIAEoCUId4EEC+kEXChVieXRlYmFzZS5jb20vRGF0YWJhc2UidwoYQmF0Y2hHZXREYXRhYmFzZXNSZXF1ZXN0Ei0KBnBhcmVudBgBIAEoCUId4EEC+kEXEhVieXRlYmFzZS5jb20vRGF0YWJhc2USLAoFbmFtZXMYAiADKAlCHeBBAvpBFwoVYnl0ZWJhc2UuY29tL0RhdGFiYXNlIkUKGUJhdGNoR2V0RGF0YWJhc2VzUmVzcG9uc2USKAoJZGF0YWJhc2VzGAEgAygLMhUuYnl0ZWJhc2UudjEuRGF0YWJhc2UipAEKFExpc3REYXRhYmFzZXNSZXF1ZXN0Ei0KBnBhcmVudBgBIAEoCUId4EEC+kEXEhVieXRlYmFzZS5jb20vRGF0YWJhc2USEQoJcGFnZV9zaXplGAIgASgFEhIKCnBhZ2VfdG9rZW4YAyABKAkSDgoGZmlsdGVyGAQgASgJEhQKDHNob3dfZGVsZXRlZBgFIAEoCBIQCghvcmRlcl9ieRgGIAEoCSJaChVMaXN0RGF0YWJhc2VzUmVzcG9uc2USKAoJZGF0YWJhc2VzGAEgAygLMhUuYnl0ZWJhc2UudjEuRGF0YWJhc2USFwoPbmV4dF9wYWdlX3Rva2VuGAIgASgJIo0BChVVcGRhdGVEYXRhYmFzZVJlcXVlc3QSLAoIZGF0YWJhc2UYASABKAsyFS5ieXRlYmFzZS52MS5EYXRhYmFzZUID4EECEi8KC3VwZGF0ZV9tYXNrGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLkZpZWxkTWFzaxIVCg1hbGxvd19taXNzaW5nGAMgASgIImgKG0JhdGNoVXBkYXRlRGF0YWJhc2VzUmVxdWVzdBIOCgZwYXJlbnQYASABKAkSOQoIcmVxdWVzdHMYAiADKAsyIi5ieXRlYmFzZS52MS5VcGRhdGVEYXRhYmFzZVJlcXVlc3RCA+BBAiJIChxCYXRjaFVwZGF0ZURhdGFiYXNlc1Jlc3BvbnNlEigKCWRhdGFiYXNlcxgBIAMoCzIVLmJ5dGViYXNlLnYxLkRhdGFiYXNlIlkKGUJhdGNoU3luY0RhdGFiYXNlc1JlcXVlc3QSDgoGcGFyZW50GAEgASgJEiwKBW5hbWVzGAIgAygJQh3gQQL6QRcKFWJ5dGViYXNlLmNvbS9EYXRhYmFzZSIcChpCYXRjaFN5bmNEYXRhYmFzZXNSZXNwb25zZSJCChNTeW5jRGF0YWJhc2VSZXF1ZXN0EisKBG5hbWUYASABKAlCHeBBAvpBFwoVYnl0ZWJhc2UuY29tL0RhdGFiYXNlIhYKFFN5bmNEYXRhYmFzZVJlc3BvbnNlInAKGkdldERhdGFiYXNlTWV0YWRhdGFSZXF1ZXN0EjMKBG5hbWUYASABKAlCJeBBAvpBHwodYnl0ZWJhc2UuY29tL0RhdGFiYXNlTWV0YWRhdGESDgoGZmlsdGVyGAIgASgJEg0KBWxpbWl0GAMgASgFIk0KGEdldERhdGFiYXNlU2NoZW1hUmVxdWVzdBIxCgRuYW1lGAEgASgJQiPgQQL6QR0KG2J5dGViYXNlLmNvbS9EYXRhYmFzZVNjaGVtYSLYAQobR2V0RGF0YWJhc2VTRExTY2hlbWFSZXF1ZXN0EisKBG5hbWUYASABKAlCHeBBAvpBFwoVYnl0ZWJhc2UuY29tL0RhdGFiYXNlEkIKBmZvcm1hdBgCIAEoDjIyLmJ5dGViYXNlLnYxLkdldERhdGFiYXNlU0RMU2NoZW1hUmVxdWVzdC5TRExGb3JtYXQiSAoJU0RMRm9ybWF0EhoKFlNETF9GT1JNQVRfVU5TUEVDSUZJRUQQABIPCgtTSU5HTEVfRklMRRABEg4KCk1VTFRJX0ZJTEUQAiJxChFEaWZmU2NoZW1hUmVxdWVzdBIrCgRuYW1lGAEgASgJQh3gQQL6QRcKFWJ5dGViYXNlLmNvbS9EYXRhYmFzZRIQCgZzY2hlbWEYAiABKAlIABITCgljaGFuZ2Vsb2cYAyABKAlIAEIICgZ0YXJnZXQiIgoSRGlmZlNjaGVtYVJlc3BvbnNlEgwKBGRpZmYYASABKAkifwoTRGlmZk1ldGFkYXRhUmVxdWVzdBIrCgRuYW1lGAEgASgJQh3gQQL6QRcKFWJ5dGViYXNlLmNvbS9EYXRhYmFzZRI7Cg90YXJnZXRfbWV0YWRhdGEYAiABKAsyHS5ieXRlYmFzZS52MS5EYXRhYmFzZU1ldGFkYXRhQgPgQQIiJAoURGlmZk1ldGFkYXRhUmVzcG9uc2USDAoEZGlmZhgBIAEoCSKrBQoIRGF0YWJhc2USDAoEbmFtZRgBIAEoCRImCgVzdGF0ZRgCIAEoDjISLmJ5dGViYXNlLnYxLlN0YXRlQgPgQQMSPQoUc3VjY2Vzc2Z1bF9zeW5jX3RpbWUYAyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSDwoHcHJvamVjdBgEIAEoCRIUCgdyZWxlYXNlGAUgASgJQgPgQQMSHQoLZW52aXJvbm1lbnQYBiABKAlCA+BBAUgAiAEBEicKFWVmZmVjdGl2ZV9lbnZpcm9ubWVudBgHIAEoCUID4EEDSAGIAQESMQoGbGFiZWxzGAggAygLMiEuYnl0ZWJhc2UudjEuRGF0YWJhc2UuTGFiZWxzRW50cnkSPQoRaW5zdGFuY2VfcmVzb3VyY2UYCSABKAsyHS5ieXRlYmFzZS52MS5JbnN0YW5jZVJlc291cmNlQgPgQQMSHQoQYmFja3VwX2F2YWlsYWJsZRgKIAEoCEID4EEDEjEKC3N5bmNfc3RhdHVzGAsgASgOMhcuYnl0ZWJhc2UudjEuU3luY1N0YXR1c0ID4EEDEhcKCnN5bmNfZXJyb3IYDCABKAlCA+BBAxotCgtMYWJlbHNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBOoQB6kGAAQoVYnl0ZWJhc2UuY29tL0RhdGFiYXNlEilpbnN0YW5jZXMve2luc3RhbmNlfS9kYXRhYmFzZXMve2RhdGFiYXNlfRI8cHJvamVjdHMve3Byb2plY3R9L2luc3RhbmNlcy97aW5zdGFuY2V9L2RhdGFiYXNlcy97ZGF0YWJhc2V9Qg4KDF9lbnZpcm9ubWVudEIYChZfZWZmZWN0aXZlX2Vudmlyb25tZW50IvECChBEYXRhYmFzZU1ldGFkYXRhEgwKBG5hbWUYASABKAkSLAoHc2NoZW1hcxgCIAMoCzIbLmJ5dGViYXNlLnYxLlNjaGVtYU1ldGFkYXRhEhUKDWNoYXJhY3Rlcl9zZXQYAyABKAkSEQoJY29sbGF0aW9uGAQgASgJEjIKCmV4dGVuc2lvbnMYBSADKAsyHi5ieXRlYmFzZS52MS5FeHRlbnNpb25NZXRhZGF0YRINCgVvd25lchgGIAEoCRITCgtzZWFyY2hfcGF0aBgHIAEoCTqeAepBmgEKHWJ5dGViYXNlLmNvbS9EYXRhYmFzZU1ldGFkYXRhEjJpbnN0YW5jZXMve2luc3RhbmNlfS9kYXRhYmFzZXMve2RhdGFiYXNlfS9tZXRhZGF0YRJFcHJvamVjdHMve3Byb2plY3R9L2luc3RhbmNlcy97aW5zdGFuY2V9L2RhdGFiYXNlcy97ZGF0YWJhc2V9L21ldGFkYXRhIuMFCg5TY2hlbWFNZXRhZGF0YRIMCgRuYW1lGAEgASgJEioKBnRhYmxlcxgCIAMoCzIaLmJ5dGViYXNlLnYxLlRhYmxlTWV0YWRhdGESOwoPZXh0ZXJuYWxfdGFibGVzGAMgAygLMiIuYnl0ZWJhc2UudjEuRXh0ZXJuYWxUYWJsZU1ldGFkYXRhEigKBXZpZXdzGAQgAygLMhkuYnl0ZWJhc2UudjEuVmlld01ldGFkYXRhEjAKCWZ1bmN0aW9ucxgFIAMoCzIdLmJ5dGViYXNlLnYxLkZ1bmN0aW9uTWV0YWRhdGESMgoKcHJvY2VkdXJlcxgGIAMoCzIeLmJ5dGViYXNlLnYxLlByb2NlZHVyZU1ldGFkYXRhEiwKB3N0cmVhbXMYByADKAsyGy5ieXRlYmFzZS52MS5TdHJlYW1NZXRhZGF0YRIoCgV0YXNrcxgIIAMoCzIZLmJ5dGViYXNlLnYxLlRhc2tNZXRhZGF0YRJBChJtYXRlcmlhbGl6ZWRfdmlld3MYCSADKAsyJS5ieXRlYmFzZS52MS5NYXRlcmlhbGl6ZWRWaWV3TWV0YWRhdGESLgoIcGFja2FnZXMYCiADKAsyHC5ieXRlYmFzZS52MS5QYWNrYWdlTWV0YWRhdGESDQoFb3duZXIYCyABKAkSMAoJc2VxdWVuY2VzGAwgAygLMh0uYnl0ZWJhc2UudjEuU2VxdWVuY2VNZXRhZGF0YRIqCgZldmVudHMYDSADKAsyGi5ieXRlYmFzZS52MS5FdmVudE1ldGFkYXRhEjEKCmVudW1fdHlwZXMYDiADKAsyHS5ieXRlYmFzZS52MS5FbnVtVHlwZU1ldGFkYXRhEhEKCXNraXBfZHVtcBgPIAEoCBIPCgdjb21tZW50GBAgASgJEjsKD2NvbXBvc2l0ZV90eXBlcxgRIAMoCzIiLmJ5dGViYXNlLnYxLkNvbXBvc2l0ZVR5cGVNZXRhZGF0YSJUChBFbnVtVHlwZU1ldGFkYXRhEgwKBG5hbWUYASABKAkSDgoGdmFsdWVzGAIgAygJEg8KB2NvbW1lbnQYAyABKAkSEQoJc2tpcF9kdW1wGAQgASgIIm8KFUNvbXBvc2l0ZVR5cGVNZXRhZGF0YRIMCgRuYW1lGAEgASgJEjcKCmF0dHJpYnV0ZXMYAiADKAsyIy5ieXRlYmFzZS52MS5Db21wb3NpdGVUeXBlQXR0cmlidXRlEg8KB2NvbW1lbnQYAyABKAkiWAoWQ29tcG9zaXRlVHlwZUF0dHJpYnV0ZRIMCgRuYW1lGAEgASgJEgwKBHR5cGUYAiABKAkSEQoJY29sbGF0aW9uGAMgASgJEg8KB2NvbW1lbnQYBCABKAkiowEKDUV2ZW50TWV0YWRhdGESDAoEbmFtZRgBIAEoCRISCgpkZWZpbml0aW9uGAIgASgJEhEKCXRpbWVfem9uZRgDIAEoCRIQCghzcWxfbW9kZRgEIAEoCRIcChRjaGFyYWN0ZXJfc2V0X2NsaWVudBgFIAEoCRIcChRjb2xsYXRpb25fY29ubmVjdGlvbhgGIAEoCRIPCgdjb21tZW50GAcgASgJIoECChBTZXF1ZW5jZU1ldGFkYXRhEgwKBG5hbWUYASABKAkSEQoJZGF0YV90eXBlGAIgASgJEg0KBXN0YXJ0GAMgASgJEhEKCW1pbl92YWx1ZRgEIAEoCRIRCgltYXhfdmFsdWUYBSABKAkSEQoJaW5jcmVtZW50GAYgASgJEg0KBWN5Y2xlGAcgASgIEhIKCmNhY2hlX3NpemUYCCABKAkSEgoKbGFzdF92YWx1ZRgJIAEoCRITCgtvd25lcl90YWJsZRgKIAEoCRIUCgxvd25lcl9jb2x1bW4YCyABKAkSDwoHY29tbWVudBgMIAEoCRIRCglza2lwX2R1bXAYDSABKAgivgEKD1RyaWdnZXJNZXRhZGF0YRIMCgRuYW1lGAEgASgJEg0KBWV2ZW50GAIgASgJEg4KBnRpbWluZxgDIAEoCRIMCgRib2R5GAQgASgJEhAKCHNxbF9tb2RlGAUgASgJEhwKFGNoYXJhY3Rlcl9zZXRfY2xpZW50GAYgASgJEhwKFGNvbGxhdGlvbl9jb25uZWN0aW9uGAcgASgJEg8KB2NvbW1lbnQYCCABKAkSEQoJc2tpcF9kdW1wGAkgASgIIpEBChVFeHRlcm5hbFRhYmxlTWV0YWRhdGESDAoEbmFtZRgBIAEoCRIcChRleHRlcm5hbF9zZXJ2ZXJfbmFtZRgCIAEoCRIeChZleHRlcm5hbF9kYXRhYmFzZV9uYW1lGAMgASgJEiwKB2NvbHVtbnMYBCADKAsyGy5ieXRlYmFzZS52MS5Db2x1bW5NZXRhZGF0YSLsBAoNVGFibGVNZXRhZGF0YRIMCgRuYW1lGAEgASgJEiwKB2NvbHVtbnMYAiADKAsyGy5ieXRlYmFzZS52MS5Db2x1bW5NZXRhZGF0YRIrCgdpbmRleGVzGAMgAygLMhouYnl0ZWJhc2UudjEuSW5kZXhNZXRhZGF0YRIOCgZlbmdpbmUYBCABKAkSEQoJY29sbGF0aW9uGAUgASgJEg8KB2NoYXJzZXQYBiABKAkSEQoJcm93X2NvdW50GAcgASgDEhEKCWRhdGFfc2l6ZRgIIAEoAxISCgppbmRleF9zaXplGAkgASgDEhEKCWRhdGFfZnJlZRgKIAEoAxIWCg5jcmVhdGVfb3B0aW9ucxgLIAEoCRIPCgdjb21tZW50GAwgASgJEjUKDGZvcmVpZ25fa2V5cxgNIAMoCzIfLmJ5dGViYXNlLnYxLkZvcmVpZ25LZXlNZXRhZGF0YRI3CgpwYXJ0aXRpb25zGA4gAygLMiMuYnl0ZWJhc2UudjEuVGFibGVQYXJ0aXRpb25NZXRhZGF0YRI/ChFjaGVja19jb25zdHJhaW50cxgPIAMoCzIkLmJ5dGViYXNlLnYxLkNoZWNrQ29uc3RyYWludE1ldGFkYXRhEg0KBW93bmVyGBAgASgJEhQKDHNvcnRpbmdfa2V5cxgRIAMoCRIuCgh0cmlnZ2VycxgSIAMoCzIcLmJ5dGViYXNlLnYxLlRyaWdnZXJNZXRhZGF0YRIRCglza2lwX2R1bXAYEyABKAgSFQoNc2hhcmRpbmdfaW5mbxgUIAEoCRIYChBwcmltYXJ5X2tleV90eXBlGBUgASgJIjsKF0NoZWNrQ29uc3RyYWludE1ldGFkYXRhEgwKBG5hbWUYASABKAkSEgoKZXhwcmVzc2lvbhgCIAEoCSLNAwoWVGFibGVQYXJ0aXRpb25NZXRhZGF0YRIMCgRuYW1lGAEgASgJEjYKBHR5cGUYAiABKA4yKC5ieXRlYmFzZS52MS5UYWJsZVBhcnRpdGlvbk1ldGFkYXRhLlR5cGUSEgoKZXhwcmVzc2lvbhgDIAEoCRINCgV2YWx1ZRgEIAEoCRITCgt1c2VfZGVmYXVsdBgFIAEoCRI6Cg1zdWJwYXJ0aXRpb25zGAYgAygLMiMuYnl0ZWJhc2UudjEuVGFibGVQYXJ0aXRpb25NZXRhZGF0YRIrCgdpbmRleGVzGAcgAygLMhouYnl0ZWJhc2UudjEuSW5kZXhNZXRhZGF0YRI/ChFjaGVja19jb25zdHJhaW50cxgIIAMoCzIkLmJ5dGViYXNlLnYxLkNoZWNrQ29uc3RyYWludE1ldGFkYXRhIooBCgRUeXBlEhQKEFRZUEVfVU5TUEVDSUZJRUQQABIJCgVSQU5HRRABEhEKDVJBTkdFX0NPTFVNTlMQAhIICgRMSVNUEAMSEAoMTElTVF9DT0xVTU5TEAQSCAoESEFTSBAFEg8KC0xJTkVBUl9IQVNIEAYSBwoDS0VZEAcSDgoKTElORUFSX0tFWRAIItEECg5Db2x1bW5NZXRhZGF0YRIMCgRuYW1lGAEgASgJEhAKCHBvc2l0aW9uGAIgASgFEhMKC2hhc19kZWZhdWx0GAMgASgIEg8KB2RlZmF1bHQYBCABKAkSFwoPZGVmYXVsdF9vbl9udWxsGAUgASgIEhEKCW9uX3VwZGF0ZRgGIAEoCRIQCghudWxsYWJsZRgHIAEoCBIMCgR0eXBlGAggASgJEhUKDWNoYXJhY3Rlcl9zZXQYCSABKAkSEQoJY29sbGF0aW9uGAogASgJEg8KB2NvbW1lbnQYCyABKAkSMwoKZ2VuZXJhdGlvbhgMIAEoCzIfLmJ5dGViYXNlLnYxLkdlbmVyYXRpb25NZXRhZGF0YRITCgtpc19pZGVudGl0eRgNIAEoCBJLChNpZGVudGl0eV9nZW5lcmF0aW9uGA4gASgOMi4uYnl0ZWJhc2UudjEuQ29sdW1uTWV0YWRhdGEuSWRlbnRpdHlHZW5lcmF0aW9uEhUKDWlkZW50aXR5X3NlZWQYDyABKAMSGgoSaWRlbnRpdHlfaW5jcmVtZW50GBAgASgDEh8KF2RlZmF1bHRfY29uc3RyYWludF9uYW1lGBEgASgJEhEKBHNyaWQYEiABKA1IAIgBARIUCgxpc19pbnZpc2libGUYEyABKAgiVQoSSWRlbnRpdHlHZW5lcmF0aW9uEiMKH0lERU5USVRZX0dFTkVSQVRJT05fVU5TUEVDSUZJRUQQABIKCgZBTFdBWVMQARIOCgpCWV9ERUZBVUxUEAJCBwoFX3NyaWQikwEKEkdlbmVyYXRpb25NZXRhZGF0YRIyCgR0eXBlGAEgASgOMiQuYnl0ZWJhc2UudjEuR2VuZXJhdGlvbk1ldGFkYXRhLlR5cGUSEgoKZXhwcmVzc2lvbhgCIAEoCSI1CgRUeXBlEhQKEFRZUEVfVU5TUEVDSUZJRUQQABILCgdWSVJUVUFMEAESCgoGU1RPUkVEEAIi7QEKDFZpZXdNZXRhZGF0YRIMCgRuYW1lGAEgASgJEhIKCmRlZmluaXRpb24YAiABKAkSDwoHY29tbWVudBgDIAEoCRI5ChJkZXBlbmRlbmN5X2NvbHVtbnMYBCADKAsyHS5ieXRlYmFzZS52MS5EZXBlbmRlbmN5Q29sdW1uEiwKB2NvbHVtbnMYBSADKAsyGy5ieXRlYmFzZS52MS5Db2x1bW5NZXRhZGF0YRIuCgh0cmlnZ2VycxgGIAMoCzIcLmJ5dGViYXNlLnYxLlRyaWdnZXJNZXRhZGF0YRIRCglza2lwX2R1bXAYByABKAgiQQoQRGVwZW5kZW5jeUNvbHVtbhIOCgZzY2hlbWEYASABKAkSDQoFdGFibGUYAiABKAkSDgoGY29sdW1uGAMgASgJIvgBChhNYXRlcmlhbGl6ZWRWaWV3TWV0YWRhdGESDAoEbmFtZRgBIAEoCRISCgpkZWZpbml0aW9uGAIgASgJEg8KB2NvbW1lbnQYAyABKAkSOQoSZGVwZW5kZW5jeV9jb2x1bW5zGAQgAygLMh0uYnl0ZWJhc2UudjEuRGVwZW5kZW5jeUNvbHVtbhIuCgh0cmlnZ2VycxgFIAMoCzIcLmJ5dGViYXNlLnYxLlRyaWdnZXJNZXRhZGF0YRIrCgdpbmRleGVzGAYgAygLMhouYnl0ZWJhc2UudjEuSW5kZXhNZXRhZGF0YRIRCglza2lwX2R1bXAYByABKAgiMAoPRGVwZW5kZW5jeVRhYmxlEg4KBnNjaGVtYRgBIAEoCRINCgV0YWJsZRgCIAEoCSKOAgoQRnVuY3Rpb25NZXRhZGF0YRIMCgRuYW1lGAEgASgJEhIKCmRlZmluaXRpb24YAiABKAkSEQoJc2lnbmF0dXJlGAMgASgJEhwKFGNoYXJhY3Rlcl9zZXRfY2xpZW50GAQgASgJEhwKFGNvbGxhdGlvbl9jb25uZWN0aW9uGAUgASgJEhoKEmRhdGFiYXNlX2NvbGxhdGlvbhgGIAEoCRIQCghzcWxfbW9kZRgHIAEoCRIPCgdjb21tZW50GAggASgJEjcKEWRlcGVuZGVuY3lfdGFibGVzGAkgAygLMhwuYnl0ZWJhc2UudjEuRGVwZW5kZW5jeVRhYmxlEhEKCXNraXBfZHVtcBgKIAEoCCLWAQoRUHJvY2VkdXJlTWV0YWRhdGESDAoEbmFtZRgBIAEoCRISCgpkZWZpbml0aW9uGAIgASgJEhEKCXNpZ25hdHVyZRgDIAEoCRIcChRjaGFyYWN0ZXJfc2V0X2NsaWVudBgEIAEoCRIcChRjb2xsYXRpb25fY29ubmVjdGlvbhgFIAEoCRIaChJkYXRhYmFzZV9jb2xsYXRpb24YBiABKAkSEAoIc3FsX21vZGUYByABKAkSDwoHY29tbWVudBgJIAEoCRIRCglza2lwX2R1bXAYCCABKAgiMwoPUGFja2FnZU1ldGFkYXRhEgwKBG5hbWUYASABKAkSEgoKZGVmaW5pdGlvbhgCIAEoCSKWAgoMVGFza01ldGFkYXRhEgwKBG5hbWUYASABKAkSCgoCaWQYAiABKAkSDQoFb3duZXIYAyABKAkSDwoHY29tbWVudBgEIAEoCRIRCgl3YXJlaG91c2UYBSABKAkSEAoIc2NoZWR1bGUYBiABKAkSFAoMcHJlZGVjZXNzb3JzGAcgAygJEi4KBXN0YXRlGAggASgOMh8uYnl0ZWJhc2UudjEuVGFza01ldGFkYXRhLlN0YXRlEhEKCWNvbmRpdGlvbhgJIAEoCRISCgpkZWZpbml0aW9uGAogASgJIjoKBVN0YXRlEhUKEVNUQVRFX1VOU1BFQ0lGSUVEEAASCwoHU1RBUlRFRBABEg0KCVNVU1BFTkRFRBACIssCCg5TdHJlYW1NZXRhZGF0YRIMCgRuYW1lGAEgASgJEhIKCnRhYmxlX25hbWUYAiABKAkSDQoFb3duZXIYAyABKAkSDwoHY29tbWVudBgEIAEoCRIuCgR0eXBlGAUgASgOMiAuYnl0ZWJhc2UudjEuU3RyZWFtTWV0YWRhdGEuVHlwZRINCgVzdGFsZRgGIAEoCBIuCgRtb2RlGAcgASgOMiAuYnl0ZWJhc2UudjEuU3RyZWFtTWV0YWRhdGEuTW9kZRISCgpkZWZpbml0aW9uGAggASgJIicKBFR5cGUSFAoQVFlQRV9VTlNQRUNJRklFRBAAEgkKBURFTFRBEAEiSwoETW9kZRIUChBNT0RFX1VOU1BFQ0lGSUVEEAASCwoHREVGQVVMVBABEg8KC0FQUEVORF9PTkxZEAISDwoLSU5TRVJUX09OTFkQAyK9AQoSU3BhdGlhbEluZGV4Q29uZmlnEg4KBm1ldGhvZBgBIAEoCRI1Cgx0ZXNzZWxsYXRpb24YAiABKAsyHy5ieXRlYmFzZS52MS5UZXNzZWxsYXRpb25Db25maWcSKwoHc3RvcmFnZRgDIAEoCzIaLmJ5dGViYXNlLnYxLlN0b3JhZ2VDb25maWcSMwoLZGltZW5zaW9uYWwYBCABKAsyHi5ieXRlYmFzZS52MS5EaW1lbnNpb25hbENvbmZpZyKbAQoSVGVzc2VsbGF0aW9uQ29uZmlnEg4KBnNjaGVtZRgBIAEoCRIrCgtncmlkX2xldmVscxgCIAMoCzIWLmJ5dGViYXNlLnYxLkdyaWRMZXZlbBIYChBjZWxsc19wZXJfb2JqZWN0GAMgASgFEi4KDGJvdW5kaW5nX2JveBgEIAEoCzIYLmJ5dGViYXNlLnYxLkJvdW5kaW5nQm94IisKCUdyaWRMZXZlbBINCgVsZXZlbBgBIAEoBRIPCgdkZW5zaXR5GAIgASgJIkUKC0JvdW5kaW5nQm94EgwKBHhtaW4YASABKAESDAoEeW1pbhgCIAEoARIMCgR4bWF4GAMgASgBEgwKBHltYXgYBCABKAEivgIKDVN0b3JhZ2VDb25maWcSEgoKZmlsbGZhY3RvchgBIAEoBRIRCglidWZmZXJpbmcYAiABKAkSEgoKdGFibGVzcGFjZRgDIAEoCRIXCg93b3JrX3RhYmxlc3BhY2UYBCABKAkSEQoJc2RvX2xldmVsGAUgASgFEhcKD2NvbW1pdF9pbnRlcnZhbBgGIAEoBRIRCglwYWRfaW5kZXgYByABKAgSFgoOc29ydF9pbl90ZW1wZGIYCCABKAkSFQoNZHJvcF9leGlzdGluZxgJIAEoCBIOCgZvbmxpbmUYCiABKAgSFwoPYWxsb3dfcm93X2xvY2tzGAsgASgIEhgKEGFsbG93X3BhZ2VfbG9ja3MYDCABKAgSDgoGbWF4ZG9wGA0gASgFEhgKEGRhdGFfY29tcHJlc3Npb24YDiABKAkifwoRRGltZW5zaW9uYWxDb25maWcSEgoKZGltZW5zaW9ucxgBIAEoBRIRCglkYXRhX3R5cGUYAiABKAkSDAoEc3JpZBgDIAEoBRI1Cgtjb25zdHJhaW50cxgEIAMoCzIgLmJ5dGViYXNlLnYxLkRpbWVuc2lvbkNvbnN0cmFpbnQiYQoTRGltZW5zaW9uQ29uc3RyYWludBIRCglkaW1lbnNpb24YASABKAkSEQoJbWluX3ZhbHVlGAIgASgBEhEKCW1heF92YWx1ZRgDIAEoARIRCgl0b2xlcmFuY2UYBCABKAEijQMKDUluZGV4TWV0YWRhdGESDAoEbmFtZRgBIAEoCRITCgtleHByZXNzaW9ucxgCIAMoCRISCgprZXlfbGVuZ3RoGAMgAygDEhIKCmRlc2NlbmRpbmcYBCADKAgSDAoEdHlwZRgFIAEoCRIOCgZ1bmlxdWUYBiABKAgSDwoHcHJpbWFyeRgHIAEoCBIPCgd2aXNpYmxlGAggASgIEg8KB2NvbW1lbnQYCSABKAkSEgoKZGVmaW5pdGlvbhgKIAEoCRIbChNwYXJlbnRfaW5kZXhfc2NoZW1hGAsgASgJEhkKEXBhcmVudF9pbmRleF9uYW1lGAwgASgJEhMKC2dyYW51bGFyaXR5GA0gASgDEhUKDWlzX2NvbnN0cmFpbnQYDiABKAgSNwoOc3BhdGlhbF9jb25maWcYDyABKAsyHy5ieXRlYmFzZS52MS5TcGF0aWFsSW5kZXhDb25maWcSFQoNb3BjbGFzc19uYW1lcxgQIAMoCRIYChBvcGNsYXNzX2RlZmF1bHRzGBEgAygIIlcKEUV4dGVuc2lvbk1ldGFkYXRhEgwKBG5hbWUYASABKAkSDgoGc2NoZW1hGAIgASgJEg8KB3ZlcnNpb24YAyABKAkSEwoLZGVzY3JpcHRpb24YBCABKAkivgEKEkZvcmVpZ25LZXlNZXRhZGF0YRIMCgRuYW1lGAEgASgJEg8KB2NvbHVtbnMYAiADKAkSGQoRcmVmZXJlbmNlZF9zY2hlbWEYAyABKAkSGAoQcmVmZXJlbmNlZF90YWJsZRgEIAEoCRIaChJyZWZlcmVuY2VkX2NvbHVtbnMYBSADKAkSEQoJb25fZGVsZXRlGAYgASgJEhEKCW9uX3VwZGF0ZRgHIAEoCRISCgptYXRjaF90eXBlGAggASgJIiAKDkRhdGFiYXNlU2NoZW1hEg4KBnNjaGVtYRgBIAEoCSI+ChFEYXRhYmFzZVNETFNjaGVtYRIOCgZzY2hlbWEYASABKAwSGQoMY29udGVudF90eXBlGAIgASgJQgPgQQMi8QIKFkdldFNjaGVtYVN0cmluZ1JlcXVlc3QSKwoEbmFtZRgBIAEoCUId4EEC+kEXChVieXRlYmFzZS5jb20vRGF0YWJhc2USPAoEdHlwZRgCIAEoDjIuLmJ5dGViYXNlLnYxLkdldFNjaGVtYVN0cmluZ1JlcXVlc3QuT2JqZWN0VHlwZRIOCgZzY2hlbWEYAyABKAkSDgoGb2JqZWN0GAQgASgJEi8KCG1ldGFkYXRhGAUgASgLMh0uYnl0ZWJhc2UudjEuRGF0YWJhc2VNZXRhZGF0YSKaAQoKT2JqZWN0VHlwZRIbChdPQkpFQ1RfVFlQRV9VTlNQRUNJRklFRBAAEgwKCERBVEFCQVNFEAESCgoGU0NIRU1BEAISCQoFVEFCTEUQAxIICgRWSUVXEAQSFQoRTUFURVJJQUxJWkVEX1ZJRVcQBRIMCghGVU5DVElPThAGEg0KCVBST0NFRFVSRRAHEgwKCFNFUVVFTkNFEAgiMAoXR2V0U2NoZW1hU3RyaW5nUmVzcG9uc2USFQoNc2NoZW1hX3N0cmluZxgBIAEoCSo9CgpTeW5jU3RhdHVzEhsKF1NZTkNfU1RBVFVTX1VOU1BFQ0lGSUVEEAASBgoCT0sQARIKCgZGQUlMRUQQAjLSGgoPRGF0YWJhc2VTZXJ2aWNlEsUBCgtHZXREYXRhYmFzZRIfLmJ5dGViYXNlLnYxLkdldERhdGFiYXNlUmVxdWVzdBoVLmJ5dGViYXNlLnYxLkRhdGFiYXNlIn7aQQRuYW1liuowEGJiLmRhdGFiYXNlcy5nZXSQ6jABoOowAYLT5JMCVVovEi0vdjEve25hbWU9cHJvamVjdHMvKi9pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKn0SIi92MS97bmFtZT1pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKn0SnQIKEUJhdGNoR2V0RGF0YWJhc2VzEiUuYnl0ZWJhc2UudjEuQmF0Y2hHZXREYXRhYmFzZXNSZXF1ZXN0GiYuYnl0ZWJhc2UudjEuQmF0Y2hHZXREYXRhYmFzZXNSZXNwb25zZSK4AYrqMBBiYi5kYXRhYmFzZXMuZ2V0kOowAqDqMAGC0+STApUBWi0SKy92MS97cGFyZW50PWluc3RhbmNlcy8qfS9kYXRhYmFzZXM6YmF0Y2hHZXRaOBI2L3YxL3twYXJlbnQ9cHJvamVjdHMvKi9pbnN0YW5jZXMvKn0vZGF0YWJhc2VzOmJhdGNoR2V0EiovdjEve3BhcmVudD1wcm9qZWN0cy8qfS9kYXRhYmFzZXM6YmF0Y2hHZXQSoQIKDUxpc3REYXRhYmFzZXMSIS5ieXRlYmFzZS52MS5MaXN0RGF0YWJhc2VzUmVxdWVzdBoiLmJ5dGViYXNlLnYxLkxpc3REYXRhYmFzZXNSZXNwb25zZSLIAdpBAIrqMBFiYi5kYXRhYmFzZXMubGlzdJDqMAKg6jABgtPkkwKhAVokEiIvdjEve3BhcmVudD1pbnN0YW5jZXMvKn0vZGF0YWJhc2VzWiUSIy92MS97cGFyZW50PXdvcmtzcGFjZXMvKn0vZGF0YWJhc2VzWi8SLS92MS97cGFyZW50PXByb2plY3RzLyovaW5zdGFuY2VzLyp9L2RhdGFiYXNlcxIhL3YxL3twYXJlbnQ9cHJvamVjdHMvKn0vZGF0YWJhc2VzEokCCg5VcGRhdGVEYXRhYmFzZRIiLmJ5dGViYXNlLnYxLlVwZGF0ZURhdGFiYXNlUmVxdWVzdBoVLmJ5dGViYXNlLnYxLkRhdGFiYXNlIrsB2kEUZGF0YWJhc2UsdXBkYXRlX21hc2uK6jATYmIuZGF0YWJhc2VzLnVwZGF0ZZDqMAGY6jABoOowAoLT5JMCezoIZGF0YWJhc2VaQjoIZGF0YWJhc2UyNi92MS97ZGF0YWJhc2UubmFtZT1wcm9qZWN0cy8qL2luc3RhbmNlcy8qL2RhdGFiYXNlcy8qfTIrL3YxL3tkYXRhYmFzZS5uYW1lPWluc3RhbmNlcy8qL2RhdGFiYXNlcy8qfRKKAgoUQmF0Y2hVcGRhdGVEYXRhYmFzZXMSKC5ieXRlYmFzZS52MS5CYXRjaFVwZGF0ZURhdGFiYXNlc1JlcXVlc3QaKS5ieXRlYmFzZS52MS5CYXRjaFVwZGF0ZURhdGFiYXNlc1Jlc3BvbnNlIpwBiuowE2JiLmRhdGFiYXNlcy51cGRhdGWQ6jABmOowAaDqMAKC0+STAnM6ASpaPjoBKiI5L3YxL3twYXJlbnQ9cHJvamVjdHMvKi9pbnN0YW5jZXMvKn0vZGF0YWJhc2VzOmJhdGNoVXBkYXRlIi4vdjEve3BhcmVudD1pbnN0YW5jZXMvKn0vZGF0YWJhc2VzOmJhdGNoVXBkYXRlEt4BCgxTeW5jRGF0YWJhc2USIC5ieXRlYmFzZS52MS5TeW5jRGF0YWJhc2VSZXF1ZXN0GiEuYnl0ZWJhc2UudjEuU3luY0RhdGFiYXNlUmVzcG9uc2UiiAGK6jARYmIuZGF0YWJhc2VzLnN5bmOQ6jABoOowAoLT5JMCZToBKlo3OgEqIjIvdjEve25hbWU9cHJvamVjdHMvKi9pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKn06c3luYyInL3YxL3tuYW1lPWluc3RhbmNlcy8qL2RhdGFiYXNlcy8qfTpzeW5jEvoBChJCYXRjaFN5bmNEYXRhYmFzZXMSJi5ieXRlYmFzZS52MS5CYXRjaFN5bmNEYXRhYmFzZXNSZXF1ZXN0GicuYnl0ZWJhc2UudjEuQmF0Y2hTeW5jRGF0YWJhc2VzUmVzcG9uc2UikgGK6jARYmIuZGF0YWJhc2VzLnN5bmOQ6jABoOowAoLT5JMCbzoBKlo8OgEqIjcvdjEve3BhcmVudD1wcm9qZWN0cy8qL2luc3RhbmNlcy8qfS9kYXRhYmFzZXM6YmF0Y2hTeW5jIiwvdjEve3BhcmVudD1pbnN0YW5jZXMvKn0vZGF0YWJhc2VzOmJhdGNoU3luYxLvAQoTR2V0RGF0YWJhc2VNZXRhZGF0YRInLmJ5dGViYXNlLnYxLkdldERhdGFiYXNlTWV0YWRhdGFSZXF1ZXN0Gh0uYnl0ZWJhc2UudjEuRGF0YWJhc2VNZXRhZGF0YSKPAYrqMBZiYi5kYXRhYmFzZXMuZ2V0U2NoZW1hkOowAaDqMAGC0+STAmdaOBI2L3YxL3tuYW1lPXByb2plY3RzLyovaW5zdGFuY2VzLyovZGF0YWJhc2VzLyovbWV0YWRhdGF9EisvdjEve25hbWU9aW5zdGFuY2VzLyovZGF0YWJhc2VzLyovbWV0YWRhdGF9EuUBChFHZXREYXRhYmFzZVNjaGVtYRIlLmJ5dGViYXNlLnYxLkdldERhdGFiYXNlU2NoZW1hUmVxdWVzdBobLmJ5dGViYXNlLnYxLkRhdGFiYXNlU2NoZW1hIosBiuowFmJiLmRhdGFiYXNlcy5nZXRTY2hlbWGQ6jABoOowAYLT5JMCY1o2EjQvdjEve25hbWU9cHJvamVjdHMvKi9pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKi9zY2hlbWF9EikvdjEve25hbWU9aW5zdGFuY2VzLyovZGF0YWJhc2VzLyovc2NoZW1hfRL0AQoUR2V0RGF0YWJhc2VTRExTY2hlbWESKC5ieXRlYmFzZS52MS5HZXREYXRhYmFzZVNETFNjaGVtYVJlcXVlc3QaHi5ieXRlYmFzZS52MS5EYXRhYmFzZVNETFNjaGVtYSKRAYrqMBZiYi5kYXRhYmFzZXMuZ2V0U2NoZW1hkOowAaDqMAGC0+STAmlaORI3L3YxL3tuYW1lPXByb2plY3RzLyovaW5zdGFuY2VzLyovZGF0YWJhc2VzLyovc2RsU2NoZW1hfRIsL3YxL3tuYW1lPWluc3RhbmNlcy8qL2RhdGFiYXNlcy8qL3NkbFNjaGVtYX0S8QIKCkRpZmZTY2hlbWESHi5ieXRlYmFzZS52MS5EaWZmU2NoZW1hUmVxdWVzdBofLmJ5dGViYXNlLnYxLkRpZmZTY2hlbWFSZXNwb25zZSKhAorqMBBiYi5kYXRhYmFzZXMuZ2V0kOowAaDqMAKC0+STAv4BOgEqWj06ASoiOC92MS97bmFtZT1wcm9qZWN0cy8qL2luc3RhbmNlcy8qL2RhdGFiYXNlcy8qfTpkaWZmU2NoZW1hWj86ASoiOi92MS97bmFtZT1pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKi9jaGFuZ2Vsb2dzLyp9OmRpZmZTY2hlbWFaSjoBKiJFL3YxL3tuYW1lPXByb2plY3RzLyovaW5zdGFuY2VzLyovZGF0YWJhc2VzLyovY2hhbmdlbG9ncy8qfTpkaWZmU2NoZW1hIi0vdjEve25hbWU9aW5zdGFuY2VzLyovZGF0YWJhc2VzLyp9OmRpZmZTY2hlbWES9gEKDERpZmZNZXRhZGF0YRIgLmJ5dGViYXNlLnYxLkRpZmZNZXRhZGF0YVJlcXVlc3QaIS5ieXRlYmFzZS52MS5EaWZmTWV0YWRhdGFSZXNwb25zZSKgAYrqMBliYi5kYXRhYmFzZXMuZGlmZk1ldGFkYXRhkOowAaDqMAKC0+STAnU6ASpaPzoBKiI6L3YxL3tuYW1lPXByb2plY3RzLyovaW5zdGFuY2VzLyovZGF0YWJhc2VzLyp9OmRpZmZNZXRhZGF0YSIvL3YxL3tuYW1lPWluc3RhbmNlcy8qL2RhdGFiYXNlcy8qfTpkaWZmTWV0YWRhdGES/QEKD0dldFNjaGVtYVN0cmluZxIjLmJ5dGViYXNlLnYxLkdldFNjaGVtYVN0cmluZ1JlcXVlc3QaJC5ieXRlYmFzZS52MS5HZXRTY2hlbWFTdHJpbmdSZXNwb25zZSKeAdpBBG5hbWWK6jAWYmIuZGF0YWJhc2VzLmdldFNjaGVtYZDqMAGg6jABgtPkkwJvWjwSOi92MS97bmFtZT1wcm9qZWN0cy8qL2luc3RhbmNlcy8qL2RhdGFiYXNlcy8qL3NjaGVtYVN0cmluZ30SLy92MS97bmFtZT1pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKi9zY2hlbWFTdHJpbmd9QqoBCg9jb20uYnl0ZWJhc2UudjFCFERhdGFiYXNlU2VydmljZVByb3RvUAFaNGdpdGh1Yi5jb20vYnl0ZWJhc2UvYnl0ZWJhc2UvYmFja2VuZC9nZW5lcmF0ZWQtZ28vdjGiAgNCWFiqAgtCeXRlYmFzZS5WMcoCC0J5dGViYXNlXFYx4gIXQnl0ZWJhc2VcVjFcR1BCTWV0YWRhdGHqAgxCeXRlYmFzZTo6VjFiBnByb3RvMw", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_instance_service]);+ fileDesc("Chl2MS9kYXRhYmFzZV9zZXJ2aWNlLnByb3RvEgtieXRlYmFzZS52MSJBChJHZXREYXRhYmFzZVJlcXVlc3QSKwoEbmFtZRgBIAEoCUId4EEC+kEXChVieXRlYmFzZS5jb20vRGF0YWJhc2UidwoYQmF0Y2hHZXREYXRhYmFzZXNSZXF1ZXN0Ei0KBnBhcmVudBgBIAEoCUId4EEC+kEXEhVieXRlYmFzZS5jb20vRGF0YWJhc2USLAoFbmFtZXMYAiADKAlCHeBBAvpBFwoVYnl0ZWJhc2UuY29tL0RhdGFiYXNlIkUKGUJhdGNoR2V0RGF0YWJhc2VzUmVzcG9uc2USKAoJZGF0YWJhc2VzGAEgAygLMhUuYnl0ZWJhc2UudjEuRGF0YWJhc2UipAEKFExpc3REYXRhYmFzZXNSZXF1ZXN0Ei0KBnBhcmVudBgBIAEoCUId4EEC+kEXEhVieXRlYmFzZS5jb20vRGF0YWJhc2USEQoJcGFnZV9zaXplGAIgASgFEhIKCnBhZ2VfdG9rZW4YAyABKAkSDgoGZmlsdGVyGAQgASgJEhQKDHNob3dfZGVsZXRlZBgFIAEoCBIQCghvcmRlcl9ieRgGIAEoCSJaChVMaXN0RGF0YWJhc2VzUmVzcG9uc2USKAoJZGF0YWJhc2VzGAEgAygLMhUuYnl0ZWJhc2UudjEuRGF0YWJhc2USFwoPbmV4dF9wYWdlX3Rva2VuGAIgASgJInYKFVVwZGF0ZURhdGFiYXNlUmVxdWVzdBIsCghkYXRhYmFzZRgBIAEoCzIVLmJ5dGViYXNlLnYxLkRhdGFiYXNlQgPgQQISLwoLdXBkYXRlX21hc2sYAiABKAsyGi5nb29nbGUucHJvdG9idWYuRmllbGRNYXNrImgKG0JhdGNoVXBkYXRlRGF0YWJhc2VzUmVxdWVzdBIOCgZwYXJlbnQYASABKAkSOQoIcmVxdWVzdHMYAiADKAsyIi5ieXRlYmFzZS52MS5VcGRhdGVEYXRhYmFzZVJlcXVlc3RCA+BBAiJIChxCYXRjaFVwZGF0ZURhdGFiYXNlc1Jlc3BvbnNlEigKCWRhdGFiYXNlcxgBIAMoCzIVLmJ5dGViYXNlLnYxLkRhdGFiYXNlIlkKGUJhdGNoU3luY0RhdGFiYXNlc1JlcXVlc3QSDgoGcGFyZW50GAEgASgJEiwKBW5hbWVzGAIgAygJQh3gQQL6QRcKFWJ5dGViYXNlLmNvbS9EYXRhYmFzZSIcChpCYXRjaFN5bmNEYXRhYmFzZXNSZXNwb25zZSJCChNTeW5jRGF0YWJhc2VSZXF1ZXN0EisKBG5hbWUYASABKAlCHeBBAvpBFwoVYnl0ZWJhc2UuY29tL0RhdGFiYXNlIhYKFFN5bmNEYXRhYmFzZVJlc3BvbnNlInAKGkdldERhdGFiYXNlTWV0YWRhdGFSZXF1ZXN0EjMKBG5hbWUYASABKAlCJeBBAvpBHwodYnl0ZWJhc2UuY29tL0RhdGFiYXNlTWV0YWRhdGESDgoGZmlsdGVyGAIgASgJEg0KBWxpbWl0GAMgASgFIk0KGEdldERhdGFiYXNlU2NoZW1hUmVxdWVzdBIxCgRuYW1lGAEgASgJQiPgQQL6QR0KG2J5dGViYXNlLmNvbS9EYXRhYmFzZVNjaGVtYSLYAQobR2V0RGF0YWJhc2VTRExTY2hlbWFSZXF1ZXN0EisKBG5hbWUYASABKAlCHeBBAvpBFwoVYnl0ZWJhc2UuY29tL0RhdGFiYXNlEkIKBmZvcm1hdBgCIAEoDjIyLmJ5dGViYXNlLnYxLkdldERhdGFiYXNlU0RMU2NoZW1hUmVxdWVzdC5TRExGb3JtYXQiSAoJU0RMRm9ybWF0EhoKFlNETF9GT1JNQVRfVU5TUEVDSUZJRUQQABIPCgtTSU5HTEVfRklMRRABEg4KCk1VTFRJX0ZJTEUQAiJxChFEaWZmU2NoZW1hUmVxdWVzdBIrCgRuYW1lGAEgASgJQh3gQQL6QRcKFWJ5dGViYXNlLmNvbS9EYXRhYmFzZRIQCgZzY2hlbWEYAiABKAlIABITCgljaGFuZ2Vsb2cYAyABKAlIAEIICgZ0YXJnZXQiIgoSRGlmZlNjaGVtYVJlc3BvbnNlEgwKBGRpZmYYASABKAkifwoTRGlmZk1ldGFkYXRhUmVxdWVzdBIrCgRuYW1lGAEgASgJQh3gQQL6QRcKFWJ5dGViYXNlLmNvbS9EYXRhYmFzZRI7Cg90YXJnZXRfbWV0YWRhdGEYAiABKAsyHS5ieXRlYmFzZS52MS5EYXRhYmFzZU1ldGFkYXRhQgPgQQIiJAoURGlmZk1ldGFkYXRhUmVzcG9uc2USDAoEZGlmZhgBIAEoCSKrBQoIRGF0YWJhc2USDAoEbmFtZRgBIAEoCRImCgVzdGF0ZRgCIAEoDjISLmJ5dGViYXNlLnYxLlN0YXRlQgPgQQMSPQoUc3VjY2Vzc2Z1bF9zeW5jX3RpbWUYAyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSDwoHcHJvamVjdBgEIAEoCRIUCgdyZWxlYXNlGAUgASgJQgPgQQMSHQoLZW52aXJvbm1lbnQYBiABKAlCA+BBAUgAiAEBEicKFWVmZmVjdGl2ZV9lbnZpcm9ubWVudBgHIAEoCUID4EEDSAGIAQESMQoGbGFiZWxzGAggAygLMiEuYnl0ZWJhc2UudjEuRGF0YWJhc2UuTGFiZWxzRW50cnkSPQoRaW5zdGFuY2VfcmVzb3VyY2UYCSABKAsyHS5ieXRlYmFzZS52MS5JbnN0YW5jZVJlc291cmNlQgPgQQMSHQoQYmFja3VwX2F2YWlsYWJsZRgKIAEoCEID4EEDEjEKC3N5bmNfc3RhdHVzGAsgASgOMhcuYnl0ZWJhc2UudjEuU3luY1N0YXR1c0ID4EEDEhcKCnN5bmNfZXJyb3IYDCABKAlCA+BBAxotCgtMYWJlbHNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBOoQB6kGAAQoVYnl0ZWJhc2UuY29tL0RhdGFiYXNlEilpbnN0YW5jZXMve2luc3RhbmNlfS9kYXRhYmFzZXMve2RhdGFiYXNlfRI8cHJvamVjdHMve3Byb2plY3R9L2luc3RhbmNlcy97aW5zdGFuY2V9L2RhdGFiYXNlcy97ZGF0YWJhc2V9Qg4KDF9lbnZpcm9ubWVudEIYChZfZWZmZWN0aXZlX2Vudmlyb25tZW50IvECChBEYXRhYmFzZU1ldGFkYXRhEgwKBG5hbWUYASABKAkSLAoHc2NoZW1hcxgCIAMoCzIbLmJ5dGViYXNlLnYxLlNjaGVtYU1ldGFkYXRhEhUKDWNoYXJhY3Rlcl9zZXQYAyABKAkSEQoJY29sbGF0aW9uGAQgASgJEjIKCmV4dGVuc2lvbnMYBSADKAsyHi5ieXRlYmFzZS52MS5FeHRlbnNpb25NZXRhZGF0YRINCgVvd25lchgGIAEoCRITCgtzZWFyY2hfcGF0aBgHIAEoCTqeAepBmgEKHWJ5dGViYXNlLmNvbS9EYXRhYmFzZU1ldGFkYXRhEjJpbnN0YW5jZXMve2luc3RhbmNlfS9kYXRhYmFzZXMve2RhdGFiYXNlfS9tZXRhZGF0YRJFcHJvamVjdHMve3Byb2plY3R9L2luc3RhbmNlcy97aW5zdGFuY2V9L2RhdGFiYXNlcy97ZGF0YWJhc2V9L21ldGFkYXRhIuMFCg5TY2hlbWFNZXRhZGF0YRIMCgRuYW1lGAEgASgJEioKBnRhYmxlcxgCIAMoCzIaLmJ5dGViYXNlLnYxLlRhYmxlTWV0YWRhdGESOwoPZXh0ZXJuYWxfdGFibGVzGAMgAygLMiIuYnl0ZWJhc2UudjEuRXh0ZXJuYWxUYWJsZU1ldGFkYXRhEigKBXZpZXdzGAQgAygLMhkuYnl0ZWJhc2UudjEuVmlld01ldGFkYXRhEjAKCWZ1bmN0aW9ucxgFIAMoCzIdLmJ5dGViYXNlLnYxLkZ1bmN0aW9uTWV0YWRhdGESMgoKcHJvY2VkdXJlcxgGIAMoCzIeLmJ5dGViYXNlLnYxLlByb2NlZHVyZU1ldGFkYXRhEiwKB3N0cmVhbXMYByADKAsyGy5ieXRlYmFzZS52MS5TdHJlYW1NZXRhZGF0YRIoCgV0YXNrcxgIIAMoCzIZLmJ5dGViYXNlLnYxLlRhc2tNZXRhZGF0YRJBChJtYXRlcmlhbGl6ZWRfdmlld3MYCSADKAsyJS5ieXRlYmFzZS52MS5NYXRlcmlhbGl6ZWRWaWV3TWV0YWRhdGESLgoIcGFja2FnZXMYCiADKAsyHC5ieXRlYmFzZS52MS5QYWNrYWdlTWV0YWRhdGESDQoFb3duZXIYCyABKAkSMAoJc2VxdWVuY2VzGAwgAygLMh0uYnl0ZWJhc2UudjEuU2VxdWVuY2VNZXRhZGF0YRIqCgZldmVudHMYDSADKAsyGi5ieXRlYmFzZS52MS5FdmVudE1ldGFkYXRhEjEKCmVudW1fdHlwZXMYDiADKAsyHS5ieXRlYmFzZS52MS5FbnVtVHlwZU1ldGFkYXRhEhEKCXNraXBfZHVtcBgPIAEoCBIPCgdjb21tZW50GBAgASgJEjsKD2NvbXBvc2l0ZV90eXBlcxgRIAMoCzIiLmJ5dGViYXNlLnYxLkNvbXBvc2l0ZVR5cGVNZXRhZGF0YSJUChBFbnVtVHlwZU1ldGFkYXRhEgwKBG5hbWUYASABKAkSDgoGdmFsdWVzGAIgAygJEg8KB2NvbW1lbnQYAyABKAkSEQoJc2tpcF9kdW1wGAQgASgIIm8KFUNvbXBvc2l0ZVR5cGVNZXRhZGF0YRIMCgRuYW1lGAEgASgJEjcKCmF0dHJpYnV0ZXMYAiADKAsyIy5ieXRlYmFzZS52MS5Db21wb3NpdGVUeXBlQXR0cmlidXRlEg8KB2NvbW1lbnQYAyABKAkiWAoWQ29tcG9zaXRlVHlwZUF0dHJpYnV0ZRIMCgRuYW1lGAEgASgJEgwKBHR5cGUYAiABKAkSEQoJY29sbGF0aW9uGAMgASgJEg8KB2NvbW1lbnQYBCABKAkiowEKDUV2ZW50TWV0YWRhdGESDAoEbmFtZRgBIAEoCRISCgpkZWZpbml0aW9uGAIgASgJEhEKCXRpbWVfem9uZRgDIAEoCRIQCghzcWxfbW9kZRgEIAEoCRIcChRjaGFyYWN0ZXJfc2V0X2NsaWVudBgFIAEoCRIcChRjb2xsYXRpb25fY29ubmVjdGlvbhgGIAEoCRIPCgdjb21tZW50GAcgASgJIoECChBTZXF1ZW5jZU1ldGFkYXRhEgwKBG5hbWUYASABKAkSEQoJZGF0YV90eXBlGAIgASgJEg0KBXN0YXJ0GAMgASgJEhEKCW1pbl92YWx1ZRgEIAEoCRIRCgltYXhfdmFsdWUYBSABKAkSEQoJaW5jcmVtZW50GAYgASgJEg0KBWN5Y2xlGAcgASgIEhIKCmNhY2hlX3NpemUYCCABKAkSEgoKbGFzdF92YWx1ZRgJIAEoCRITCgtvd25lcl90YWJsZRgKIAEoCRIUCgxvd25lcl9jb2x1bW4YCyABKAkSDwoHY29tbWVudBgMIAEoCRIRCglza2lwX2R1bXAYDSABKAgivgEKD1RyaWdnZXJNZXRhZGF0YRIMCgRuYW1lGAEgASgJEg0KBWV2ZW50GAIgASgJEg4KBnRpbWluZxgDIAEoCRIMCgRib2R5GAQgASgJEhAKCHNxbF9tb2RlGAUgASgJEhwKFGNoYXJhY3Rlcl9zZXRfY2xpZW50GAYgASgJEhwKFGNvbGxhdGlvbl9jb25uZWN0aW9uGAcgASgJEg8KB2NvbW1lbnQYCCABKAkSEQoJc2tpcF9kdW1wGAkgASgIIpEBChVFeHRlcm5hbFRhYmxlTWV0YWRhdGESDAoEbmFtZRgBIAEoCRIcChRleHRlcm5hbF9zZXJ2ZXJfbmFtZRgCIAEoCRIeChZleHRlcm5hbF9kYXRhYmFzZV9uYW1lGAMgASgJEiwKB2NvbHVtbnMYBCADKAsyGy5ieXRlYmFzZS52MS5Db2x1bW5NZXRhZGF0YSLsBAoNVGFibGVNZXRhZGF0YRIMCgRuYW1lGAEgASgJEiwKB2NvbHVtbnMYAiADKAsyGy5ieXRlYmFzZS52MS5Db2x1bW5NZXRhZGF0YRIrCgdpbmRleGVzGAMgAygLMhouYnl0ZWJhc2UudjEuSW5kZXhNZXRhZGF0YRIOCgZlbmdpbmUYBCABKAkSEQoJY29sbGF0aW9uGAUgASgJEg8KB2NoYXJzZXQYBiABKAkSEQoJcm93X2NvdW50GAcgASgDEhEKCWRhdGFfc2l6ZRgIIAEoAxISCgppbmRleF9zaXplGAkgASgDEhEKCWRhdGFfZnJlZRgKIAEoAxIWCg5jcmVhdGVfb3B0aW9ucxgLIAEoCRIPCgdjb21tZW50GAwgASgJEjUKDGZvcmVpZ25fa2V5cxgNIAMoCzIfLmJ5dGViYXNlLnYxLkZvcmVpZ25LZXlNZXRhZGF0YRI3CgpwYXJ0aXRpb25zGA4gAygLMiMuYnl0ZWJhc2UudjEuVGFibGVQYXJ0aXRpb25NZXRhZGF0YRI/ChFjaGVja19jb25zdHJhaW50cxgPIAMoCzIkLmJ5dGViYXNlLnYxLkNoZWNrQ29uc3RyYWludE1ldGFkYXRhEg0KBW93bmVyGBAgASgJEhQKDHNvcnRpbmdfa2V5cxgRIAMoCRIuCgh0cmlnZ2VycxgSIAMoCzIcLmJ5dGViYXNlLnYxLlRyaWdnZXJNZXRhZGF0YRIRCglza2lwX2R1bXAYEyABKAgSFQoNc2hhcmRpbmdfaW5mbxgUIAEoCRIYChBwcmltYXJ5X2tleV90eXBlGBUgASgJIjsKF0NoZWNrQ29uc3RyYWludE1ldGFkYXRhEgwKBG5hbWUYASABKAkSEgoKZXhwcmVzc2lvbhgCIAEoCSLNAwoWVGFibGVQYXJ0aXRpb25NZXRhZGF0YRIMCgRuYW1lGAEgASgJEjYKBHR5cGUYAiABKA4yKC5ieXRlYmFzZS52MS5UYWJsZVBhcnRpdGlvbk1ldGFkYXRhLlR5cGUSEgoKZXhwcmVzc2lvbhgDIAEoCRINCgV2YWx1ZRgEIAEoCRITCgt1c2VfZGVmYXVsdBgFIAEoCRI6Cg1zdWJwYXJ0aXRpb25zGAYgAygLMiMuYnl0ZWJhc2UudjEuVGFibGVQYXJ0aXRpb25NZXRhZGF0YRIrCgdpbmRleGVzGAcgAygLMhouYnl0ZWJhc2UudjEuSW5kZXhNZXRhZGF0YRI/ChFjaGVja19jb25zdHJhaW50cxgIIAMoCzIkLmJ5dGViYXNlLnYxLkNoZWNrQ29uc3RyYWludE1ldGFkYXRhIooBCgRUeXBlEhQKEFRZUEVfVU5TUEVDSUZJRUQQABIJCgVSQU5HRRABEhEKDVJBTkdFX0NPTFVNTlMQAhIICgRMSVNUEAMSEAoMTElTVF9DT0xVTU5TEAQSCAoESEFTSBAFEg8KC0xJTkVBUl9IQVNIEAYSBwoDS0VZEAcSDgoKTElORUFSX0tFWRAIItEECg5Db2x1bW5NZXRhZGF0YRIMCgRuYW1lGAEgASgJEhAKCHBvc2l0aW9uGAIgASgFEhMKC2hhc19kZWZhdWx0GAMgASgIEg8KB2RlZmF1bHQYBCABKAkSFwoPZGVmYXVsdF9vbl9udWxsGAUgASgIEhEKCW9uX3VwZGF0ZRgGIAEoCRIQCghudWxsYWJsZRgHIAEoCBIMCgR0eXBlGAggASgJEhUKDWNoYXJhY3Rlcl9zZXQYCSABKAkSEQoJY29sbGF0aW9uGAogASgJEg8KB2NvbW1lbnQYCyABKAkSMwoKZ2VuZXJhdGlvbhgMIAEoCzIfLmJ5dGViYXNlLnYxLkdlbmVyYXRpb25NZXRhZGF0YRITCgtpc19pZGVudGl0eRgNIAEoCBJLChNpZGVudGl0eV9nZW5lcmF0aW9uGA4gASgOMi4uYnl0ZWJhc2UudjEuQ29sdW1uTWV0YWRhdGEuSWRlbnRpdHlHZW5lcmF0aW9uEhUKDWlkZW50aXR5X3NlZWQYDyABKAMSGgoSaWRlbnRpdHlfaW5jcmVtZW50GBAgASgDEh8KF2RlZmF1bHRfY29uc3RyYWludF9uYW1lGBEgASgJEhEKBHNyaWQYEiABKA1IAIgBARIUCgxpc19pbnZpc2libGUYEyABKAgiVQoSSWRlbnRpdHlHZW5lcmF0aW9uEiMKH0lERU5USVRZX0dFTkVSQVRJT05fVU5TUEVDSUZJRUQQABIKCgZBTFdBWVMQARIOCgpCWV9ERUZBVUxUEAJCBwoFX3NyaWQikwEKEkdlbmVyYXRpb25NZXRhZGF0YRIyCgR0eXBlGAEgASgOMiQuYnl0ZWJhc2UudjEuR2VuZXJhdGlvbk1ldGFkYXRhLlR5cGUSEgoKZXhwcmVzc2lvbhgCIAEoCSI1CgRUeXBlEhQKEFRZUEVfVU5TUEVDSUZJRUQQABILCgdWSVJUVUFMEAESCgoGU1RPUkVEEAIi7QEKDFZpZXdNZXRhZGF0YRIMCgRuYW1lGAEgASgJEhIKCmRlZmluaXRpb24YAiABKAkSDwoHY29tbWVudBgDIAEoCRI5ChJkZXBlbmRlbmN5X2NvbHVtbnMYBCADKAsyHS5ieXRlYmFzZS52MS5EZXBlbmRlbmN5Q29sdW1uEiwKB2NvbHVtbnMYBSADKAsyGy5ieXRlYmFzZS52MS5Db2x1bW5NZXRhZGF0YRIuCgh0cmlnZ2VycxgGIAMoCzIcLmJ5dGViYXNlLnYxLlRyaWdnZXJNZXRhZGF0YRIRCglza2lwX2R1bXAYByABKAgiQQoQRGVwZW5kZW5jeUNvbHVtbhIOCgZzY2hlbWEYASABKAkSDQoFdGFibGUYAiABKAkSDgoGY29sdW1uGAMgASgJIvgBChhNYXRlcmlhbGl6ZWRWaWV3TWV0YWRhdGESDAoEbmFtZRgBIAEoCRISCgpkZWZpbml0aW9uGAIgASgJEg8KB2NvbW1lbnQYAyABKAkSOQoSZGVwZW5kZW5jeV9jb2x1bW5zGAQgAygLMh0uYnl0ZWJhc2UudjEuRGVwZW5kZW5jeUNvbHVtbhIuCgh0cmlnZ2VycxgFIAMoCzIcLmJ5dGViYXNlLnYxLlRyaWdnZXJNZXRhZGF0YRIrCgdpbmRleGVzGAYgAygLMhouYnl0ZWJhc2UudjEuSW5kZXhNZXRhZGF0YRIRCglza2lwX2R1bXAYByABKAgiMAoPRGVwZW5kZW5jeVRhYmxlEg4KBnNjaGVtYRgBIAEoCRINCgV0YWJsZRgCIAEoCSKOAgoQRnVuY3Rpb25NZXRhZGF0YRIMCgRuYW1lGAEgASgJEhIKCmRlZmluaXRpb24YAiABKAkSEQoJc2lnbmF0dXJlGAMgASgJEhwKFGNoYXJhY3Rlcl9zZXRfY2xpZW50GAQgASgJEhwKFGNvbGxhdGlvbl9jb25uZWN0aW9uGAUgASgJEhoKEmRhdGFiYXNlX2NvbGxhdGlvbhgGIAEoCRIQCghzcWxfbW9kZRgHIAEoCRIPCgdjb21tZW50GAggASgJEjcKEWRlcGVuZGVuY3lfdGFibGVzGAkgAygLMhwuYnl0ZWJhc2UudjEuRGVwZW5kZW5jeVRhYmxlEhEKCXNraXBfZHVtcBgKIAEoCCLWAQoRUHJvY2VkdXJlTWV0YWRhdGESDAoEbmFtZRgBIAEoCRISCgpkZWZpbml0aW9uGAIgASgJEhEKCXNpZ25hdHVyZRgDIAEoCRIcChRjaGFyYWN0ZXJfc2V0X2NsaWVudBgEIAEoCRIcChRjb2xsYXRpb25fY29ubmVjdGlvbhgFIAEoCRIaChJkYXRhYmFzZV9jb2xsYXRpb24YBiABKAkSEAoIc3FsX21vZGUYByABKAkSDwoHY29tbWVudBgJIAEoCRIRCglza2lwX2R1bXAYCCABKAgiMwoPUGFja2FnZU1ldGFkYXRhEgwKBG5hbWUYASABKAkSEgoKZGVmaW5pdGlvbhgCIAEoCSKWAgoMVGFza01ldGFkYXRhEgwKBG5hbWUYASABKAkSCgoCaWQYAiABKAkSDQoFb3duZXIYAyABKAkSDwoHY29tbWVudBgEIAEoCRIRCgl3YXJlaG91c2UYBSABKAkSEAoIc2NoZWR1bGUYBiABKAkSFAoMcHJlZGVjZXNzb3JzGAcgAygJEi4KBXN0YXRlGAggASgOMh8uYnl0ZWJhc2UudjEuVGFza01ldGFkYXRhLlN0YXRlEhEKCWNvbmRpdGlvbhgJIAEoCRISCgpkZWZpbml0aW9uGAogASgJIjoKBVN0YXRlEhUKEVNUQVRFX1VOU1BFQ0lGSUVEEAASCwoHU1RBUlRFRBABEg0KCVNVU1BFTkRFRBACIssCCg5TdHJlYW1NZXRhZGF0YRIMCgRuYW1lGAEgASgJEhIKCnRhYmxlX25hbWUYAiABKAkSDQoFb3duZXIYAyABKAkSDwoHY29tbWVudBgEIAEoCRIuCgR0eXBlGAUgASgOMiAuYnl0ZWJhc2UudjEuU3RyZWFtTWV0YWRhdGEuVHlwZRINCgVzdGFsZRgGIAEoCBIuCgRtb2RlGAcgASgOMiAuYnl0ZWJhc2UudjEuU3RyZWFtTWV0YWRhdGEuTW9kZRISCgpkZWZpbml0aW9uGAggASgJIicKBFR5cGUSFAoQVFlQRV9VTlNQRUNJRklFRBAAEgkKBURFTFRBEAEiSwoETW9kZRIUChBNT0RFX1VOU1BFQ0lGSUVEEAASCwoHREVGQVVMVBABEg8KC0FQUEVORF9PTkxZEAISDwoLSU5TRVJUX09OTFkQAyK9AQoSU3BhdGlhbEluZGV4Q29uZmlnEg4KBm1ldGhvZBgBIAEoCRI1Cgx0ZXNzZWxsYXRpb24YAiABKAsyHy5ieXRlYmFzZS52MS5UZXNzZWxsYXRpb25Db25maWcSKwoHc3RvcmFnZRgDIAEoCzIaLmJ5dGViYXNlLnYxLlN0b3JhZ2VDb25maWcSMwoLZGltZW5zaW9uYWwYBCABKAsyHi5ieXRlYmFzZS52MS5EaW1lbnNpb25hbENvbmZpZyKbAQoSVGVzc2VsbGF0aW9uQ29uZmlnEg4KBnNjaGVtZRgBIAEoCRIrCgtncmlkX2xldmVscxgCIAMoCzIWLmJ5dGViYXNlLnYxLkdyaWRMZXZlbBIYChBjZWxsc19wZXJfb2JqZWN0GAMgASgFEi4KDGJvdW5kaW5nX2JveBgEIAEoCzIYLmJ5dGViYXNlLnYxLkJvdW5kaW5nQm94IisKCUdyaWRMZXZlbBINCgVsZXZlbBgBIAEoBRIPCgdkZW5zaXR5GAIgASgJIkUKC0JvdW5kaW5nQm94EgwKBHhtaW4YASABKAESDAoEeW1pbhgCIAEoARIMCgR4bWF4GAMgASgBEgwKBHltYXgYBCABKAEivgIKDVN0b3JhZ2VDb25maWcSEgoKZmlsbGZhY3RvchgBIAEoBRIRCglidWZmZXJpbmcYAiABKAkSEgoKdGFibGVzcGFjZRgDIAEoCRIXCg93b3JrX3RhYmxlc3BhY2UYBCABKAkSEQoJc2RvX2xldmVsGAUgASgFEhcKD2NvbW1pdF9pbnRlcnZhbBgGIAEoBRIRCglwYWRfaW5kZXgYByABKAgSFgoOc29ydF9pbl90ZW1wZGIYCCABKAkSFQoNZHJvcF9leGlzdGluZxgJIAEoCBIOCgZvbmxpbmUYCiABKAgSFwoPYWxsb3dfcm93X2xvY2tzGAsgASgIEhgKEGFsbG93X3BhZ2VfbG9ja3MYDCABKAgSDgoGbWF4ZG9wGA0gASgFEhgKEGRhdGFfY29tcHJlc3Npb24YDiABKAkifwoRRGltZW5zaW9uYWxDb25maWcSEgoKZGltZW5zaW9ucxgBIAEoBRIRCglkYXRhX3R5cGUYAiABKAkSDAoEc3JpZBgDIAEoBRI1Cgtjb25zdHJhaW50cxgEIAMoCzIgLmJ5dGViYXNlLnYxLkRpbWVuc2lvbkNvbnN0cmFpbnQiYQoTRGltZW5zaW9uQ29uc3RyYWludBIRCglkaW1lbnNpb24YASABKAkSEQoJbWluX3ZhbHVlGAIgASgBEhEKCW1heF92YWx1ZRgDIAEoARIRCgl0b2xlcmFuY2UYBCABKAEijQMKDUluZGV4TWV0YWRhdGESDAoEbmFtZRgBIAEoCRITCgtleHByZXNzaW9ucxgCIAMoCRISCgprZXlfbGVuZ3RoGAMgAygDEhIKCmRlc2NlbmRpbmcYBCADKAgSDAoEdHlwZRgFIAEoCRIOCgZ1bmlxdWUYBiABKAgSDwoHcHJpbWFyeRgHIAEoCBIPCgd2aXNpYmxlGAggASgIEg8KB2NvbW1lbnQYCSABKAkSEgoKZGVmaW5pdGlvbhgKIAEoCRIbChNwYXJlbnRfaW5kZXhfc2NoZW1hGAsgASgJEhkKEXBhcmVudF9pbmRleF9uYW1lGAwgASgJEhMKC2dyYW51bGFyaXR5GA0gASgDEhUKDWlzX2NvbnN0cmFpbnQYDiABKAgSNwoOc3BhdGlhbF9jb25maWcYDyABKAsyHy5ieXRlYmFzZS52MS5TcGF0aWFsSW5kZXhDb25maWcSFQoNb3BjbGFzc19uYW1lcxgQIAMoCRIYChBvcGNsYXNzX2RlZmF1bHRzGBEgAygIIlcKEUV4dGVuc2lvbk1ldGFkYXRhEgwKBG5hbWUYASABKAkSDgoGc2NoZW1hGAIgASgJEg8KB3ZlcnNpb24YAyABKAkSEwoLZGVzY3JpcHRpb24YBCABKAkivgEKEkZvcmVpZ25LZXlNZXRhZGF0YRIMCgRuYW1lGAEgASgJEg8KB2NvbHVtbnMYAiADKAkSGQoRcmVmZXJlbmNlZF9zY2hlbWEYAyABKAkSGAoQcmVmZXJlbmNlZF90YWJsZRgEIAEoCRIaChJyZWZlcmVuY2VkX2NvbHVtbnMYBSADKAkSEQoJb25fZGVsZXRlGAYgASgJEhEKCW9uX3VwZGF0ZRgHIAEoCRISCgptYXRjaF90eXBlGAggASgJIiAKDkRhdGFiYXNlU2NoZW1hEg4KBnNjaGVtYRgBIAEoCSI+ChFEYXRhYmFzZVNETFNjaGVtYRIOCgZzY2hlbWEYASABKAwSGQoMY29udGVudF90eXBlGAIgASgJQgPgQQMi8QIKFkdldFNjaGVtYVN0cmluZ1JlcXVlc3QSKwoEbmFtZRgBIAEoCUId4EEC+kEXChVieXRlYmFzZS5jb20vRGF0YWJhc2USPAoEdHlwZRgCIAEoDjIuLmJ5dGViYXNlLnYxLkdldFNjaGVtYVN0cmluZ1JlcXVlc3QuT2JqZWN0VHlwZRIOCgZzY2hlbWEYAyABKAkSDgoGb2JqZWN0GAQgASgJEi8KCG1ldGFkYXRhGAUgASgLMh0uYnl0ZWJhc2UudjEuRGF0YWJhc2VNZXRhZGF0YSKaAQoKT2JqZWN0VHlwZRIbChdPQkpFQ1RfVFlQRV9VTlNQRUNJRklFRBAAEgwKCERBVEFCQVNFEAESCgoGU0NIRU1BEAISCQoFVEFCTEUQAxIICgRWSUVXEAQSFQoRTUFURVJJQUxJWkVEX1ZJRVcQBRIMCghGVU5DVElPThAGEg0KCVBST0NFRFVSRRAHEgwKCFNFUVVFTkNFEAgiMAoXR2V0U2NoZW1hU3RyaW5nUmVzcG9uc2USFQoNc2NoZW1hX3N0cmluZxgBIAEoCSo9CgpTeW5jU3RhdHVzEhsKF1NZTkNfU1RBVFVTX1VOU1BFQ0lGSUVEEAASBgoCT0sQARIKCgZGQUlMRUQQAjLSGgoPRGF0YWJhc2VTZXJ2aWNlEsUBCgtHZXREYXRhYmFzZRIfLmJ5dGViYXNlLnYxLkdldERhdGFiYXNlUmVxdWVzdBoVLmJ5dGViYXNlLnYxLkRhdGFiYXNlIn7aQQRuYW1liuowEGJiLmRhdGFiYXNlcy5nZXSQ6jABoOowAYLT5JMCVVovEi0vdjEve25hbWU9cHJvamVjdHMvKi9pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKn0SIi92MS97bmFtZT1pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKn0SnQIKEUJhdGNoR2V0RGF0YWJhc2VzEiUuYnl0ZWJhc2UudjEuQmF0Y2hHZXREYXRhYmFzZXNSZXF1ZXN0GiYuYnl0ZWJhc2UudjEuQmF0Y2hHZXREYXRhYmFzZXNSZXNwb25zZSK4AYrqMBBiYi5kYXRhYmFzZXMuZ2V0kOowAqDqMAGC0+STApUBWi0SKy92MS97cGFyZW50PWluc3RhbmNlcy8qfS9kYXRhYmFzZXM6YmF0Y2hHZXRaOBI2L3YxL3twYXJlbnQ9cHJvamVjdHMvKi9pbnN0YW5jZXMvKn0vZGF0YWJhc2VzOmJhdGNoR2V0EiovdjEve3BhcmVudD1wcm9qZWN0cy8qfS9kYXRhYmFzZXM6YmF0Y2hHZXQSoQIKDUxpc3REYXRhYmFzZXMSIS5ieXRlYmFzZS52MS5MaXN0RGF0YWJhc2VzUmVxdWVzdBoiLmJ5dGViYXNlLnYxLkxpc3REYXRhYmFzZXNSZXNwb25zZSLIAdpBAIrqMBFiYi5kYXRhYmFzZXMubGlzdJDqMAKg6jABgtPkkwKhAVokEiIvdjEve3BhcmVudD1pbnN0YW5jZXMvKn0vZGF0YWJhc2VzWiUSIy92MS97cGFyZW50PXdvcmtzcGFjZXMvKn0vZGF0YWJhc2VzWi8SLS92MS97cGFyZW50PXByb2plY3RzLyovaW5zdGFuY2VzLyp9L2RhdGFiYXNlcxIhL3YxL3twYXJlbnQ9cHJvamVjdHMvKn0vZGF0YWJhc2VzEokCCg5VcGRhdGVEYXRhYmFzZRIiLmJ5dGViYXNlLnYxLlVwZGF0ZURhdGFiYXNlUmVxdWVzdBoVLmJ5dGViYXNlLnYxLkRhdGFiYXNlIrsB2kEUZGF0YWJhc2UsdXBkYXRlX21hc2uK6jATYmIuZGF0YWJhc2VzLnVwZGF0ZZDqMAGY6jABoOowAoLT5JMCezoIZGF0YWJhc2VaQjoIZGF0YWJhc2UyNi92MS97ZGF0YWJhc2UubmFtZT1wcm9qZWN0cy8qL2luc3RhbmNlcy8qL2RhdGFiYXNlcy8qfTIrL3YxL3tkYXRhYmFzZS5uYW1lPWluc3RhbmNlcy8qL2RhdGFiYXNlcy8qfRKKAgoUQmF0Y2hVcGRhdGVEYXRhYmFzZXMSKC5ieXRlYmFzZS52MS5CYXRjaFVwZGF0ZURhdGFiYXNlc1JlcXVlc3QaKS5ieXRlYmFzZS52MS5CYXRjaFVwZGF0ZURhdGFiYXNlc1Jlc3BvbnNlIpwBiuowE2JiLmRhdGFiYXNlcy51cGRhdGWQ6jABmOowAaDqMAKC0+STAnM6ASpaPjoBKiI5L3YxL3twYXJlbnQ9cHJvamVjdHMvKi9pbnN0YW5jZXMvKn0vZGF0YWJhc2VzOmJhdGNoVXBkYXRlIi4vdjEve3BhcmVudD1pbnN0YW5jZXMvKn0vZGF0YWJhc2VzOmJhdGNoVXBkYXRlEt4BCgxTeW5jRGF0YWJhc2USIC5ieXRlYmFzZS52MS5TeW5jRGF0YWJhc2VSZXF1ZXN0GiEuYnl0ZWJhc2UudjEuU3luY0RhdGFiYXNlUmVzcG9uc2UiiAGK6jARYmIuZGF0YWJhc2VzLnN5bmOQ6jABoOowAoLT5JMCZToBKlo3OgEqIjIvdjEve25hbWU9cHJvamVjdHMvKi9pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKn06c3luYyInL3YxL3tuYW1lPWluc3RhbmNlcy8qL2RhdGFiYXNlcy8qfTpzeW5jEvoBChJCYXRjaFN5bmNEYXRhYmFzZXMSJi5ieXRlYmFzZS52MS5CYXRjaFN5bmNEYXRhYmFzZXNSZXF1ZXN0GicuYnl0ZWJhc2UudjEuQmF0Y2hTeW5jRGF0YWJhc2VzUmVzcG9uc2UikgGK6jARYmIuZGF0YWJhc2VzLnN5bmOQ6jABoOowAoLT5JMCbzoBKlo8OgEqIjcvdjEve3BhcmVudD1wcm9qZWN0cy8qL2luc3RhbmNlcy8qfS9kYXRhYmFzZXM6YmF0Y2hTeW5jIiwvdjEve3BhcmVudD1pbnN0YW5jZXMvKn0vZGF0YWJhc2VzOmJhdGNoU3luYxLvAQoTR2V0RGF0YWJhc2VNZXRhZGF0YRInLmJ5dGViYXNlLnYxLkdldERhdGFiYXNlTWV0YWRhdGFSZXF1ZXN0Gh0uYnl0ZWJhc2UudjEuRGF0YWJhc2VNZXRhZGF0YSKPAYrqMBZiYi5kYXRhYmFzZXMuZ2V0U2NoZW1hkOowAaDqMAGC0+STAmdaOBI2L3YxL3tuYW1lPXByb2plY3RzLyovaW5zdGFuY2VzLyovZGF0YWJhc2VzLyovbWV0YWRhdGF9EisvdjEve25hbWU9aW5zdGFuY2VzLyovZGF0YWJhc2VzLyovbWV0YWRhdGF9EuUBChFHZXREYXRhYmFzZVNjaGVtYRIlLmJ5dGViYXNlLnYxLkdldERhdGFiYXNlU2NoZW1hUmVxdWVzdBobLmJ5dGViYXNlLnYxLkRhdGFiYXNlU2NoZW1hIosBiuowFmJiLmRhdGFiYXNlcy5nZXRTY2hlbWGQ6jABoOowAYLT5JMCY1o2EjQvdjEve25hbWU9cHJvamVjdHMvKi9pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKi9zY2hlbWF9EikvdjEve25hbWU9aW5zdGFuY2VzLyovZGF0YWJhc2VzLyovc2NoZW1hfRL0AQoUR2V0RGF0YWJhc2VTRExTY2hlbWESKC5ieXRlYmFzZS52MS5HZXREYXRhYmFzZVNETFNjaGVtYVJlcXVlc3QaHi5ieXRlYmFzZS52MS5EYXRhYmFzZVNETFNjaGVtYSKRAYrqMBZiYi5kYXRhYmFzZXMuZ2V0U2NoZW1hkOowAaDqMAGC0+STAmlaORI3L3YxL3tuYW1lPXByb2plY3RzLyovaW5zdGFuY2VzLyovZGF0YWJhc2VzLyovc2RsU2NoZW1hfRIsL3YxL3tuYW1lPWluc3RhbmNlcy8qL2RhdGFiYXNlcy8qL3NkbFNjaGVtYX0S8QIKCkRpZmZTY2hlbWESHi5ieXRlYmFzZS52MS5EaWZmU2NoZW1hUmVxdWVzdBofLmJ5dGViYXNlLnYxLkRpZmZTY2hlbWFSZXNwb25zZSKhAorqMBBiYi5kYXRhYmFzZXMuZ2V0kOowAaDqMAKC0+STAv4BOgEqWj06ASoiOC92MS97bmFtZT1wcm9qZWN0cy8qL2luc3RhbmNlcy8qL2RhdGFiYXNlcy8qfTpkaWZmU2NoZW1hWj86ASoiOi92MS97bmFtZT1pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKi9jaGFuZ2Vsb2dzLyp9OmRpZmZTY2hlbWFaSjoBKiJFL3YxL3tuYW1lPXByb2plY3RzLyovaW5zdGFuY2VzLyovZGF0YWJhc2VzLyovY2hhbmdlbG9ncy8qfTpkaWZmU2NoZW1hIi0vdjEve25hbWU9aW5zdGFuY2VzLyovZGF0YWJhc2VzLyp9OmRpZmZTY2hlbWES9gEKDERpZmZNZXRhZGF0YRIgLmJ5dGViYXNlLnYxLkRpZmZNZXRhZGF0YVJlcXVlc3QaIS5ieXRlYmFzZS52MS5EaWZmTWV0YWRhdGFSZXNwb25zZSKgAYrqMBliYi5kYXRhYmFzZXMuZGlmZk1ldGFkYXRhkOowAaDqMAKC0+STAnU6ASpaPzoBKiI6L3YxL3tuYW1lPXByb2plY3RzLyovaW5zdGFuY2VzLyovZGF0YWJhc2VzLyp9OmRpZmZNZXRhZGF0YSIvL3YxL3tuYW1lPWluc3RhbmNlcy8qL2RhdGFiYXNlcy8qfTpkaWZmTWV0YWRhdGES/QEKD0dldFNjaGVtYVN0cmluZxIjLmJ5dGViYXNlLnYxLkdldFNjaGVtYVN0cmluZ1JlcXVlc3QaJC5ieXRlYmFzZS52MS5HZXRTY2hlbWFTdHJpbmdSZXNwb25zZSKeAdpBBG5hbWWK6jAWYmIuZGF0YWJhc2VzLmdldFNjaGVtYZDqMAGg6jABgtPkkwJvWjwSOi92MS97bmFtZT1wcm9qZWN0cy8qL2luc3RhbmNlcy8qL2RhdGFiYXNlcy8qL3NjaGVtYVN0cmluZ30SLy92MS97bmFtZT1pbnN0YW5jZXMvKi9kYXRhYmFzZXMvKi9zY2hlbWFTdHJpbmd9QqoBCg9jb20uYnl0ZWJhc2UudjFCFERhdGFiYXNlU2VydmljZVByb3RvUAFaNGdpdGh1Yi5jb20vYnl0ZWJhc2UvYnl0ZWJhc2UvYmFja2VuZC9nZW5lcmF0ZWQtZ28vdjGiAgNCWFiqAgtCeXRlYmFzZS5WMcoCC0J5dGViYXNlXFYx4gIXQnl0ZWJhc2VcVjFcR1BCTWV0YWRhdGHqAgxCeXRlYmFzZTo6VjFiBnByb3RvMw", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_instance_service]);/*** Describes the message bytebase.v1.GetDatabaseRequest.diff --git a/proto/gen/grpc-doc/openapi.yaml b/proto/gen/grpc-doc/openapi.yamlindex 24be63e57f..7cbab8b4c8 100644--- a/proto/gen/grpc-doc/openapi.yaml+++ b/proto/gen/grpc-doc/openapi.yaml@@ -2511,14 +2511,6 @@ paths:`INVALID_ARGUMENT` error if any path is unmappable.schema:type: string- - name: allowMissing- in: query- description: |-- If set to true, and the database is not found, a new database will be created.- In this situation, `update_mask` is ignored.- schema:- type: boolean- title: allow_missingrequestBody:description: |-The database to update.@@ -7629,14 +7621,6 @@ paths:`INVALID_ARGUMENT` error if any path is unmappable.schema:type: string- - name: allowMissing- in: query- description: |-- If set to true, and the database is not found, a new database will be created.- In this situation, `update_mask` is ignored.- schema:- type: boolean- title: allow_missingrequestBody:description: |-The database to update.@@ -32727,12 +32711,6 @@ components:title: update_maskdescription: The list of fields to update.$ref: '#/components/schemas/google.protobuf.FieldMask'- allowMissing:- type: boolean- title: allow_missing- description: |-- If set to true, and the database is not found, a new database will be created.- In this situation, `update_mask` is ignored.title: UpdateDatabaseRequestrequired:- databasediff --git a/proto/gen/grpc-doc/v1/README.md b/proto/gen/grpc-doc/v1/README.mdindex 4a16e89ebb..cba8c27e0b 100644--- a/proto/gen/grpc-doc/v1/README.md+++ b/proto/gen/grpc-doc/v1/README.md@@ -8726,7 +8726,6 @@ TessellationConfig defines tessellation parameters for spatial indexes.The database's `name` field is used to identify the database to update. Format: instances/{instance}/databases/{database} or projects/{project}/instances/{instance}/databases/{database} || update_mask | [google.protobuf.FieldMask](#google-protobuf-FieldMask) | | The list of fields to update. |-| allow_missing | [bool](#bool) | | If set to true, and the database is not found, a new database will be created. In this situation, `update_mask` is ignored. |diff --git a/proto/gen/grpc-doc/v1/index.html b/proto/gen/grpc-doc/v1/index.htmlindex dbc8f0fc5f..5324b966b3 100644--- a/proto/gen/grpc-doc/v1/index.html+++ b/proto/gen/grpc-doc/v1/index.html@@ -24909,14 +24909,6 @@ Format: instances/{instance}/databases/{database} or projects/{project}/instance<td><p>The list of fields to update. </p></td></tr>- <tr>- <td>allow_missing</td>- <td><a href="#bool">bool</a></td>- <td></td>- <td><p>If set to true, and the database is not found, a new database will be created.-In this situation, `update_mask` is ignored. </p></td>- </tr>-</tbody></table>diff --git a/proto/v1/v1/database_service.proto b/proto/v1/v1/database_service.protoindex e241aec177..de73e0977d 100644--- a/proto/v1/v1/database_service.proto+++ b/proto/v1/v1/database_service.proto@@ -340,9 +340,8 @@ message UpdateDatabaseRequest {// The list of fields to update.google.protobuf.FieldMask update_mask = 2;- // If set to true, and the database is not found, a new database will be created.- // In this situation, `update_mask` is ignored.- bool allow_missing = 3;+ // Never add allow_missing: a database is not independently creatable, it+ // appears when its instance is synced, so the flag has nothing to create.}message BatchUpdateDatabasesRequest {