feat(user): add per-user tag metadata settings (#5735)

go.mod

@@ -32,7 +32,8 @@ require (
 	golang.org/x/net v0.52.0
 	golang.org/x/oauth2 v0.36.0
 	golang.org/x/sync v0.20.0
-	google.golang.org/genproto/googleapis/api v0.0.0-20260311181403-84a4fc48630c
+	google.golang.org/genproto v0.0.0-20260316180232-0b37fe3546d5
+	google.golang.org/genproto/googleapis/api v0.0.0-20260316172706-e463d84ca32d
 	google.golang.org/grpc v1.79.2
 	modernc.org/sqlite v1.46.1
 )
@@ -106,7 +107,7 @@ require (
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
 	golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 // indirect
 	golang.org/x/image v0.30.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20260311181403-84a4fc48630c // indirect
 	modernc.org/libc v1.67.6 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect

go.sum

@@ -307,10 +307,12 @@ golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
 gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
-google.golang.org/genproto/googleapis/api v0.0.0-20260311181403-84a4fc48630c h1:OyQPd6I3pN/9gDxz6L13kYGJgqkpdrAohJRBeXyxlgI=
-google.golang.org/genproto/googleapis/api v0.0.0-20260311181403-84a4fc48630c/go.mod h1:X2gu9Qwng7Nn009s/r3RUxqkzQNqOrAy79bluY7ojIg=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171 h1:ggcbiqK8WWh6l1dnltU4BgWGIGo+EVYxCaAPih/zQXQ=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
+google.golang.org/genproto v0.0.0-20260316180232-0b37fe3546d5 h1:JNfk58HZ8lfmXbYK2vx/UvsqIL59TzByCxPIX4TDmsE=
+google.golang.org/genproto v0.0.0-20260316180232-0b37fe3546d5/go.mod h1:x5julN69+ED4PcFk/XWayw35O0lf/nGa4aNgODCmNmw=
+google.golang.org/genproto/googleapis/api v0.0.0-20260316172706-e463d84ca32d h1:RdWlPmVySdTF0IBIZzvZJvSD0ZocPBNUsnE+uGBxj+4=
+google.golang.org/genproto/googleapis/api v0.0.0-20260316172706-e463d84ca32d/go.mod h1:X2gu9Qwng7Nn009s/r3RUxqkzQNqOrAy79bluY7ojIg=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260311181403-84a4fc48630c h1:xgCzyF2LFIO/0X2UAoVRiXKU5Xg6VjToG4i2/ecSswk=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260311181403-84a4fc48630c/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
 google.golang.org/grpc v1.79.2 h1:fRMD94s2tITpyJGtBBn7MkMseNpOZU8ZxgC3MMBaXRU=
 google.golang.org/grpc v1.79.2/go.mod h1:KmT0Kjez+0dde/v2j9vzwoAScgEPx/Bw1CYChhHLrHQ=
 google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=

proto/api/v1/user_service.proto

@@ -10,6 +10,7 @@ import "google/api/resource.proto";
 import "google/protobuf/empty.proto";
 import "google/protobuf/field_mask.proto";
 import "google/protobuf/timestamp.proto";
+import "google/type/color.proto";
 
 option go_package = "gen/api/v1";
 
@@ -375,6 +376,7 @@ message UserSetting {
   oneof value {
     GeneralSetting general_setting = 2;
     WebhooksSetting webhooks_setting = 5;
+    TagsSetting tags_setting = 6;
   }
 
   // Enumeration of user setting keys.
@@ -384,6 +386,8 @@ message UserSetting {
     GENERAL = 1;
     // WEBHOOKS is the key for user webhooks.
     WEBHOOKS = 4;
+    // TAGS is the key for user tag metadata.
+    TAGS = 5;
   }
 
   // General user settings configuration.
@@ -403,6 +407,17 @@ message UserSetting {
     // List of user webhooks.
     repeated UserWebhook webhooks = 1;
   }
+
+  // Metadata for a tag.
+  message TagMetadata {
+    // Background color for the tag label.
+    google.type.Color background_color = 1;
+  }
+
+  // User tag metadata configuration.
+  message TagsSetting {
+    map<string, TagMetadata> tags = 1;
+  }
 }
 
 message GetUserSettingRequest {

proto/gen/openapi.yaml

@@ -1903,6 +1903,161 @@ components:
                     description: |-
                         Optional. The related memo. Refer to `Memo.name`.
                          Format: memos/{memo}
+        Color:
+            type: object
+            properties:
+                red:
+                    type: number
+                    description: The amount of red in the color as a value in the interval [0, 1].
+                    format: float
+                green:
+                    type: number
+                    description: The amount of green in the color as a value in the interval [0, 1].
+                    format: float
+                blue:
+                    type: number
+                    description: The amount of blue in the color as a value in the interval [0, 1].
+                    format: float
+                alpha:
+                    type: number
+                    description: |-
+                        The fraction of this color that should be applied to the pixel. That is,
+                         the final pixel color is defined by the equation:
+
+                           `pixel color = alpha * (this color) + (1.0 - alpha) * (background color)`
+
+                         This means that a value of 1.0 corresponds to a solid color, whereas
+                         a value of 0.0 corresponds to a completely transparent color. This
+                         uses a wrapper message rather than a simple float scalar so that it is
+                         possible to distinguish between a default value and the value being unset.
+                         If omitted, this color object is rendered as a solid color
+                         (as if the alpha value had been explicitly given a value of 1.0).
+                    format: float
+            description: |-
+                Represents a color in the RGBA color space. This representation is designed
+                 for simplicity of conversion to/from color representations in various
+                 languages over compactness. For example, the fields of this representation
+                 can be trivially provided to the constructor of `java.awt.Color` in Java; it
+                 can also be trivially provided to UIColor's `+colorWithRed:green:blue:alpha`
+                 method in iOS; and, with just a little work, it can be easily formatted into
+                 a CSS `rgba()` string in JavaScript.
+
+                 This reference page doesn't carry information about the absolute color
+                 space
+                 that should be used to interpret the RGB value (e.g. sRGB, Adobe RGB,
+                 DCI-P3, BT.2020, etc.). By default, applications should assume the sRGB color
+                 space.
+
+                 When color equality needs to be decided, implementations, unless
+                 documented otherwise, treat two colors as equal if all their red,
+                 green, blue, and alpha values each differ by at most 1e-5.
+
+                 Example (Java):
+
+                      import com.google.type.Color;
+
+                      // ...
+                      public static java.awt.Color fromProto(Color protocolor) {
+                        float alpha = protocolor.hasAlpha()
+                            ? protocolor.getAlpha().getValue()
+                            : 1.0;
+
+                        return new java.awt.Color(
+                            protocolor.getRed(),
+                            protocolor.getGreen(),
+                            protocolor.getBlue(),
+                            alpha);
+                      }
+
+                      public static Color toProto(java.awt.Color color) {
+                        float red = (float) color.getRed();
+                        float green = (float) color.getGreen();
+                        float blue = (float) color.getBlue();
+                        float denominator = 255.0;
+                        Color.Builder resultBuilder =
+                            Color
+                                .newBuilder()
+                                .setRed(red / denominator)
+                                .setGreen(green / denominator)
+                                .setBlue(blue / denominator);
+                        int alpha = color.getAlpha();
+                        if (alpha != 255) {
+                          result.setAlpha(
+                              FloatValue
+                                  .newBuilder()
+                                  .setValue(((float) alpha) / denominator)
+                                  .build());
+                        }
+                        return resultBuilder.build();
+                      }
+                      // ...
+
+                 Example (iOS / Obj-C):
+
+                      // ...
+                      static UIColor* fromProto(Color* protocolor) {
+                         float red = [protocolor red];
+                         float green = [protocolor green];
+                         float blue = [protocolor blue];
+                         FloatValue* alpha_wrapper = [protocolor alpha];
+                         float alpha = 1.0;
+                         if (alpha_wrapper != nil) {
+                           alpha = [alpha_wrapper value];
+                         }
+                         return [UIColor colorWithRed:red green:green blue:blue alpha:alpha];
+                      }
+
+                      static Color* toProto(UIColor* color) {
+                          CGFloat red, green, blue, alpha;
+                          if (![color getRed:&red green:&green blue:&blue alpha:&alpha]) {
+                            return nil;
+                          }
+                          Color* result = [[Color alloc] init];
+                          [result setRed:red];
+                          [result setGreen:green];
+                          [result setBlue:blue];
+                          if (alpha <= 0.9999) {
+                            [result setAlpha:floatWrapperWithValue(alpha)];
+                          }
+                          [result autorelease];
+                          return result;
+                     }
+                     // ...
+
+                  Example (JavaScript):
+
+                     // ...
+
+                     var protoToCssColor = function(rgb_color) {
+                        var redFrac = rgb_color.red || 0.0;
+                        var greenFrac = rgb_color.green || 0.0;
+                        var blueFrac = rgb_color.blue || 0.0;
+                        var red = Math.floor(redFrac * 255);
+                        var green = Math.floor(greenFrac * 255);
+                        var blue = Math.floor(blueFrac * 255);
+
+                        if (!('alpha' in rgb_color)) {
+                           return rgbToCssColor(red, green, blue);
+                        }
+
+                        var alphaFrac = rgb_color.alpha.value || 0.0;
+                        var rgbParams = [red, green, blue].join(',');
+                        return ['rgba(', rgbParams, ',', alphaFrac, ')'].join('');
+                     };
+
+                     var rgbToCssColor = function(red, green, blue) {
+                       var rgbNumber = new Number((red << 16) | (green << 8) | blue);
+                       var hexString = rgbNumber.toString(16);
+                       var missingZeros = 6 - hexString.length;
+                       var resultBuilder = ['#'];
+                       for (var i = 0; i < missingZeros; i++) {
+                          resultBuilder.push('0');
+                       }
+                       resultBuilder.push(hexString);
+                       return resultBuilder.join('');
+                     };
+
+                     // ...
         CreatePersonalAccessTokenRequest:
             required:
                 - parent
@@ -2831,6 +2986,8 @@ components:
                     $ref: '#/components/schemas/UserSetting_GeneralSetting'
                 webhooksSetting:
                     $ref: '#/components/schemas/UserSetting_WebhooksSetting'
+                tagsSetting:
+                    $ref: '#/components/schemas/UserSetting_TagsSetting'
             description: User settings message
         UserSetting_GeneralSetting:
             type: object
@@ -2848,6 +3005,22 @@ components:
                          This references a CSS file in the web/public/themes/ directory.
                          If not set, the default theme will be used.
             description: General user settings configuration.
+        UserSetting_TagMetadata:
+            type: object
+            properties:
+                backgroundColor:
+                    allOf:
+                        - $ref: '#/components/schemas/Color'
+                    description: Background color for the tag label.
+            description: Metadata for a tag.
+        UserSetting_TagsSetting:
+            type: object
+            properties:
+                tags:
+                    type: object
+                    additionalProperties:
+                        $ref: '#/components/schemas/UserSetting_TagMetadata'
+            description: User tag metadata configuration.
         UserSetting_WebhooksSetting:
             type: object
             properties:

proto/store/user_setting.proto

@@ -3,6 +3,7 @@ syntax = "proto3";
 package memos.store;
 
 import "google/protobuf/timestamp.proto";
+import "google/type/color.proto";
 
 option go_package = "gen/store";
 
@@ -19,6 +20,8 @@ message UserSetting {
     REFRESH_TOKENS = 6;
     // Personal access tokens for the user.
     PERSONAL_ACCESS_TOKENS = 7;
+    // Tag metadata for the user.
+    TAGS = 8;
   }
 
   int32 user_id = 1;
@@ -30,6 +33,7 @@ message UserSetting {
     WebhooksUserSetting webhooks = 7;
     RefreshTokensUserSetting refresh_tokens = 8;
     PersonalAccessTokensUserSetting personal_access_tokens = 9;
+    TagsUserSetting tags = 10;
   }
 }
 
@@ -111,3 +115,12 @@ message WebhooksUserSetting {
   }
   repeated Webhook webhooks = 1;
 }
+
+message TagMetadata {
+  // Background color for the tag label.
+  google.type.Color background_color = 1;
+}
+
+message TagsUserSetting {
+  map<string, TagMetadata> tags = 1;
+}

server/router/api/v1/test/user_setting_test.go

+package test
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	colorpb "google.golang.org/genproto/googleapis/type/color"
+	"google.golang.org/protobuf/types/known/fieldmaskpb"
+
+	apiv1 "github.com/usememos/memos/proto/gen/api/v1"
+)
+
+func TestUserSettingTags(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+
+	t.Run("GetUserSetting returns empty tags setting by default", func(t *testing.T) {
+		ts := NewTestService(t)
+		defer ts.Cleanup()
+
+		user, err := ts.CreateHostUser(ctx, "tags-default")
+		require.NoError(t, err)
+
+		response, err := ts.Service.GetUserSetting(ts.CreateUserContext(ctx, user.ID), &apiv1.GetUserSettingRequest{
+			Name: fmt.Sprintf("users/%d/settings/TAGS", user.ID),
+		})
+		require.NoError(t, err)
+		require.NotNil(t, response)
+		require.NotNil(t, response.GetTagsSetting())
+		require.Empty(t, response.GetTagsSetting().GetTags())
+	})
+
+	t.Run("UpdateUserSetting replaces tag metadata", func(t *testing.T) {
+		ts := NewTestService(t)
+		defer ts.Cleanup()
+
+		user, err := ts.CreateHostUser(ctx, "tags-update")
+		require.NoError(t, err)
+		userCtx := ts.CreateUserContext(ctx, user.ID)
+
+		settingName := fmt.Sprintf("users/%d/settings/TAGS", user.ID)
+		updateRequest := &apiv1.UpdateUserSettingRequest{
+			Setting: &apiv1.UserSetting{
+				Name: settingName,
+				Value: &apiv1.UserSetting_TagsSetting_{
+					TagsSetting: &apiv1.UserSetting_TagsSetting{
+						Tags: map[string]*apiv1.UserSetting_TagMetadata{
+							"bug": {
+								BackgroundColor: &colorpb.Color{
+									Red:   0.9,
+									Green: 0.1,
+									Blue:  0.1,
+								},
+							},
+						},
+					},
+				},
+			},
+			UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"tags"}},
+		}
+
+		response, err := ts.Service.UpdateUserSetting(userCtx, updateRequest)
+		require.NoError(t, err)
+		require.NotNil(t, response.GetTagsSetting())
+		require.Contains(t, response.GetTagsSetting().GetTags(), "bug")
+		require.InDelta(t, 0.9, response.GetTagsSetting().GetTags()["bug"].GetBackgroundColor().GetRed(), 0.0001)
+
+		getResponse, err := ts.Service.GetUserSetting(userCtx, &apiv1.GetUserSettingRequest{Name: settingName})
+		require.NoError(t, err)
+		require.Len(t, getResponse.GetTagsSetting().GetTags(), 1)
+		require.Contains(t, getResponse.GetTagsSetting().GetTags(), "bug")
+	})
+
+	t.Run("UpdateUserSetting rejects invalid color", func(t *testing.T) {
+		ts := NewTestService(t)
+		defer ts.Cleanup()
+
+		user, err := ts.CreateHostUser(ctx, "tags-invalid")
+		require.NoError(t, err)
+
+		_, err = ts.Service.UpdateUserSetting(ts.CreateUserContext(ctx, user.ID), &apiv1.UpdateUserSettingRequest{
+			Setting: &apiv1.UserSetting{
+				Name: fmt.Sprintf("users/%d/settings/TAGS", user.ID),
+				Value: &apiv1.UserSetting_TagsSetting_{
+					TagsSetting: &apiv1.UserSetting_TagsSetting{
+						Tags: map[string]*apiv1.UserSetting_TagMetadata{
+							"bug": {
+								BackgroundColor: &colorpb.Color{
+									Red:   1.2,
+									Green: 0.1,
+									Blue:  0.1,
+								},
+							},
+						},
+					},
+				},
+			},
+			UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"tags"}},
+		})
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "invalid tags setting")
+	})
+
+	t.Run("Other users cannot read or update tag metadata", func(t *testing.T) {
+		ts := NewTestService(t)
+		defer ts.Cleanup()
+
+		user, err := ts.CreateHostUser(ctx, "tags-owner")
+		require.NoError(t, err)
+		otherUser, err := ts.CreateHostUser(ctx, "tags-other")
+		require.NoError(t, err)
+
+		settingName := fmt.Sprintf("users/%d/settings/TAGS", user.ID)
+		_, err = ts.Service.GetUserSetting(ts.CreateUserContext(ctx, otherUser.ID), &apiv1.GetUserSettingRequest{
+			Name: settingName,
+		})
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "permission denied")
+
+		_, err = ts.Service.UpdateUserSetting(ts.CreateUserContext(ctx, otherUser.ID), &apiv1.UpdateUserSettingRequest{
+			Setting: &apiv1.UserSetting{
+				Name: settingName,
+				Value: &apiv1.UserSetting_TagsSetting_{
+					TagsSetting: &apiv1.UserSetting_TagsSetting{
+						Tags: map[string]*apiv1.UserSetting_TagMetadata{
+							"bug": {
+								BackgroundColor: &colorpb.Color{
+									Red:   0.1,
+									Green: 0.2,
+									Blue:  0.3,
+								},
+							},
+						},
+					},
+				},
+			},
+			UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"tags"}},
+		})
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "permission denied")
+	})
+}

store/test/user_setting_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
+	colorpb "google.golang.org/genproto/googleapis/type/color"
 	"google.golang.org/protobuf/types/known/timestamppb"
 
 	storepb "github.com/usememos/memos/proto/gen/store"
@@ -104,6 +105,48 @@ func TestUserSettingUpsertUpdate(t *testing.T) {
 	ts.Close()
 }
 
+func TestUserSettingTags(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+	ts := NewTestingStore(ctx, t)
+	user, err := createTestingHostUser(ctx, ts)
+	require.NoError(t, err)
+
+	_, err = ts.UpsertUserSetting(ctx, &storepb.UserSetting{
+		UserId: user.ID,
+		Key:    storepb.UserSetting_TAGS,
+		Value: &storepb.UserSetting_Tags{
+			Tags: &storepb.TagsUserSetting{
+				Tags: map[string]*storepb.TagMetadata{
+					"bug": {
+						BackgroundColor: &colorpb.Color{
+							Red:   0.1,
+							Green: 0.2,
+							Blue:  0.3,
+						},
+					},
+				},
+			},
+		},
+	})
+	require.NoError(t, err)
+
+	setting, err := ts.GetUserSetting(ctx, &store.FindUserSetting{
+		UserID: &user.ID,
+		Key:    storepb.UserSetting_TAGS,
+	})
+	require.NoError(t, err)
+	require.NotNil(t, setting)
+	require.Contains(t, setting.GetTags().Tags, "bug")
+	require.InDelta(t, 0.1, setting.GetTags().Tags["bug"].GetBackgroundColor().GetRed(), 0.0001)
+
+	list, err := ts.ListUserSettings(ctx, &store.FindUserSetting{UserID: &user.ID})
+	require.NoError(t, err)
+	require.Len(t, list, 1)
+
+	ts.Close()
+}
+
 func TestUserSettingRefreshTokens(t *testing.T) {
 	t.Parallel()
 	ctx := context.Background()

store/user_setting.go

@@ -431,6 +431,12 @@ func convertUserSettingFromRaw(raw *UserSetting) (*storepb.UserSetting, error) {
 			return nil, err
 		}
 		userSetting.Value = &storepb.UserSetting_Webhooks{Webhooks: webhooksUserSetting}
+	case storepb.UserSetting_TAGS:
+		tagsUserSetting := &storepb.TagsUserSetting{}
+		if err := protojsonUnmarshaler.Unmarshal([]byte(raw.Value), tagsUserSetting); err != nil {
+			return nil, err
+		}
+		userSetting.Value = &storepb.UserSetting_Tags{Tags: tagsUserSetting}
 	default:
 		return nil, nil
 	}
@@ -479,6 +485,13 @@ func convertUserSettingToRaw(userSetting *storepb.UserSetting) (*UserSetting, er
 			return nil, err
 		}
 		raw.Value = string(value)
+	case storepb.UserSetting_TAGS:
+		tagsUserSetting := userSetting.GetTags()
+		value, err := protojson.Marshal(tagsUserSetting)
+		if err != nil {
+			return nil, err
+		}
+		raw.Value = string(value)
 	default:
 		return nil, errors.Errorf("unsupported user setting key: %v", userSetting.Key)
 	}

web/src/types/proto/google/type/color_pb.ts

+// Copyright 2025 Google LLC
+//
+// 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.
+
+// @generated by protoc-gen-es v2.11.0 with parameter "target=ts"
+// @generated from file google/type/color.proto (package google.type, syntax proto3)
+/* eslint-disable */
+
+import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
+import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2";
+import { file_google_protobuf_wrappers } from "@bufbuild/protobuf/wkt";
+import type { Message } from "@bufbuild/protobuf";
+
+/**
+ * Describes the file google/type/color.proto.
+ */
+export const file_google_type_color: GenFile = /*@__PURE__*/
+  fileDesc("Chdnb29nbGUvdHlwZS9jb2xvci5wcm90bxILZ29vZ2xlLnR5cGUiXQoFQ29sb3ISCwoDcmVkGAEgASgCEg0KBWdyZWVuGAIgASgCEgwKBGJsdWUYAyABKAISKgoFYWxwaGEYBCABKAsyGy5nb29nbGUucHJvdG9idWYuRmxvYXRWYWx1ZUKlAQoPY29tLmdvb2dsZS50eXBlQgpDb2xvclByb3RvUAFaNmdvb2dsZS5nb2xhbmcub3JnL2dlbnByb3RvL2dvb2dsZWFwaXMvdHlwZS9jb2xvcjtjb2xvcvgBAaICA0dUWKoCC0dvb2dsZS5UeXBlygILR29vZ2xlXFR5cGXiAhdHb29nbGVcVHlwZVxHUEJNZXRhZGF0YeoCDEdvb2dsZTo6VHlwZWIGcHJvdG8z", [file_google_protobuf_wrappers]);
+
+/**
+ * Represents a color in the RGBA color space. This representation is designed
+ * for simplicity of conversion to/from color representations in various
+ * languages over compactness. For example, the fields of this representation
+ * can be trivially provided to the constructor of `java.awt.Color` in Java; it
+ * can also be trivially provided to UIColor's `+colorWithRed:green:blue:alpha`
+ * method in iOS; and, with just a little work, it can be easily formatted into
+ * a CSS `rgba()` string in JavaScript.
+ *
+ * This reference page doesn't carry information about the absolute color
+ * space
+ * that should be used to interpret the RGB value (e.g. sRGB, Adobe RGB,
+ * DCI-P3, BT.2020, etc.). By default, applications should assume the sRGB color
+ * space.
+ *
+ * When color equality needs to be decided, implementations, unless
+ * documented otherwise, treat two colors as equal if all their red,
+ * green, blue, and alpha values each differ by at most 1e-5.
+ *
+ * Example (Java):
+ *
+ *      import com.google.type.Color;
+ *
+ *      // ...
+ *      public static java.awt.Color fromProto(Color protocolor) {
+ *        float alpha = protocolor.hasAlpha()
+ *            ? protocolor.getAlpha().getValue()
+ *            : 1.0;
+ *
+ *        return new java.awt.Color(
+ *            protocolor.getRed(),
+ *            protocolor.getGreen(),
+ *            protocolor.getBlue(),
+ *            alpha);
+ *      }
+ *
+ *      public static Color toProto(java.awt.Color color) {
+ *        float red = (float) color.getRed();
+ *        float green = (float) color.getGreen();
+ *        float blue = (float) color.getBlue();
+ *        float denominator = 255.0;
+ *        Color.Builder resultBuilder =
+ *            Color
+ *                .newBuilder()
+ *                .setRed(red / denominator)
+ *                .setGreen(green / denominator)
+ *                .setBlue(blue / denominator);
+ *        int alpha = color.getAlpha();
+ *        if (alpha != 255) {
+ *          result.setAlpha(
+ *              FloatValue
+ *                  .newBuilder()
+ *                  .setValue(((float) alpha) / denominator)
+ *                  .build());
+ *        }
+ *        return resultBuilder.build();
+ *      }
+ *      // ...
+ *
+ * Example (iOS / Obj-C):
+ *
+ *      // ...
+ *      static UIColor* fromProto(Color* protocolor) {
+ *         float red = [protocolor red];
+ *         float green = [protocolor green];
+ *         float blue = [protocolor blue];
+ *         FloatValue* alpha_wrapper = [protocolor alpha];
+ *         float alpha = 1.0;
+ *         if (alpha_wrapper != nil) {
+ *           alpha = [alpha_wrapper value];
+ *         }
+ *         return [UIColor colorWithRed:red green:green blue:blue alpha:alpha];
+ *      }
+ *
+ *      static Color* toProto(UIColor* color) {
+ *          CGFloat red, green, blue, alpha;
+ *          if (![color getRed:&red green:&green blue:&blue alpha:&alpha]) {
+ *            return nil;
+ *          }
+ *          Color* result = [[Color alloc] init];
+ *          [result setRed:red];
+ *          [result setGreen:green];
+ *          [result setBlue:blue];
+ *          if (alpha <= 0.9999) {
+ *            [result setAlpha:floatWrapperWithValue(alpha)];
+ *          }
+ *          [result autorelease];
+ *          return result;
+ *     }
+ *     // ...
+ *
+ *  Example (JavaScript):
+ *
+ *     // ...
+ *
+ *     var protoToCssColor = function(rgb_color) {
+ *        var redFrac = rgb_color.red || 0.0;
+ *        var greenFrac = rgb_color.green || 0.0;
+ *        var blueFrac = rgb_color.blue || 0.0;
+ *        var red = Math.floor(redFrac * 255);
+ *        var green = Math.floor(greenFrac * 255);
+ *        var blue = Math.floor(blueFrac * 255);
+ *
+ *        if (!('alpha' in rgb_color)) {
+ *           return rgbToCssColor(red, green, blue);
+ *        }
+ *
+ *        var alphaFrac = rgb_color.alpha.value || 0.0;
+ *        var rgbParams = [red, green, blue].join(',');
+ *        return ['rgba(', rgbParams, ',', alphaFrac, ')'].join('');
+ *     };
+ *
+ *     var rgbToCssColor = function(red, green, blue) {
+ *       var rgbNumber = new Number((red << 16) | (green << 8) | blue);
+ *       var hexString = rgbNumber.toString(16);
+ *       var missingZeros = 6 - hexString.length;
+ *       var resultBuilder = ['#'];
+ *       for (var i = 0; i < missingZeros; i++) {
+ *          resultBuilder.push('0');
+ *       }
+ *       resultBuilder.push(hexString);
+ *       return resultBuilder.join('');
+ *     };
+ *
+ *     // ...
+ *
+ * @generated from message google.type.Color
+ */
+export type Color = Message<"google.type.Color"> & {
+  /**
+   * The amount of red in the color as a value in the interval [0, 1].
+   *
+   * @generated from field: float red = 1;
+   */
+  red: number;
+
+  /**
+   * The amount of green in the color as a value in the interval [0, 1].
+   *
+   * @generated from field: float green = 2;
+   */
+  green: number;
+
+  /**
+   * The amount of blue in the color as a value in the interval [0, 1].
+   *
+   * @generated from field: float blue = 3;
+   */
+  blue: number;
+
+  /**
+   * The fraction of this color that should be applied to the pixel. That is,
+   * the final pixel color is defined by the equation:
+   *
+   *   `pixel color = alpha * (this color) + (1.0 - alpha) * (background color)`
+   *
+   * This means that a value of 1.0 corresponds to a solid color, whereas
+   * a value of 0.0 corresponds to a completely transparent color. This
+   * uses a wrapper message rather than a simple float scalar so that it is
+   * possible to distinguish between a default value and the value being unset.
+   * If omitted, this color object is rendered as a solid color
+   * (as if the alpha value had been explicitly given a value of 1.0).
+   *
+   * @generated from field: google.protobuf.FloatValue alpha = 4;
+   */
+  alpha?: number;
+};
+
+/**
+ * Describes the message google.type.Color.
+ * Use `create(ColorSchema)` to create a new message.
+ */
+export const ColorSchema: GenMessage<Color> = /*@__PURE__*/
+  messageDesc(file_google_type_color, 0);
+