From 2379518abf5f8ced413163d3abfdd892a3a084fa Mon Sep 17 00:00:00 2001 From: Adam Babik Date: Fri, 4 Oct 2024 19:09:58 +0200 Subject: [PATCH] internal/config: use JSON Schema (#678) This change switches the `runme.yaml` schema definition from protobuf to JSON Schema. This results in fewer conversions and more natural representation. It also adds support for parsing and merging multiple configuration files. Default config was moved to [a file](internal/config/runme.default.yaml). Go's struct representing the config is generated from the schema. When you change `internal/config/config.schema.json`, remember to call `make schema/generate`. --------- Co-authored-by: Sebastian Tiedtke --- .gitignore | 3 + Makefile | 9 + cmd/gqltool/main.go | 4 - docker/runme-test-env.Dockerfile | 1 + go.mod | 5 - go.sum | 15 +- internal/cmd/beta/beta_cmd.go | 24 +- internal/cmd/beta/server/grpcurl_utils.go | 4 +- internal/cmd/beta/server/server_cmd.go | 2 +- internal/cmd/beta/server/server_start_cmd.go | 12 +- internal/cmd/beta/server/server_stop_cmd.go | 2 +- internal/config/autoconfig/autoconfig.go | 117 +- internal/config/config.go | 190 +- internal/config/config.schema.json | 178 + internal/config/config_defaults.go | 77 - internal/config/config_schema.go | 368 ++ internal/config/config_test.go | 148 +- internal/config/loader.go | 65 +- internal/config/loader_test.go | 22 +- internal/config/runme.default.yaml | 34 + .../go/runme/config/v1alpha1/config.pb.go | 1041 ------ .../gen/proto/go/runme/parser/v1/parser.pb.go | 15 +- .../gql/runme/config/v1alpha1/config.graphql | 3 - .../proto/gql/runme/parser/v1/parser.graphql | 8 + .../runme/reporter/v1alpha1/reporter.graphql | 8 + .../ts/google/protobuf/descriptor_pb.d.ts | 2383 ------------- .../proto/ts/google/protobuf/descriptor_pb.js | 3153 ----------------- .../ts/runme/config/v1alpha1/config_pb.d.ts | 303 -- .../ts/runme/config/v1alpha1/config_pb.js | 169 - .../proto/ts/runme/parser/v1/parser_pb.d.ts | 2 + .../proto/runme/config/v1alpha1/config.proto | 119 - 31 files changed, 943 insertions(+), 7541 deletions(-) create mode 100644 internal/config/config.schema.json delete mode 100644 internal/config/config_defaults.go create mode 100644 internal/config/config_schema.go create mode 100644 internal/config/runme.default.yaml delete mode 100644 pkg/api/gen/proto/go/runme/config/v1alpha1/config.pb.go delete mode 100644 pkg/api/gen/proto/gql/runme/config/v1alpha1/config.graphql delete mode 100644 pkg/api/gen/proto/ts/google/protobuf/descriptor_pb.d.ts delete mode 100644 pkg/api/gen/proto/ts/google/protobuf/descriptor_pb.js delete mode 100644 pkg/api/gen/proto/ts/runme/config/v1alpha1/config_pb.d.ts delete mode 100644 pkg/api/gen/proto/ts/runme/config/v1alpha1/config_pb.js delete mode 100644 pkg/api/proto/runme/config/v1alpha1/config.proto diff --git a/.gitignore b/.gitignore index fce1ec77d..f48f399a9 100644 --- a/.gitignore +++ b/.gitignore @@ -52,3 +52,6 @@ cover.out # Prevent git from interpreting internal/project/testdata/git-project as a submodule. internal/project/testdata/git-project/**/.git internal/project/testdata/git-project/**/.gitignore + +# Ignore user-specific runme.yaml files. +experimental/runme.*.yaml diff --git a/Makefile b/Makefile index 12f58b214..2027ae2ea 100644 --- a/Makefile +++ b/Makefile @@ -117,6 +117,7 @@ install/dev: go install mvdan.cc/gofumpt@v0.7.0 go install github.com/icholy/gomajor@v0.13.1 go install github.com/stateful/go-proto-gql/protoc-gen-gql@latest + go install github.com/atombender/go-jsonschema@v0.16.0 .PHONY: install/goreleaser install/goreleaser: @@ -148,6 +149,14 @@ proto/dev/reset: proto/publish: @cd ./pkg/api/proto && buf push +.PHONY: schema/generate +schema/generate: + go-jsonschema -t \ + -p config \ + --tags "json,yaml" \ + -o internal/config/config_schema.go \ + internal/config/config.schema.json + .PHONY: release release: install/goreleaser @goreleaser check diff --git a/cmd/gqltool/main.go b/cmd/gqltool/main.go index 29479b83f..bcd1115ce 100644 --- a/cmd/gqltool/main.go +++ b/cmd/gqltool/main.go @@ -19,10 +19,6 @@ func init() { } func main() { - // httpClient := client.NewHTTPClient(nil, client.WithTokenGetter(func() (string, error) { - // a := auth.New(oauth2.Config{}, *apiURL, &auth.DiskStorage{Location: *tokenDir}) - // return a.GetToken(context.Background()) - // })) httpClient := client.NewHTTPClient(nil) client, err := graphql.New(*apiURL+"/graphql", httpClient) if err != nil { diff --git a/docker/runme-test-env.Dockerfile b/docker/runme-test-env.Dockerfile index aca7d3fde..d2d1ed6d1 100644 --- a/docker/runme-test-env.Dockerfile +++ b/docker/runme-test-env.Dockerfile @@ -11,6 +11,7 @@ RUN apt-get update && apt-get install -y \ curl \ make \ python3 \ + ruby-full \ unzip # Install node.js diff --git a/go.mod b/go.mod index 5b41af299..8ae6d2dd9 100644 --- a/go.mod +++ b/go.mod @@ -5,11 +5,9 @@ go 1.22.0 // replace github.com/stateful/godotenv => ../godotenv require ( - buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.34.2-20240717164558-a6c49f84cc0f.2 github.com/Masterminds/semver/v3 v3.2.1 github.com/Microsoft/go-winio v0.6.2 github.com/atotto/clipboard v0.1.4 - github.com/bufbuild/protovalidate-go v0.6.3 github.com/charmbracelet/bubbletea v0.26.6 github.com/charmbracelet/lipgloss v0.12.1 github.com/cli/cli/v2 v2.53.0 @@ -53,7 +51,6 @@ require ( require ( dario.cat/mergo v1.0.0 // indirect - github.com/antlr4-go/antlr/v4 v4.13.1 // indirect github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect github.com/bufbuild/protocompile v0.14.0 // indirect github.com/charmbracelet/x/ansi v0.1.4 // indirect @@ -74,12 +71,10 @@ require ( github.com/go-logr/stdr v1.2.2 // indirect github.com/gogo/protobuf v1.3.2 // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect - github.com/google/cel-go v0.20.1 // indirect github.com/moby/docker-image-spec v1.3.1 // indirect github.com/moby/term v0.5.0 // indirect github.com/morikuni/aec v1.0.0 // indirect github.com/opencontainers/go-digest v1.0.0 // indirect - github.com/stoewer/go-strcase v1.3.0 // indirect github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0 // indirect go.opentelemetry.io/otel v1.28.0 // indirect diff --git a/go.sum b/go.sum index 5ab14bc40..f7a294fba 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,3 @@ -buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.34.2-20240717164558-a6c49f84cc0f.2 h1:SZRVx928rbYZ6hEKUIN+vtGDkl7uotABRWGY4OAg5gM= -buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.34.2-20240717164558-a6c49f84cc0f.2/go.mod h1:ylS4c28ACSI59oJrOdW4pHS4n0Hw4TgSPHn8rpHl4Yw= dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk= dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 h1:UQHMgLO+TxOElx5B5HZ4hJQsoJ/PvUvKRhJHDQXO8P8= @@ -19,8 +17,6 @@ github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883 h1:bvNMNQO63//z+xNg github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8= github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8= github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4= -github.com/antlr4-go/antlr/v4 v4.13.1 h1:SqQKkuVZ+zWkMMNkjy5FZe5mr5WURWnlpmOuzYWrPrQ= -github.com/antlr4-go/antlr/v4 v4.13.1/go.mod h1:GKmUxMtwp6ZgGwZSva4eWPC5mS6vUAmOABFgjdkM7Nw= github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio= github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4= @@ -31,8 +27,6 @@ github.com/briandowns/spinner v1.23.1 h1:t5fDPmScwUjozhDj4FA46p5acZWIPXYE30qW2Pt github.com/briandowns/spinner v1.23.1/go.mod h1:LaZeM4wm2Ywy6vO571mvhQNRcWfRUnXOs0RcKV0wYKM= github.com/bufbuild/protocompile v0.14.0 h1:z3DW4IvXE5G/uTOnSQn+qwQQxvhckkTWLS/0No/o7KU= github.com/bufbuild/protocompile v0.14.0/go.mod h1:N6J1NYzkspJo3ZwyL4Xjvli86XOj1xq4qAasUFxGups= -github.com/bufbuild/protovalidate-go v0.6.3 h1:wxQyzW035zM16Binbaz/nWAzS12dRIXhZdSUWRY7Fv0= -github.com/bufbuild/protovalidate-go v0.6.3/go.mod h1:J4PtwP9Z2YAGgB0+o+tTWEDtLtXvz/gfhFZD8pbzM/U= github.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0= github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM= github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= @@ -143,8 +137,6 @@ github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= -github.com/google/cel-go v0.20.1 h1:nDx9r8S3L4pE61eDdt8igGj8rf5kjYR3ILxWIpWNi84= -github.com/google/cel-go v0.20.1/go.mod h1:kWcIzTsPX0zmQ+H3TirHstLLf9ep5QTsZBN9u4dOYLg= github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= @@ -263,8 +255,6 @@ github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/stateful/godotenv v0.0.0-20240309032207-c7bc0b812915 h1:rBwOH8hK4mnonIOv9qV76i+nhmJIMaxqUeuzg9e7pF8= github.com/stateful/godotenv v0.0.0-20240309032207-c7bc0b812915/go.mod h1:A7pPuRB981nGoMyu09TOEDPHzg/eVlO3rgy1pk91xYY= -github.com/stoewer/go-strcase v1.3.0 h1:g0eASXYtp+yvN9fK8sH94oCIk0fau9uV1/ZdJ0AVEzs= -github.com/stoewer/go-strcase v1.3.0/go.mod h1:fAH5hQ5pehh+j3nZfvwdk2RgEgQjAoM8wodgtPmh1xo= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= @@ -274,7 +264,6 @@ github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81P github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= -github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= @@ -282,10 +271,10 @@ github.com/vektah/gqlparser/v2 v2.5.16 h1:1gcmLTvs3JLKXckwCwlUagVn/IlV2bwqle0vJ0 github.com/vektah/gqlparser/v2 v2.5.16/go.mod h1:1lz1OeCqgQbQepsGxPVywrjdBHW2T08PUS3pJqepRww= github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM= github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw= -github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no= -github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM= github.com/xo/dburl v0.23.2 h1:Fl88cvayrgE56JA/sqhNMLljCW/b7RmG1mMkKMZUFgA= github.com/xo/dburl v0.23.2/go.mod h1:uazlaAQxj4gkshhfuuYyvwCBouOmNnG2aDxTCFZpmL4= +github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no= +github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= diff --git a/internal/cmd/beta/beta_cmd.go b/internal/cmd/beta/beta_cmd.go index ac7456b95..5412819a4 100644 --- a/internal/cmd/beta/beta_cmd.go +++ b/internal/cmd/beta/beta_cmd.go @@ -6,6 +6,7 @@ import ( "github.com/spf13/cobra" "github.com/spf13/pflag" + "go.uber.org/zap" "github.com/stateful/runme/v3/internal/cmd/beta/server" "github.com/stateful/runme/v3/internal/config" @@ -36,25 +37,30 @@ All commands use the runme.yaml configuration file.`, cmd.SetErr(io.Discard) } - err := autoconfig.InvokeForCommand(func(cfg *config.Config) error { + err := autoconfig.InvokeForCommand(func(cfg *config.Config, log *zap.Logger) error { // Override the filename if provided. if cFlags.filename != "" { - cfg.ProjectFilename = cFlags.filename + cfg.Project.Filename = cFlags.filename } // Add a filter to run only tasks from the specified tags. if len(cFlags.tags) > 0 { - cfg.ProjectFilters = append(cfg.ProjectFilters, &config.Filter{ - Type: config.FilterTypeBlock, - Condition: `len(intersection(tags, extra.tags)) > 0`, - Extra: map[string]interface{}{"tags": cFlags.tags}, - }) + cfg.Project.Filters = append( + cfg.Project.Filters, + config.ConfigProjectFiltersElem{ + Type: config.FilterTypeBlock, + Condition: `len(intersection(tags, extra.tags)) > 0`, + Extra: map[string]interface{}{"tags": cFlags.tags}, + }, + ) } + log.Info("final configuration", zap.Any("config", cfg)) + return nil }) - // print the error to stderr but don't return it because error modes - // are neither fully baked yet nor ready for users to consume + // Print the error to stderr but don't return it because error modes + // are neither fully baked yet nor ready for users to consume. if err != nil { _, _ = fmt.Fprintf(cmd.ErrOrStderr(), "%s\n", err) } diff --git a/internal/cmd/beta/server/grpcurl_utils.go b/internal/cmd/beta/server/grpcurl_utils.go index 65300d206..74823a9e0 100644 --- a/internal/cmd/beta/server/grpcurl_utils.go +++ b/internal/cmd/beta/server/grpcurl_utils.go @@ -27,14 +27,14 @@ func getDescriptorSource(ctx context.Context, cfg *config.Config) (grpcurl.Descr } func dialServer(ctx context.Context, cfg *config.Config) (*grpc.ClientConn, error) { - tlsConf, err := runmetls.LoadClientConfig(cfg.ServerTLSCertFile, cfg.ServerTLSKeyFile) + tlsConf, err := runmetls.LoadClientConfig(*cfg.Server.Tls.CertFile, *cfg.Server.Tls.KeyFile) if err != nil { return nil, err } creds := credentials.NewTLS(tlsConf) - network, addr := "tcp", cfg.ServerAddress + network, addr := "tcp", cfg.Server.Address if strings.HasPrefix(addr, "unix://") { network, addr = "unix", strings.TrimPrefix(addr, "unix://") } diff --git a/internal/cmd/beta/server/server_cmd.go b/internal/cmd/beta/server/server_cmd.go index 66a8d3abe..127a6e5b2 100644 --- a/internal/cmd/beta/server/server_cmd.go +++ b/internal/cmd/beta/server/server_cmd.go @@ -19,7 +19,7 @@ func Cmd() *cobra.Command { ) error { // For the server commands, we want to always log to stdout. // TODO(adamb): there might be a need to separate client and server logs. - cfg.LogPath = "" + cfg.Log.Path = "" return nil }, ) diff --git a/internal/cmd/beta/server/server_start_cmd.go b/internal/cmd/beta/server/server_start_cmd.go index c1ecbba15..d1831a2c1 100644 --- a/internal/cmd/beta/server/server_start_cmd.go +++ b/internal/cmd/beta/server/server_start_cmd.go @@ -28,10 +28,10 @@ func serverStartCmd() *cobra.Command { defer logger.Sync() serverCfg := &server.Config{ - Address: cfg.ServerAddress, - CertFile: cfg.ServerTLSCertFile, - KeyFile: cfg.ServerTLSKeyFile, - TLSEnabled: cfg.ServerTLSEnabled, + Address: cfg.Server.Address, + CertFile: *cfg.Server.Tls.CertFile, // guaranteed by autoconfig + KeyFile: *cfg.Server.Tls.KeyFile, // guaranteed by autoconfig + TLSEnabled: cfg.Server.Tls.Enabled, } _ = telemetry.ReportUnlessNoTracking(logger) @@ -44,12 +44,12 @@ func serverStartCmd() *cobra.Command { } // When using a unix socket, we want to create a file with server's PID. - if path := pidFileNameFromAddr(cfg.ServerAddress); path != "" { + if path := pidFileNameFromAddr(cfg.Server.Address); path != "" { logger.Debug("creating PID file", zap.String("path", path)) if err := createFileWithPID(path); err != nil { return errors.WithStack(err) } - defer os.Remove(cfg.ServerAddress) + defer os.Remove(cfg.Server.Address) } logger.Debug("starting the server") diff --git a/internal/cmd/beta/server/server_stop_cmd.go b/internal/cmd/beta/server/server_stop_cmd.go index e9100b6b9..bbe93be37 100644 --- a/internal/cmd/beta/server/server_stop_cmd.go +++ b/internal/cmd/beta/server/server_stop_cmd.go @@ -27,7 +27,7 @@ func serverStopCmd() *cobra.Command { logger.Debug("stopping the server by looking for runme.pid") - path := pidFileNameFromAddr(cfg.ServerAddress) + path := pidFileNameFromAddr(cfg.Server.Address) if path == "" { return errors.New("server address is not a unix socket") } diff --git a/internal/config/autoconfig/autoconfig.go b/internal/config/autoconfig/autoconfig.go index 7007bab6b..9ab399e81 100644 --- a/internal/config/autoconfig/autoconfig.go +++ b/internal/config/autoconfig/autoconfig.go @@ -17,10 +17,15 @@ import ( "github.com/pkg/errors" "go.uber.org/dig" "go.uber.org/zap" + "google.golang.org/grpc" + "google.golang.org/grpc/credentials" + "google.golang.org/grpc/credentials/insecure" "github.com/stateful/runme/v3/internal/command" "github.com/stateful/runme/v3/internal/config" "github.com/stateful/runme/v3/internal/dockerexec" + "github.com/stateful/runme/v3/internal/runnerv2client" + runmetls "github.com/stateful/runme/v3/internal/tls" "github.com/stateful/runme/v3/pkg/project" ) @@ -60,6 +65,8 @@ func mustProvide(err error) { } func init() { + mustProvide(container.Provide(getClient)) + mustProvide(container.Provide(getClientFactory)) mustProvide(container.Provide(getCommandFactory)) mustProvide(container.Provide(getConfigLoader)) mustProvide(container.Provide(getDocker)) @@ -70,6 +77,39 @@ func init() { mustProvide(container.Provide(getUserConfigDir)) } +func getClient(cfg *config.Config, logger *zap.Logger) (*runnerv2client.Client, error) { + if cfg.Server == nil { + return nil, nil + } + + var opts []grpc.DialOption + + if cfg.Server.Tls != nil && cfg.Server.Tls.Enabled { + // It's ok to dereference TLS fields because they are checked in [getRootConfig]. + tlsConfig, err := runmetls.LoadClientConfig(*cfg.Server.Tls.CertFile, *cfg.Server.Tls.KeyFile) + if err != nil { + return nil, errors.WithStack(err) + } + creds := credentials.NewTLS(tlsConfig) + opts = append(opts, grpc.WithTransportCredentials(creds)) + } else { + opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials())) + } + + return runnerv2client.New( + cfg.Server.Address, + opts..., + ) +} + +type ClientFactory func() (*runnerv2client.Client, error) + +func getClientFactory(cfg *config.Config, logger *zap.Logger) ClientFactory { + return func() (*runnerv2client.Client, error) { + return getClient(cfg, logger) + } +} + func getCommandFactory(docker *dockerexec.Docker, logger *zap.Logger, proj *project.Project) command.Factory { return command.NewFactory( command.WithDocker(docker), @@ -81,24 +121,33 @@ func getCommandFactory(docker *dockerexec.Docker, logger *zap.Logger, proj *proj func getConfigLoader() (*config.Loader, error) { // TODO(adamb): change from "./experimental" to "." when the feature is stable and // delete the project root path. - return config.NewLoader("runme", "yaml", os.DirFS("./experimental"), config.WithProjectRootPath(os.DirFS("."))), nil + return config.NewLoader( + []string{"runme.yaml", "runme." + os.Getenv("USER") + ".yaml"}, + os.DirFS("./experimental"), + config.WithProjectRootPath(os.DirFS(".")), + ), nil } func getDocker(c *config.Config, logger *zap.Logger) (*dockerexec.Docker, error) { - if !c.RuntimeDockerEnabled { + if c.Runtime == nil || c.Runtime.Docker == nil || !c.Runtime.Docker.Enabled { return nil, nil } - return dockerexec.New(&dockerexec.Options{ - BuildContext: c.RuntimeDockerBuildContext, - Dockerfile: c.RuntimeDockerBuildDockerfile, - Image: c.RuntimeDockerImage, - Logger: logger, - }) + options := &dockerexec.Options{ + Image: c.Runtime.Docker.Image, + Logger: logger, + } + + if b := c.Runtime.Docker.Build; b != nil { + options.BuildContext = c.Runtime.Docker.Build.Context + options.Dockerfile = c.Runtime.Docker.Build.Dockerfile + } + + return dockerexec.New(options) } func getLogger(c *config.Config) (*zap.Logger, error) { - if c == nil || !c.LogEnabled { + if c == nil || c.Log == nil || !c.Log.Enabled { return zap.NewNop(), nil } @@ -115,16 +164,16 @@ func getLogger(c *config.Config) (*zap.Logger, error) { ErrorOutputPaths: []string{"stderr"}, } - if c.LogVerbose { + if c.Log.Verbose { zapConfig.Level = zap.NewAtomicLevelAt(zap.DebugLevel) zapConfig.Development = true zapConfig.Encoding = "console" zapConfig.EncoderConfig = zap.NewDevelopmentEncoderConfig() } - if c.LogPath != "" { - zapConfig.OutputPaths = []string{c.LogPath} - zapConfig.ErrorOutputPaths = []string{c.LogPath} + if c.Log.Path != "" { + zapConfig.OutputPaths = []string{c.Log.Path} + zapConfig.ErrorOutputPaths = []string{c.Log.Path} } l, err := zapConfig.Build() @@ -136,11 +185,11 @@ func getProject(c *config.Config, logger *zap.Logger) (*project.Project, error) project.WithLogger(logger), } - if c.ProjectFilename != "" { - return project.NewFileProject(c.ProjectFilename, opts...) + if c.Project.Filename != "" { + return project.NewFileProject(c.Project.Filename, opts...) } - projDir := c.ProjectRoot + projDir := c.Project.Root // If no project directory is specified, use the current directory. if projDir == "" { projDir = "." @@ -148,12 +197,12 @@ func getProject(c *config.Config, logger *zap.Logger) (*project.Project, error) opts = append( opts, - project.WithIgnoreFilePatterns(c.ProjectIgnorePaths...), - project.WithRespectGitignore(!c.ProjectDisableGitignore), - project.WithEnvFilesReadOrder(c.ProjectEnvSources), + project.WithIgnoreFilePatterns(c.Project.Ignore...), + project.WithRespectGitignore(!c.Project.DisableGitignore), + project.WithEnvFilesReadOrder(c.Project.Env.Sources), ) - if c.ProjectFindRepoUpward { + if c.Project.FindRepoUpward { opts = append(opts, project.WithFindRepoUpward()) } @@ -163,8 +212,12 @@ func getProject(c *config.Config, logger *zap.Logger) (*project.Project, error) func getProjectFilters(c *config.Config) ([]project.Filter, error) { var filters []project.Filter - for _, filter := range c.ProjectFilters { - filter := filter + for _, filter := range c.Project.Filters { + filter := config.Filter{ + Type: string(filter.Type), + Condition: filter.Condition, + Extra: filter.Extra, + } switch filter.Type { case config.FilterTypeBlock: @@ -212,24 +265,28 @@ func getProjectFilters(c *config.Config) ([]project.Filter, error) { func getRootConfig(cfgLoader *config.Loader, userCfgDir UserConfigDir) (*config.Config, error) { var cfg *config.Config - content, err := cfgLoader.RootConfig() + items, err := cfgLoader.RootConfigs() switch err { case nil: - if cfg, err = config.ParseYAML(content); err != nil { + if cfg, err = config.ParseYAML(items...); err != nil { return nil, err } case config.ErrRootConfigNotFound: - cfg = config.Defaults() + cfg = config.Default() default: return nil, errors.WithMessage(err, "failed to load root configuration") } - if cfg.ServerTLSEnabled { - if cfg.ServerTLSCertFile == "" { - cfg.ServerTLSCertFile = filepath.Join(string(userCfgDir), "runme", "tls", "cert.pem") + if cfg.Server != nil && cfg.Server.Tls != nil && cfg.Server.Tls.Enabled { + tls := cfg.Server.Tls + + if tls.CertFile == nil { + path := filepath.Join(string(userCfgDir), "runme", "tls", "cert.pem") + tls.CertFile = &path } - if cfg.ServerTLSKeyFile == "" { - cfg.ServerTLSKeyFile = filepath.Join(string(userCfgDir), "runme", "tls", "key.pem") + if tls.KeyFile == nil { + path := filepath.Join(string(userCfgDir), "runme", "tls", "key.pem") + tls.KeyFile = &path } } diff --git a/internal/config/config.go b/internal/config/config.go index 7b86a23a8..676d67bfa 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -1,87 +1,65 @@ package config import ( + _ "embed" "encoding/json" "os" "path/filepath" - "reflect" "strings" - "github.com/bufbuild/protovalidate-go" "github.com/pkg/errors" - "google.golang.org/protobuf/encoding/protojson" - "google.golang.org/protobuf/reflect/protoreflect" "gopkg.in/yaml.v3" - - configv1alpha1 "github.com/stateful/runme/v3/pkg/api/gen/proto/go/runme/config/v1alpha1" ) -// Config is a flatten configuration of runme.yaml. The purpose of it is to -// unify all the different configuration versions into a single struct. -type Config struct { - ProjectRoot string - ProjectFilename string - ProjectFindRepoUpward bool - ProjectIgnorePaths []string - ProjectDisableGitignore bool - ProjectEnvUseSystemEnv bool - ProjectEnvSources []string - ProjectFilters []*Filter - - RuntimeDockerEnabled bool - RuntimeDockerImage string - RuntimeDockerBuildContext string - RuntimeDockerBuildDockerfile string - - ServerAddress string - ServerTLSEnabled bool - ServerTLSCertFile string - ServerTLSKeyFile string - - LogEnabled bool - LogPath string - LogVerbose bool -} +//go:embed runme.default.yaml +var defaultRunmeYAML []byte -func (c *Config) Clone() *Config { - clone := *c - clone.ProjectIgnorePaths = make([]string, len(c.ProjectIgnorePaths)) - copy(clone.ProjectIgnorePaths, c.ProjectIgnorePaths) - clone.ProjectEnvSources = make([]string, len(c.ProjectEnvSources)) - copy(clone.ProjectEnvSources, c.ProjectEnvSources) - clone.ProjectFilters = make([]*Filter, len(c.ProjectFilters)) - for i, f := range c.ProjectFilters { - clone.ProjectFilters[i] = &Filter{ - Type: f.Type, - Condition: f.Condition, - } +func init() { + // Ensure the default configuration is valid. + _, err := newDefault() + if err != nil { + panic(err) } - return &clone } -func Defaults() *Config { - return defaults.Clone() +func newDefault() (*Config, error) { + return ParseYAML(defaultRunmeYAML) +} + +func Default() *Config { + cfg, _ := newDefault() + return cfg +} + +// ParseYAML parses the given YAML items and returns a configuration object. +// Multiple items are merged into a single configuration. It uses a default +// configuration as a base. +func ParseYAML(items ...[]byte) (*Config, error) { + items = append([][]byte{defaultRunmeYAML}, items...) + return parseYAML(items...) } -func ParseYAML(data []byte) (*Config, error) { - version, err := parseVersionFromYAML(data) +func parseYAML(items ...[]byte) (*Config, error) { + version, err := parseVersionFromYAML(items[0]) if err != nil { return nil, err } - switch version { - case "v1alpha1": - cfg, err := parseYAMLv1alpha1(data) + + for i := 1; i < len(items); i++ { + v, err := parseVersionFromYAML(items[i]) if err != nil { return nil, err } - - if err := validateProto(cfg); err != nil { - return nil, errors.Wrap(err, "failed to validate v1alpha1 config") + if v != version { + return nil, errors.Errorf("inconsistent versions: %s and %s", version, v) } + } - config, err := configV1alpha1ToConfig(cfg) + switch version { + case "v1alpha1": + config, err := parseAndMergeV1alpha1(items...) if err != nil { - return nil, errors.Wrap(err, "failed to convert v1alpha1 config") + return nil, err } if err := validateConfig(config); err != nil { @@ -108,75 +86,37 @@ func parseVersionFromYAML(data []byte) (string, error) { return result.Version, nil } -func parseYAMLv1alpha1(data []byte) (*configv1alpha1.Config, error) { - mmap := make(map[string]any) - - if err := yaml.Unmarshal(data, &mmap); err != nil { - return nil, errors.Wrap(err, "failed to unmarshal yaml") +// parseAndMergeV1alpha1 parses items, which are raw YAML blobs, +// one-by-one into a single map. Then, marshals the map into raw JSON. +// Finally, unmarshals the JSON into a [Config] object. +// Double unmarshaling is required to take advantage of the +// auto-generated [Config.UnmarshalJSON] method which does +// validation. +func parseAndMergeV1alpha1(items ...[]byte) (*Config, error) { + m := make(map[string]interface{}) + + for _, data := range items { + if err := yaml.Unmarshal(data, &m); err != nil { + return nil, errors.Wrap(err, "failed to parse v1alpha1 config") + } } - delete(mmap, "version") - - // In order to properly handle JSON-related field options like `json_name`, - // the YAML data is first marshaled to JSON and then unmarshaled to a proto message - // using the protojson package. - configJSONRaw, err := json.Marshal(mmap) + flatten, err := json.Marshal(m) if err != nil { - return nil, errors.Wrap(err, "failed to marshal yaml to json") + return nil, errors.Wrap(err, "failed to parse v1alpha1 config") } - var cfg configv1alpha1.Config - if err := protojson.Unmarshal(configJSONRaw, &cfg); err != nil { - return nil, errors.Wrap(err, "failed to unmarshal json to proto") - } - return &cfg, nil -} + var config Config -func configV1alpha1ToConfig(c *configv1alpha1.Config) (*Config, error) { - project := c.GetProject() - runtime := c.GetRuntime() - server := c.GetServer() - log := c.GetLog() - - var filters []*Filter - for _, f := range c.GetProject().GetFilters() { - filters = append(filters, &Filter{ - Type: f.GetType().String(), - Condition: f.GetCondition(), - }) + if err := json.Unmarshal(flatten, &config); err != nil { + return nil, errors.Wrap(err, "failed to parse v1alpha1 config") } - cfg := Defaults() - cfg.ProjectRoot = project.GetRoot() - cfg.ProjectFilename = project.GetFilename() - setIfHasValue(&cfg.ProjectFindRepoUpward, project.GetFindRepoUpward()) - cfg.ProjectIgnorePaths = project.GetIgnorePaths() - setIfHasValue(&cfg.ProjectDisableGitignore, project.GetDisableGitignore()) - setIfHasValue(&cfg.ProjectEnvUseSystemEnv, project.GetEnv().GetUseSystemEnv()) - cfg.ProjectEnvSources = project.GetEnv().GetSources() - cfg.ProjectFilters = filters - - setIfHasValue(&cfg.RuntimeDockerEnabled, runtime.GetDocker().GetEnabled()) - cfg.RuntimeDockerImage = runtime.GetDocker().GetImage() - cfg.RuntimeDockerBuildContext = runtime.GetDocker().GetBuild().GetContext() - cfg.RuntimeDockerBuildDockerfile = runtime.GetDocker().GetBuild().GetDockerfile() - - cfg.ServerAddress = server.GetAddress() - setIfHasValue(&cfg.ServerTLSEnabled, server.GetTls().GetEnabled()) - cfg.ServerTLSCertFile = server.GetTls().GetCertFile() - cfg.ServerTLSKeyFile = server.GetTls().GetKeyFile() - - setIfHasValue(&cfg.LogEnabled, log.GetEnabled()) - cfg.LogPath = log.GetPath() - setIfHasValue(&cfg.LogVerbose, log.GetVerbose()) - - return cfg, nil -} - -func setIfHasValue[T any](prop *T, val interface{ GetValue() T }) { - if val != nil && !reflect.ValueOf(val).IsNil() { - *prop = val.GetValue() + if err := validateConfig(&config); err != nil { + return nil, errors.Wrap(err, "failed to validate v1alpha1 config") } + + return &config, nil } func validateConfig(cfg *Config) error { @@ -185,12 +125,12 @@ func validateConfig(cfg *Config) error { cwd = "." } - if err := validateInsideCwd(cfg.ProjectRoot, cwd); err != nil { - return errors.Wrap(err, "failed to validate project dir") + if err := validateInsideCwd(cfg.Project.Root, cwd); err != nil { + return errors.Wrap(err, "project.root") } - if err := validateInsideCwd(cfg.ProjectFilename, cwd); err != nil { - return errors.Wrap(err, "failed to validate filename") + if err := validateInsideCwd(cfg.Project.Filename, cwd); err != nil { + return errors.Wrap(err, "project.filename") } return nil @@ -206,11 +146,3 @@ func validateInsideCwd(path, cwd string) error { } return nil } - -func validateProto(m protoreflect.ProtoMessage) error { - v, err := protovalidate.New() - if err != nil { - return errors.WithStack(err) - } - return errors.WithStack(v.Validate(m)) -} diff --git a/internal/config/config.schema.json b/internal/config/config.schema.json new file mode 100644 index 000000000..d8a21f4c0 --- /dev/null +++ b/internal/config/config.schema.json @@ -0,0 +1,178 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://runme.dev/config.schema.json", + "title": "Config", + "description": "Runme configuration schema", + "type": "object", + "properties": { + "version": { + "type": "string" + }, + "project": { + "type": "object", + "properties": { + "root": { + "type": "string", + "default": "" + }, + "find_repo_upward": { + "type": "boolean", + "default": false + }, + "ignore": { + "type": "array", + "items": { + "type": "string" + } + }, + "disable_gitignore": { + "type": "boolean", + "default": false + }, + "filename": { + "type": "string", + "default": "" + }, + "env": { + "type": "object", + "properties": { + "use_system_env": { + "type": "boolean", + "default": false + }, + "sources": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "filters": { + "type": "array", + "items": { + "type": "object", + "properties": { + "type": { + "type": "string", + "enum": [ + "FILTER_TYPE_BLOCK", + "FILTER_TYPE_DOCUMENT" + ] + }, + "condition": { + "type": "string" + }, + "extra": { + "type": "object" + } + }, + "required": [ + "type", + "condition" + ] + } + } + } + }, + "runtime": { + "type": "object", + "properties": { + "docker": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean" + }, + "image": { + "type": "string" + }, + "build": { + "type": "object", + "properties": { + "context": { + "type": "string" + }, + "dockerfile": { + "type": "string" + } + }, + "required": [ + "context", + "dockerfile" + ] + } + }, + "required": [ + "enabled", + "image" + ] + } + } + }, + "server": { + "type": "object", + "properties": { + "address": { + "type": "string" + }, + "tls": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean" + }, + "cert_file": { + "type": "string" + }, + "key_file": { + "type": "string" + } + }, + "required": [ + "enabled" + ] + } + }, + "required": [ + "address" + ] + }, + "client": { + "type": "object", + "properties": { + "server_address": { + "type": "string" + } + }, + "required": [ + "server_address" + ] + }, + "log": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean", + "default": false + }, + "path": { + "type": "string", + "default": "" + }, + "verbose": { + "type": "boolean", + "default": false + } + }, + "required": [ + "enabled", + "path" + ] + } + }, + "required": [ + "version", + "project" + ] +} diff --git a/internal/config/config_defaults.go b/internal/config/config_defaults.go deleted file mode 100644 index f88525a0e..000000000 --- a/internal/config/config_defaults.go +++ /dev/null @@ -1,77 +0,0 @@ -package config - -var defaults Config - -func init() { - // todo(sebastian): use inline file for easier editing - yaml := []byte(`version: v1alpha1 - -# Settings that apply on at the project level. -project: - # Indicate the root of the runme project. "." means that - # the project root directory will be used. - root: "." - # If true, the project root will be searched upwards starting from "dir". - # If found, the repo root will be used as the project root. - find_repo_upward: true - ignore: - - "node_modules" - - ".venv" - disable_gitignore: false - - # It's possible to point the project at a single file. - # filename: "README.md" - - # List of dotenv files to load. - env: - use_system_env: false - sources: - - ".env" - - ".env.local" - - # The list of filters to apply to blocks. - # "condition" must return a boolean value. - # You can learn about the syntax at https://expr-lang.org/docs/language-definition. - # Available fields are defined in [config.FilterDocumentEnv] and [config.FilterBlockEnv]. - # filters: - # # Do not allow unnamed code blocks. - # # - type: "FILTER_TYPE_BLOCK" - # # condition: "is_named" - # # Do not allow code blocks without a language. - # - type: "FILTER_TYPE_BLOCK" - # condition: "language != ''" - # # Do not allow code blocks starting with "test". - # - type: "FILTER_TYPE_BLOCK" - # condition: "!hasPrefix(name, 'test')" - -runtime: - # Optional Docker configuration to run code blocks in a container. - docker: - enabled: false - image: runme-runtime:latest - build: - context: ./experimental/docker - dockerfile: Dockerfile - -server: - # Also unix:///path/to/file.sock is supported. - address: localhost:7998 - tls: - enabled: true - # If not specified, default paths will be used. - # cert_file: "/path/to/cert.pem" - # key_file: "/path/to/key.pem" - -log: - enabled: false - path: "/tmp/runme.log" - verbose: false -`) - - cfg, err := ParseYAML(yaml) - if err != nil { - panic(err) - } - - defaults = *cfg -} diff --git a/internal/config/config_schema.go b/internal/config/config_schema.go new file mode 100644 index 000000000..3e81b777f --- /dev/null +++ b/internal/config/config_schema.go @@ -0,0 +1,368 @@ +// Code generated by github.com/atombender/go-jsonschema, DO NOT EDIT. + +package config + +import "encoding/json" +import "fmt" +import "reflect" + +// Runme configuration schema +type Config struct { + // Client corresponds to the JSON schema field "client". + Client *ConfigClient `json:"client,omitempty" yaml:"client,omitempty"` + + // Log corresponds to the JSON schema field "log". + Log *ConfigLog `json:"log,omitempty" yaml:"log,omitempty"` + + // Project corresponds to the JSON schema field "project". + Project ConfigProject `json:"project" yaml:"project"` + + // Runtime corresponds to the JSON schema field "runtime". + Runtime *ConfigRuntime `json:"runtime,omitempty" yaml:"runtime,omitempty"` + + // Server corresponds to the JSON schema field "server". + Server *ConfigServer `json:"server,omitempty" yaml:"server,omitempty"` + + // Version corresponds to the JSON schema field "version". + Version string `json:"version" yaml:"version"` +} + +type ConfigClient struct { + // ServerAddress corresponds to the JSON schema field "server_address". + ServerAddress string `json:"server_address" yaml:"server_address"` +} + +// UnmarshalJSON implements json.Unmarshaler. +func (j *ConfigClient) UnmarshalJSON(b []byte) error { + var raw map[string]interface{} + if err := json.Unmarshal(b, &raw); err != nil { + return err + } + if _, ok := raw["server_address"]; raw != nil && !ok { + return fmt.Errorf("field server_address in ConfigClient: required") + } + type Plain ConfigClient + var plain Plain + if err := json.Unmarshal(b, &plain); err != nil { + return err + } + *j = ConfigClient(plain) + return nil +} + +type ConfigLog struct { + // Enabled corresponds to the JSON schema field "enabled". + Enabled bool `json:"enabled" yaml:"enabled"` + + // Path corresponds to the JSON schema field "path". + Path string `json:"path" yaml:"path"` + + // Verbose corresponds to the JSON schema field "verbose". + Verbose bool `json:"verbose,omitempty" yaml:"verbose,omitempty"` +} + +// UnmarshalJSON implements json.Unmarshaler. +func (j *ConfigLog) UnmarshalJSON(b []byte) error { + var raw map[string]interface{} + if err := json.Unmarshal(b, &raw); err != nil { + return err + } + type Plain ConfigLog + var plain Plain + if err := json.Unmarshal(b, &plain); err != nil { + return err + } + if v, ok := raw["enabled"]; !ok || v == nil { + plain.Enabled = false + } + if v, ok := raw["path"]; !ok || v == nil { + plain.Path = "" + } + if v, ok := raw["verbose"]; !ok || v == nil { + plain.Verbose = false + } + *j = ConfigLog(plain) + return nil +} + +type ConfigProject struct { + // DisableGitignore corresponds to the JSON schema field "disable_gitignore". + DisableGitignore bool `json:"disable_gitignore,omitempty" yaml:"disable_gitignore,omitempty"` + + // Env corresponds to the JSON schema field "env". + Env *ConfigProjectEnv `json:"env,omitempty" yaml:"env,omitempty"` + + // Filename corresponds to the JSON schema field "filename". + Filename string `json:"filename,omitempty" yaml:"filename,omitempty"` + + // Filters corresponds to the JSON schema field "filters". + Filters []ConfigProjectFiltersElem `json:"filters,omitempty" yaml:"filters,omitempty"` + + // FindRepoUpward corresponds to the JSON schema field "find_repo_upward". + FindRepoUpward bool `json:"find_repo_upward,omitempty" yaml:"find_repo_upward,omitempty"` + + // Ignore corresponds to the JSON schema field "ignore". + Ignore []string `json:"ignore,omitempty" yaml:"ignore,omitempty"` + + // Root corresponds to the JSON schema field "root". + Root string `json:"root,omitempty" yaml:"root,omitempty"` +} + +type ConfigProjectEnv struct { + // Sources corresponds to the JSON schema field "sources". + Sources []string `json:"sources,omitempty" yaml:"sources,omitempty"` + + // UseSystemEnv corresponds to the JSON schema field "use_system_env". + UseSystemEnv bool `json:"use_system_env,omitempty" yaml:"use_system_env,omitempty"` +} + +// UnmarshalJSON implements json.Unmarshaler. +func (j *ConfigProjectEnv) UnmarshalJSON(b []byte) error { + var raw map[string]interface{} + if err := json.Unmarshal(b, &raw); err != nil { + return err + } + type Plain ConfigProjectEnv + var plain Plain + if err := json.Unmarshal(b, &plain); err != nil { + return err + } + if v, ok := raw["use_system_env"]; !ok || v == nil { + plain.UseSystemEnv = false + } + *j = ConfigProjectEnv(plain) + return nil +} + +type ConfigProjectFiltersElem struct { + // Condition corresponds to the JSON schema field "condition". + Condition string `json:"condition" yaml:"condition"` + + // Extra corresponds to the JSON schema field "extra". + Extra ConfigProjectFiltersElemExtra `json:"extra,omitempty" yaml:"extra,omitempty"` + + // Type corresponds to the JSON schema field "type". + Type ConfigProjectFiltersElemType `json:"type" yaml:"type"` +} + +type ConfigProjectFiltersElemExtra map[string]interface{} + +type ConfigProjectFiltersElemType string + +const ConfigProjectFiltersElemTypeFILTERTYPEBLOCK ConfigProjectFiltersElemType = "FILTER_TYPE_BLOCK" +const ConfigProjectFiltersElemTypeFILTERTYPEDOCUMENT ConfigProjectFiltersElemType = "FILTER_TYPE_DOCUMENT" + +var enumValues_ConfigProjectFiltersElemType = []interface{}{ + "FILTER_TYPE_BLOCK", + "FILTER_TYPE_DOCUMENT", +} + +// UnmarshalJSON implements json.Unmarshaler. +func (j *ConfigProjectFiltersElemType) UnmarshalJSON(b []byte) error { + var v string + if err := json.Unmarshal(b, &v); err != nil { + return err + } + var ok bool + for _, expected := range enumValues_ConfigProjectFiltersElemType { + if reflect.DeepEqual(v, expected) { + ok = true + break + } + } + if !ok { + return fmt.Errorf("invalid value (expected one of %#v): %#v", enumValues_ConfigProjectFiltersElemType, v) + } + *j = ConfigProjectFiltersElemType(v) + return nil +} + +// UnmarshalJSON implements json.Unmarshaler. +func (j *ConfigProjectFiltersElem) UnmarshalJSON(b []byte) error { + var raw map[string]interface{} + if err := json.Unmarshal(b, &raw); err != nil { + return err + } + if _, ok := raw["condition"]; raw != nil && !ok { + return fmt.Errorf("field condition in ConfigProjectFiltersElem: required") + } + if _, ok := raw["type"]; raw != nil && !ok { + return fmt.Errorf("field type in ConfigProjectFiltersElem: required") + } + type Plain ConfigProjectFiltersElem + var plain Plain + if err := json.Unmarshal(b, &plain); err != nil { + return err + } + *j = ConfigProjectFiltersElem(plain) + return nil +} + +// UnmarshalJSON implements json.Unmarshaler. +func (j *ConfigProject) UnmarshalJSON(b []byte) error { + var raw map[string]interface{} + if err := json.Unmarshal(b, &raw); err != nil { + return err + } + type Plain ConfigProject + var plain Plain + if err := json.Unmarshal(b, &plain); err != nil { + return err + } + if v, ok := raw["disable_gitignore"]; !ok || v == nil { + plain.DisableGitignore = false + } + if v, ok := raw["filename"]; !ok || v == nil { + plain.Filename = "" + } + if v, ok := raw["find_repo_upward"]; !ok || v == nil { + plain.FindRepoUpward = false + } + if v, ok := raw["root"]; !ok || v == nil { + plain.Root = "" + } + *j = ConfigProject(plain) + return nil +} + +type ConfigRuntime struct { + // Docker corresponds to the JSON schema field "docker". + Docker *ConfigRuntimeDocker `json:"docker,omitempty" yaml:"docker,omitempty"` +} + +type ConfigRuntimeDocker struct { + // Build corresponds to the JSON schema field "build". + Build *ConfigRuntimeDockerBuild `json:"build,omitempty" yaml:"build,omitempty"` + + // Enabled corresponds to the JSON schema field "enabled". + Enabled bool `json:"enabled" yaml:"enabled"` + + // Image corresponds to the JSON schema field "image". + Image string `json:"image" yaml:"image"` +} + +type ConfigRuntimeDockerBuild struct { + // Context corresponds to the JSON schema field "context". + Context string `json:"context" yaml:"context"` + + // Dockerfile corresponds to the JSON schema field "dockerfile". + Dockerfile string `json:"dockerfile" yaml:"dockerfile"` +} + +// UnmarshalJSON implements json.Unmarshaler. +func (j *ConfigRuntimeDockerBuild) UnmarshalJSON(b []byte) error { + var raw map[string]interface{} + if err := json.Unmarshal(b, &raw); err != nil { + return err + } + if _, ok := raw["context"]; raw != nil && !ok { + return fmt.Errorf("field context in ConfigRuntimeDockerBuild: required") + } + if _, ok := raw["dockerfile"]; raw != nil && !ok { + return fmt.Errorf("field dockerfile in ConfigRuntimeDockerBuild: required") + } + type Plain ConfigRuntimeDockerBuild + var plain Plain + if err := json.Unmarshal(b, &plain); err != nil { + return err + } + *j = ConfigRuntimeDockerBuild(plain) + return nil +} + +// UnmarshalJSON implements json.Unmarshaler. +func (j *ConfigRuntimeDocker) UnmarshalJSON(b []byte) error { + var raw map[string]interface{} + if err := json.Unmarshal(b, &raw); err != nil { + return err + } + if _, ok := raw["enabled"]; raw != nil && !ok { + return fmt.Errorf("field enabled in ConfigRuntimeDocker: required") + } + if _, ok := raw["image"]; raw != nil && !ok { + return fmt.Errorf("field image in ConfigRuntimeDocker: required") + } + type Plain ConfigRuntimeDocker + var plain Plain + if err := json.Unmarshal(b, &plain); err != nil { + return err + } + *j = ConfigRuntimeDocker(plain) + return nil +} + +type ConfigServer struct { + // Address corresponds to the JSON schema field "address". + Address string `json:"address" yaml:"address"` + + // Tls corresponds to the JSON schema field "tls". + Tls *ConfigServerTls `json:"tls,omitempty" yaml:"tls,omitempty"` +} + +type ConfigServerTls struct { + // CertFile corresponds to the JSON schema field "cert_file". + CertFile *string `json:"cert_file,omitempty" yaml:"cert_file,omitempty"` + + // Enabled corresponds to the JSON schema field "enabled". + Enabled bool `json:"enabled" yaml:"enabled"` + + // KeyFile corresponds to the JSON schema field "key_file". + KeyFile *string `json:"key_file,omitempty" yaml:"key_file,omitempty"` +} + +// UnmarshalJSON implements json.Unmarshaler. +func (j *ConfigServerTls) UnmarshalJSON(b []byte) error { + var raw map[string]interface{} + if err := json.Unmarshal(b, &raw); err != nil { + return err + } + if _, ok := raw["enabled"]; raw != nil && !ok { + return fmt.Errorf("field enabled in ConfigServerTls: required") + } + type Plain ConfigServerTls + var plain Plain + if err := json.Unmarshal(b, &plain); err != nil { + return err + } + *j = ConfigServerTls(plain) + return nil +} + +// UnmarshalJSON implements json.Unmarshaler. +func (j *ConfigServer) UnmarshalJSON(b []byte) error { + var raw map[string]interface{} + if err := json.Unmarshal(b, &raw); err != nil { + return err + } + if _, ok := raw["address"]; raw != nil && !ok { + return fmt.Errorf("field address in ConfigServer: required") + } + type Plain ConfigServer + var plain Plain + if err := json.Unmarshal(b, &plain); err != nil { + return err + } + *j = ConfigServer(plain) + return nil +} + +// UnmarshalJSON implements json.Unmarshaler. +func (j *Config) UnmarshalJSON(b []byte) error { + var raw map[string]interface{} + if err := json.Unmarshal(b, &raw); err != nil { + return err + } + if _, ok := raw["project"]; raw != nil && !ok { + return fmt.Errorf("field project in Config: required") + } + if _, ok := raw["version"]; raw != nil && !ok { + return fmt.Errorf("field version in Config: required") + } + type Plain Config + var plain Plain + if err := json.Unmarshal(b, &plain); err != nil { + return err + } + *j = Config(plain) + return nil +} diff --git a/internal/config/config_test.go b/internal/config/config_test.go index 5b61047c8..300d2b6ae 100644 --- a/internal/config/config_test.go +++ b/internal/config/config_test.go @@ -8,7 +8,21 @@ import ( "github.com/stretchr/testify/require" ) -func TestParseYAML(t *testing.T) { +func TestDefault(t *testing.T) { + // Invariant that all default configurations are equal. + expected, err := newDefault() + require.NoError(t, err) + got := Default() + opts := cmpopts.EquateEmpty() + require.True( + t, + cmp.Equal(expected, got, opts), + "%s", + cmp.Diff(expected, got, opts), + ) +} + +func Test_parseYAML(t *testing.T) { testCases := []struct { name string rawConfig string @@ -26,7 +40,10 @@ func TestParseYAML(t *testing.T) { project: filename: REAEDME.md `, - expectedConfig: &Config{ProjectFilename: "REAEDME.md", ProjectFindRepoUpward: true, ServerTLSEnabled: true}, + expectedConfig: &Config{ + Project: ConfigProject{Filename: "REAEDME.md"}, + Version: "v1alpha1", + }, }, { name: "root and filename", @@ -35,7 +52,10 @@ project: root: "." filename: README.md `, - expectedConfig: &Config{ProjectRoot: ".", ProjectFilename: "README.md", ProjectFindRepoUpward: true, ServerTLSEnabled: true}, + expectedConfig: &Config{ + Version: "v1alpha1", + Project: ConfigProject{Root: ".", Filename: "README.md"}, + }, }, { name: "validate filter type", @@ -43,10 +63,10 @@ project: project: filename: README.md filters: - - type: 3 + - type: "FILTER_TYPE_SOME_OTHER" condition: "name != ''" `, - errorSubstring: "failed to validate v1alpha1 config: validation error:\n - project.filters[0].type: value must be one of the defined enum values", + errorSubstring: "failed to parse v1alpha1 config: invalid value (expected one of []interface {}{\"FILTER_TYPE_BLOCK\", \"FILTER_TYPE_DOCUMENT\"}): \"FILTER_TYPE_SOME_OTHER\"", }, { name: "validate project within cwd", @@ -54,7 +74,7 @@ project: project: root: '..' `, - errorSubstring: "failed to validate config: failed to validate project dir: outside of the current working directory", + errorSubstring: "failed to validate v1alpha1 config: project.root: outside of the current working directory", }, { name: "validate filename within cwd", @@ -62,13 +82,13 @@ project: project: filename: '../README.md' `, - errorSubstring: "failed to validate config: failed to validate filename: outside of the current working directory", + errorSubstring: "failed to validate v1alpha1 config: project.filename: outside of the current working directory", }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { - config, err := ParseYAML([]byte(tc.rawConfig)) + config, err := parseYAML([]byte(tc.rawConfig)) if tc.errorSubstring != "" { require.Error(t, err) @@ -90,6 +110,53 @@ project: } } +func Test_parseYAML_Multiple(t *testing.T) { + cfg1 := []byte(`version: v1alpha1`) + cfg2 := []byte(`version: v1alpha1 +project: + filename: README.md +`) + expected := &Config{ + Version: "v1alpha1", + Project: ConfigProject{ + Filename: "README.md", + }, + } + + config, err := parseYAML(cfg1, cfg2) + require.NoError(t, err) + require.True( + t, + cmp.Equal( + expected, + config, + cmpopts.IgnoreUnexported(Filter{}), + ), + "%s", cmp.Diff(expected, config, cmpopts.IgnoreUnexported(Filter{})), + ) +} + +func TestParseYAML(t *testing.T) { + got, err := ParseYAML([]byte(testConfigV1alpha1Raw)) + require.NoError(t, err) + expected := *testConfigV1alpha1 + expected.Server = &ConfigServer{ + Address: "localhost:7998", + Tls: &ConfigServerTls{ + Enabled: true, + }, + } + require.True( + t, + cmp.Equal( + &expected, + got, + cmpopts.IgnoreUnexported(Filter{}), + ), + "%s", cmp.Diff(&expected, got, cmpopts.IgnoreUnexported(Filter{})), + ) +} + var ( testConfigV1alpha1Raw = `version: v1alpha1 @@ -124,44 +191,39 @@ log: ` testConfigV1alpha1 = &Config{ - ProjectRoot: ".", - ProjectFindRepoUpward: true, - ProjectIgnorePaths: []string{"node_modules", ".venv"}, - ProjectDisableGitignore: false, - ProjectEnvSources: []string{".env"}, - ProjectFilters: []*Filter{ - { - Type: "FILTER_TYPE_BLOCK", - Condition: "name != ''", + Version: "v1alpha1", + + Project: ConfigProject{ + Root: ".", + FindRepoUpward: true, + Ignore: []string{"node_modules", ".venv"}, + DisableGitignore: false, + Env: &ConfigProjectEnv{ + Sources: []string{".env"}, + }, + Filters: []ConfigProjectFiltersElem{ + { + Type: ConfigProjectFiltersElemTypeFILTERTYPEBLOCK, + Condition: "name != ''", + }, }, }, - RuntimeDockerEnabled: false, - RuntimeDockerImage: "runme-runner:latest", - RuntimeDockerBuildContext: "./experimental/docker", - RuntimeDockerBuildDockerfile: "Dockerfile", - - LogEnabled: true, - LogPath: "/var/tmp/runme.log", - LogVerbose: true, + Runtime: &ConfigRuntime{ + Docker: &ConfigRuntimeDocker{ + Enabled: false, + Image: "runme-runner:latest", + Build: &ConfigRuntimeDockerBuild{ + Context: "./experimental/docker", + Dockerfile: "Dockerfile", + }, + }, + }, - ServerTLSEnabled: true, + Log: &ConfigLog{ + Enabled: true, + Path: "/var/tmp/runme.log", + Verbose: true, + }, } ) - -func TestCloneConfig(t *testing.T) { - original := defaults - clone := original.Clone() - - opts := cmpopts.EquateEmpty() - require.True( - t, - cmp.Equal(&original, clone, opts), - "%s", - cmp.Diff(&original, clone, opts), - ) - require.False(t, &original == clone) - require.False(t, &original.ProjectIgnorePaths == &clone.ProjectIgnorePaths) - require.False(t, &original.ProjectEnvSources == &clone.ProjectEnvSources) - require.False(t, &original.ProjectFilters == &clone.ProjectFilters) -} diff --git a/internal/config/loader.go b/internal/config/loader.go index 0ba2739d3..fb29b75b0 100644 --- a/internal/config/loader.go +++ b/internal/config/loader.go @@ -10,6 +10,8 @@ import ( "go.uber.org/zap" ) +const defaultNestedConfigFileName = "runme.yaml" + var ErrRootConfigNotFound = errors.New("root configuration file not found") // Loader allows to load configuration files from a file system. @@ -19,12 +21,8 @@ type Loader struct { // the current working directory. configRootPath fs.FS - // configName is a name of the configuration file. - configName string - - // configType is a type of the configuration file. - // Together with configName it forms a configFile. - configType string + // configNames is a list of configuration files. + configNames []string // projectRootPath is a path to the project root directory. // If not empty, it is used to find nested configuration files, @@ -48,15 +46,14 @@ func WithProjectRootPath(projectRootPath fs.FS) LoaderOption { } } -func NewLoader(configName, configType string, configRootPath fs.FS, opts ...LoaderOption) *Loader { - if configName == "" { - panic("config name is not set") +func NewLoader(configNames []string, configRootPath fs.FS, opts ...LoaderOption) *Loader { + if len(configNames) == 0 { + configNames = []string{"runme.yaml"} } l := &Loader{ configRootPath: configRootPath, - configName: configName, - configType: configType, + configNames: configNames, } for _, opt := range opts { @@ -70,13 +67,6 @@ func NewLoader(configName, configType string, configRootPath fs.FS, opts ...Load return l } -func (l *Loader) configFullName() string { - if l.configType == "" { - return l.configName - } - return l.configName + "." + l.configType -} - func (l *Loader) SetConfigRootPath(configRootPath fs.FS) { l.configRootPath = configRootPath } @@ -89,12 +79,23 @@ func (l *Loader) FindConfigChain(path string) ([][]byte, error) { return l.readFiles(paths...) } -func (l *Loader) RootConfig() ([]byte, error) { - data, err := fs.ReadFile(l.configRootPath, l.configFullName()) - if err != nil { +func (l *Loader) RootConfigs() ([][]byte, error) { + result := make([][]byte, 0, len(l.configNames)) + + for _, name := range l.configNames { + data, err := fs.ReadFile(l.configRootPath, name) + if err != nil && !errors.Is(err, fs.ErrNotExist) { + return nil, errors.WithStack(err) + } + if err == nil { + result = append(result, data) + } + } + + if len(result) == 0 { return nil, ErrRootConfigNotFound } - return data, nil + return result, nil } func (l *Loader) findConfigFilesOnPath(name string) (result []string, _ error) { @@ -104,16 +105,16 @@ func (l *Loader) findConfigFilesOnPath(name string) (result []string, _ error) { } l.logger.Debug("finding config files on path", zap.String("name", name)) - configFullName := l.configFullName() - - // Find the root configuration file and add it to the result if exists. + // Find the root configuration files and add each of them to the result if exists. // It is always searched in the config root directory. - _, err = fs.Stat(l.configRootPath, configFullName) - if err == nil { - result = append(result, configFullName) - } else if !errors.Is(err, fs.ErrNotExist) { - l.logger.Debug("root configuration file not found", zap.Error(err)) - return nil, err + for _, name := range l.configNames { + _, err := fs.Stat(l.configRootPath, name) + if err == nil { + result = append(result, name) + } else if !errors.Is(err, fs.ErrNotExist) { + l.logger.Debug("root configuration file not found", zap.Error(err)) + return nil, err + } } // Detect the file system to use for nested configuration files. @@ -135,7 +136,7 @@ func (l *Loader) findConfigFilesOnPath(name string) (result []string, _ error) { // It works well with [fs.FS]. curDir = path.Join(curDir, fragment) - configPath := path.Join(curDir, configFullName) + configPath := path.Join(curDir, defaultNestedConfigFileName) l.logger.Debug("checking nested configuration file", zap.String("path", configPath)) _, err := fs.Stat(fsys, configPath) if err == nil { diff --git a/internal/config/loader_test.go b/internal/config/loader_test.go index 897313c4c..f339427e0 100644 --- a/internal/config/loader_test.go +++ b/internal/config/loader_test.go @@ -12,9 +12,9 @@ import ( func TestNewLoader(t *testing.T) { t.Parallel() - require.Panics(t, func() { - NewLoader("", "yaml", fstest.MapFS{}) - }, "config name is not set") + require.NotPanics(t, func() { + NewLoader(nil, fstest.MapFS{}) + }) } func TestLoader_RootConfig(t *testing.T) { @@ -24,10 +24,10 @@ func TestLoader_RootConfig(t *testing.T) { t.Parallel() fsys := fstest.MapFS{} - loader := NewLoader("runme", "yaml", fsys, WithLogger(zaptest.NewLogger(t))) - result, err := loader.RootConfig() + loader := NewLoader(nil, fsys, WithLogger(zaptest.NewLogger(t))) + items, err := loader.RootConfigs() require.ErrorIs(t, err, ErrRootConfigNotFound) - require.Nil(t, result) + require.Nil(t, items) }) t.Run("with root config", func(t *testing.T) { @@ -39,10 +39,10 @@ func TestLoader_RootConfig(t *testing.T) { Data: data, }, } - loader := NewLoader("runme", "yaml", fsys, WithLogger(zaptest.NewLogger(t))) - result, err := loader.RootConfig() + loader := NewLoader(nil, fsys, WithLogger(zaptest.NewLogger(t))) + items, err := loader.RootConfigs() require.NoError(t, err) - require.Equal(t, data, result) + require.Equal(t, [][]byte{data}, items) }) } @@ -53,7 +53,7 @@ func TestLoader_ChainConfigs(t *testing.T) { t.Parallel() fsys := fstest.MapFS{} - loader := NewLoader("runme", "yaml", fsys, WithLogger(zaptest.NewLogger(t))) + loader := NewLoader(nil, fsys, WithLogger(zaptest.NewLogger(t))) result, err := loader.FindConfigChain("") require.NoError(t, err) require.Nil(t, result) @@ -77,7 +77,7 @@ func TestLoader_ChainConfigs(t *testing.T) { Mode: fs.ModeDir, }, } - loader := NewLoader("runme", "yaml", fsys, WithLogger(zaptest.NewLogger(t))) + loader := NewLoader(nil, fsys, WithLogger(zaptest.NewLogger(t))) t.Run("root config", func(t *testing.T) { result, err := loader.FindConfigChain("") diff --git a/internal/config/runme.default.yaml b/internal/config/runme.default.yaml new file mode 100644 index 000000000..877375263 --- /dev/null +++ b/internal/config/runme.default.yaml @@ -0,0 +1,34 @@ +version: v1alpha1 + +# Settings that apply on at the project level. +project: + # Indicate the root of the runme project. "." means that + # the project root directory will be used. + root: "." + # If true, the project root will be searched upwards starting from "dir". + # If found, the repo root will be used as the project root. + find_repo_upward: true + ignore: + - "node_modules" + - ".venv" + disable_gitignore: false + + # List of dotenv files to load. + env: + use_system_env: false + sources: + - ".env" + - ".env.local" + +server: + # Also unix:///path/to/file.sock is supported. + address: localhost:7998 + tls: + enabled: true + # If not specified, default paths will be used. + # cert_file: "/path/to/cert.pem" + # key_file: "/path/to/key.pem" + +log: + enabled: false + path: "/var/log/runme.log" diff --git a/pkg/api/gen/proto/go/runme/config/v1alpha1/config.pb.go b/pkg/api/gen/proto/go/runme/config/v1alpha1/config.pb.go deleted file mode 100644 index 9b25dd17c..000000000 --- a/pkg/api/gen/proto/go/runme/config/v1alpha1/config.pb.go +++ /dev/null @@ -1,1041 +0,0 @@ -// Code generated by protoc-gen-go. DO NOT EDIT. -// versions: -// protoc-gen-go v1.34.2 -// protoc (unknown) -// source: runme/config/v1alpha1/config.proto - -package configv1alpha1 - -import ( - _ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate" - protoreflect "google.golang.org/protobuf/reflect/protoreflect" - protoimpl "google.golang.org/protobuf/runtime/protoimpl" - wrapperspb "google.golang.org/protobuf/types/known/wrapperspb" - reflect "reflect" - sync "sync" -) - -const ( - // Verify that this generated code is sufficiently up-to-date. - _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) - // Verify that runtime/protoimpl is sufficiently up-to-date. - _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) -) - -type Config_FilterType int32 - -const ( - Config_FILTER_TYPE_UNSPECIFIED Config_FilterType = 0 - Config_FILTER_TYPE_BLOCK Config_FilterType = 1 - Config_FILTER_TYPE_DOCUMENT Config_FilterType = 2 -) - -// Enum value maps for Config_FilterType. -var ( - Config_FilterType_name = map[int32]string{ - 0: "FILTER_TYPE_UNSPECIFIED", - 1: "FILTER_TYPE_BLOCK", - 2: "FILTER_TYPE_DOCUMENT", - } - Config_FilterType_value = map[string]int32{ - "FILTER_TYPE_UNSPECIFIED": 0, - "FILTER_TYPE_BLOCK": 1, - "FILTER_TYPE_DOCUMENT": 2, - } -) - -func (x Config_FilterType) Enum() *Config_FilterType { - p := new(Config_FilterType) - *p = x - return p -} - -func (x Config_FilterType) String() string { - return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) -} - -func (Config_FilterType) Descriptor() protoreflect.EnumDescriptor { - return file_runme_config_v1alpha1_config_proto_enumTypes[0].Descriptor() -} - -func (Config_FilterType) Type() protoreflect.EnumType { - return &file_runme_config_v1alpha1_config_proto_enumTypes[0] -} - -func (x Config_FilterType) Number() protoreflect.EnumNumber { - return protoreflect.EnumNumber(x) -} - -// Deprecated: Use Config_FilterType.Descriptor instead. -func (Config_FilterType) EnumDescriptor() ([]byte, []int) { - return file_runme_config_v1alpha1_config_proto_rawDescGZIP(), []int{0, 0} -} - -// Config describes the configuration of the runme tools, including CLI, server, and clients like VS Code extension. -type Config struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Project *Config_Project `protobuf:"bytes,1,opt,name=project,proto3" json:"project,omitempty"` - Runtime *Config_Runtime `protobuf:"bytes,2,opt,name=runtime,proto3" json:"runtime,omitempty"` - Server *Config_Server `protobuf:"bytes,3,opt,name=server,proto3" json:"server,omitempty"` - Log *Config_Log `protobuf:"bytes,4,opt,name=log,proto3" json:"log,omitempty"` -} - -func (x *Config) Reset() { - *x = Config{} - if protoimpl.UnsafeEnabled { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[0] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Config) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Config) ProtoMessage() {} - -func (x *Config) ProtoReflect() protoreflect.Message { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[0] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Config.ProtoReflect.Descriptor instead. -func (*Config) Descriptor() ([]byte, []int) { - return file_runme_config_v1alpha1_config_proto_rawDescGZIP(), []int{0} -} - -func (x *Config) GetProject() *Config_Project { - if x != nil { - return x.Project - } - return nil -} - -func (x *Config) GetRuntime() *Config_Runtime { - if x != nil { - return x.Runtime - } - return nil -} - -func (x *Config) GetServer() *Config_Server { - if x != nil { - return x.Server - } - return nil -} - -func (x *Config) GetLog() *Config_Log { - if x != nil { - return x.Log - } - return nil -} - -type Config_Project struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // root is the root directory of the project. - Root string `protobuf:"bytes,1,opt,name=root,proto3" json:"root,omitempty"` - // filename is the filename to look for in the project. - // It effectively narrows down to search code blocks - // within a single file. - // - // If root is empty, it should be the absolute path. - // Otherwise, it should be a relative path to the root. - Filename string `protobuf:"bytes,2,opt,name=filename,proto3" json:"filename,omitempty"` - // find_repo_upward indicates whether to find the nearest Git repository upward. - // This is useful to, for example, recognize .gitignore files. - FindRepoUpward *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=find_repo_upward,json=findRepoUpward,proto3" json:"find_repo_upward,omitempty"` - // ignore_paths is a list of paths to ignore relative to dir. - IgnorePaths []string `protobuf:"bytes,4,rep,name=ignore_paths,json=ignore,proto3" json:"ignore_paths,omitempty"` - // disable_gitignore indicates whether to disable the .gitignore file. - DisableGitignore *wrapperspb.BoolValue `protobuf:"bytes,5,opt,name=disable_gitignore,json=disableGitignore,proto3" json:"disable_gitignore,omitempty"` - // env is the environment variables configuration. - Env *Config_Env `protobuf:"bytes,6,opt,name=env,proto3" json:"env,omitempty"` - // filters is a list of filters to apply. - // They can be applied to documents or - // individual code blocks. - Filters []*Config_Filter `protobuf:"bytes,7,rep,name=filters,proto3" json:"filters,omitempty"` -} - -func (x *Config_Project) Reset() { - *x = Config_Project{} - if protoimpl.UnsafeEnabled { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[1] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Config_Project) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Config_Project) ProtoMessage() {} - -func (x *Config_Project) ProtoReflect() protoreflect.Message { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[1] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Config_Project.ProtoReflect.Descriptor instead. -func (*Config_Project) Descriptor() ([]byte, []int) { - return file_runme_config_v1alpha1_config_proto_rawDescGZIP(), []int{0, 0} -} - -func (x *Config_Project) GetRoot() string { - if x != nil { - return x.Root - } - return "" -} - -func (x *Config_Project) GetFilename() string { - if x != nil { - return x.Filename - } - return "" -} - -func (x *Config_Project) GetFindRepoUpward() *wrapperspb.BoolValue { - if x != nil { - return x.FindRepoUpward - } - return nil -} - -func (x *Config_Project) GetIgnorePaths() []string { - if x != nil { - return x.IgnorePaths - } - return nil -} - -func (x *Config_Project) GetDisableGitignore() *wrapperspb.BoolValue { - if x != nil { - return x.DisableGitignore - } - return nil -} - -func (x *Config_Project) GetEnv() *Config_Env { - if x != nil { - return x.Env - } - return nil -} - -func (x *Config_Project) GetFilters() []*Config_Filter { - if x != nil { - return x.Filters - } - return nil -} - -type Config_Env struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // use_system_env indicates whether to use the system environment variables. - UseSystemEnv *wrapperspb.BoolValue `protobuf:"bytes,1,opt,name=use_system_env,json=useSystemEnv,proto3" json:"use_system_env,omitempty"` - // sources is a list of files with env. - Sources []string `protobuf:"bytes,2,rep,name=sources,proto3" json:"sources,omitempty"` -} - -func (x *Config_Env) Reset() { - *x = Config_Env{} - if protoimpl.UnsafeEnabled { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[2] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Config_Env) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Config_Env) ProtoMessage() {} - -func (x *Config_Env) ProtoReflect() protoreflect.Message { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[2] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Config_Env.ProtoReflect.Descriptor instead. -func (*Config_Env) Descriptor() ([]byte, []int) { - return file_runme_config_v1alpha1_config_proto_rawDescGZIP(), []int{0, 1} -} - -func (x *Config_Env) GetUseSystemEnv() *wrapperspb.BoolValue { - if x != nil { - return x.UseSystemEnv - } - return nil -} - -func (x *Config_Env) GetSources() []string { - if x != nil { - return x.Sources - } - return nil -} - -type Config_Filter struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // type is the type of the filter. - Type Config_FilterType `protobuf:"varint,1,opt,name=type,proto3,enum=runme.config.v1alpha1.Config_FilterType" json:"type,omitempty"` - // condition is the filter program to execute for each document or block, - // depending on the filter type. - // - // The condition should be a valid Expr expression and it should return a boolean value. - // You can read more about the Expr syntax on https://expr-lang.org/. - Condition string `protobuf:"bytes,2,opt,name=condition,proto3" json:"condition,omitempty"` -} - -func (x *Config_Filter) Reset() { - *x = Config_Filter{} - if protoimpl.UnsafeEnabled { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[3] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Config_Filter) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Config_Filter) ProtoMessage() {} - -func (x *Config_Filter) ProtoReflect() protoreflect.Message { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[3] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Config_Filter.ProtoReflect.Descriptor instead. -func (*Config_Filter) Descriptor() ([]byte, []int) { - return file_runme_config_v1alpha1_config_proto_rawDescGZIP(), []int{0, 2} -} - -func (x *Config_Filter) GetType() Config_FilterType { - if x != nil { - return x.Type - } - return Config_FILTER_TYPE_UNSPECIFIED -} - -func (x *Config_Filter) GetCondition() string { - if x != nil { - return x.Condition - } - return "" -} - -type Config_Runtime struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Docker *Config_Docker `protobuf:"bytes,1,opt,name=docker,proto3,oneof" json:"docker,omitempty"` -} - -func (x *Config_Runtime) Reset() { - *x = Config_Runtime{} - if protoimpl.UnsafeEnabled { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[4] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Config_Runtime) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Config_Runtime) ProtoMessage() {} - -func (x *Config_Runtime) ProtoReflect() protoreflect.Message { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[4] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Config_Runtime.ProtoReflect.Descriptor instead. -func (*Config_Runtime) Descriptor() ([]byte, []int) { - return file_runme_config_v1alpha1_config_proto_rawDescGZIP(), []int{0, 3} -} - -func (x *Config_Runtime) GetDocker() *Config_Docker { - if x != nil { - return x.Docker - } - return nil -} - -type Config_Docker struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Enabled *wrapperspb.BoolValue `protobuf:"bytes,1,opt,name=enabled,proto3" json:"enabled,omitempty"` - Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"` - Build *Config_Docker_Build `protobuf:"bytes,3,opt,name=build,proto3" json:"build,omitempty"` -} - -func (x *Config_Docker) Reset() { - *x = Config_Docker{} - if protoimpl.UnsafeEnabled { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[5] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Config_Docker) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Config_Docker) ProtoMessage() {} - -func (x *Config_Docker) ProtoReflect() protoreflect.Message { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[5] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Config_Docker.ProtoReflect.Descriptor instead. -func (*Config_Docker) Descriptor() ([]byte, []int) { - return file_runme_config_v1alpha1_config_proto_rawDescGZIP(), []int{0, 4} -} - -func (x *Config_Docker) GetEnabled() *wrapperspb.BoolValue { - if x != nil { - return x.Enabled - } - return nil -} - -func (x *Config_Docker) GetImage() string { - if x != nil { - return x.Image - } - return "" -} - -func (x *Config_Docker) GetBuild() *Config_Docker_Build { - if x != nil { - return x.Build - } - return nil -} - -type Config_Server struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` - Tls *Config_Server_TLS `protobuf:"bytes,2,opt,name=tls,proto3" json:"tls,omitempty"` -} - -func (x *Config_Server) Reset() { - *x = Config_Server{} - if protoimpl.UnsafeEnabled { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[6] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Config_Server) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Config_Server) ProtoMessage() {} - -func (x *Config_Server) ProtoReflect() protoreflect.Message { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[6] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Config_Server.ProtoReflect.Descriptor instead. -func (*Config_Server) Descriptor() ([]byte, []int) { - return file_runme_config_v1alpha1_config_proto_rawDescGZIP(), []int{0, 5} -} - -func (x *Config_Server) GetAddress() string { - if x != nil { - return x.Address - } - return "" -} - -func (x *Config_Server) GetTls() *Config_Server_TLS { - if x != nil { - return x.Tls - } - return nil -} - -type Config_Log struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // enabled indicates whether to enable logging. - Enabled *wrapperspb.BoolValue `protobuf:"bytes,1,opt,name=enabled,proto3" json:"enabled,omitempty"` - // path is the path to the log output file. - Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"` - // verbose is the verbosity level of the log. - Verbose *wrapperspb.BoolValue `protobuf:"bytes,3,opt,name=verbose,proto3" json:"verbose,omitempty"` -} - -func (x *Config_Log) Reset() { - *x = Config_Log{} - if protoimpl.UnsafeEnabled { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[7] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Config_Log) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Config_Log) ProtoMessage() {} - -func (x *Config_Log) ProtoReflect() protoreflect.Message { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[7] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Config_Log.ProtoReflect.Descriptor instead. -func (*Config_Log) Descriptor() ([]byte, []int) { - return file_runme_config_v1alpha1_config_proto_rawDescGZIP(), []int{0, 6} -} - -func (x *Config_Log) GetEnabled() *wrapperspb.BoolValue { - if x != nil { - return x.Enabled - } - return nil -} - -func (x *Config_Log) GetPath() string { - if x != nil { - return x.Path - } - return "" -} - -func (x *Config_Log) GetVerbose() *wrapperspb.BoolValue { - if x != nil { - return x.Verbose - } - return nil -} - -type Config_Docker_Build struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Context string `protobuf:"bytes,1,opt,name=context,proto3" json:"context,omitempty"` - Dockerfile string `protobuf:"bytes,2,opt,name=dockerfile,proto3" json:"dockerfile,omitempty"` -} - -func (x *Config_Docker_Build) Reset() { - *x = Config_Docker_Build{} - if protoimpl.UnsafeEnabled { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[8] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Config_Docker_Build) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Config_Docker_Build) ProtoMessage() {} - -func (x *Config_Docker_Build) ProtoReflect() protoreflect.Message { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[8] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Config_Docker_Build.ProtoReflect.Descriptor instead. -func (*Config_Docker_Build) Descriptor() ([]byte, []int) { - return file_runme_config_v1alpha1_config_proto_rawDescGZIP(), []int{0, 4, 0} -} - -func (x *Config_Docker_Build) GetContext() string { - if x != nil { - return x.Context - } - return "" -} - -func (x *Config_Docker_Build) GetDockerfile() string { - if x != nil { - return x.Dockerfile - } - return "" -} - -type Config_Server_TLS struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Enabled *wrapperspb.BoolValue `protobuf:"bytes,1,opt,name=enabled,proto3" json:"enabled,omitempty"` - CertFile string `protobuf:"bytes,2,opt,name=cert_file,json=certFile,proto3" json:"cert_file,omitempty"` - KeyFile string `protobuf:"bytes,3,opt,name=key_file,json=keyFile,proto3" json:"key_file,omitempty"` -} - -func (x *Config_Server_TLS) Reset() { - *x = Config_Server_TLS{} - if protoimpl.UnsafeEnabled { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[9] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Config_Server_TLS) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Config_Server_TLS) ProtoMessage() {} - -func (x *Config_Server_TLS) ProtoReflect() protoreflect.Message { - mi := &file_runme_config_v1alpha1_config_proto_msgTypes[9] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Config_Server_TLS.ProtoReflect.Descriptor instead. -func (*Config_Server_TLS) Descriptor() ([]byte, []int) { - return file_runme_config_v1alpha1_config_proto_rawDescGZIP(), []int{0, 5, 0} -} - -func (x *Config_Server_TLS) GetEnabled() *wrapperspb.BoolValue { - if x != nil { - return x.Enabled - } - return nil -} - -func (x *Config_Server_TLS) GetCertFile() string { - if x != nil { - return x.CertFile - } - return "" -} - -func (x *Config_Server_TLS) GetKeyFile() string { - if x != nil { - return x.KeyFile - } - return "" -} - -var File_runme_config_v1alpha1_config_proto protoreflect.FileDescriptor - -var file_runme_config_v1alpha1_config_proto_rawDesc = []byte{ - 0x0a, 0x22, 0x72, 0x75, 0x6e, 0x6d, 0x65, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2f, 0x76, - 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x72, 0x75, 0x6e, 0x6d, 0x65, 0x2e, 0x63, 0x6f, 0x6e, 0x66, - 0x69, 0x67, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x1a, 0x1b, 0x62, 0x75, 0x66, - 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, - 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, - 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, - 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa9, 0x0c, 0x0a, 0x06, 0x43, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x12, 0x3f, 0x0a, 0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x72, 0x75, 0x6e, 0x6d, 0x65, 0x2e, 0x63, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x2e, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x07, 0x70, 0x72, 0x6f, - 0x6a, 0x65, 0x63, 0x74, 0x12, 0x3f, 0x0a, 0x07, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x72, 0x75, 0x6e, 0x6d, 0x65, 0x2e, 0x63, 0x6f, - 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, - 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x52, 0x07, 0x72, 0x75, - 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x3c, 0x0a, 0x06, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x75, 0x6e, 0x6d, 0x65, 0x2e, 0x63, 0x6f, - 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, - 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x06, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x12, 0x33, 0x0a, 0x03, 0x6c, 0x6f, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x21, 0x2e, 0x72, 0x75, 0x6e, 0x6d, 0x65, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, - 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, - 0x4c, 0x6f, 0x67, 0x52, 0x03, 0x6c, 0x6f, 0x67, 0x1a, 0xdb, 0x02, 0x0a, 0x07, 0x50, 0x72, 0x6f, - 0x6a, 0x65, 0x63, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x04, 0x72, 0x6f, 0x6f, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x6c, 0x65, - 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, - 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x44, 0x0a, 0x10, 0x66, 0x69, 0x6e, 0x64, 0x5f, 0x72, 0x65, 0x70, - 0x6f, 0x5f, 0x75, 0x70, 0x77, 0x61, 0x72, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, - 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, - 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0e, 0x66, 0x69, 0x6e, 0x64, - 0x52, 0x65, 0x70, 0x6f, 0x55, 0x70, 0x77, 0x61, 0x72, 0x64, 0x12, 0x1c, 0x0a, 0x0c, 0x69, 0x67, - 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, - 0x52, 0x06, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x12, 0x47, 0x0a, 0x11, 0x64, 0x69, 0x73, 0x61, - 0x62, 0x6c, 0x65, 0x5f, 0x67, 0x69, 0x74, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, - 0x10, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x47, 0x69, 0x74, 0x69, 0x67, 0x6e, 0x6f, 0x72, - 0x65, 0x12, 0x33, 0x0a, 0x03, 0x65, 0x6e, 0x76, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, - 0x2e, 0x72, 0x75, 0x6e, 0x6d, 0x65, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x76, 0x31, - 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x45, 0x6e, - 0x76, 0x52, 0x03, 0x65, 0x6e, 0x76, 0x12, 0x3e, 0x0a, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, - 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x72, 0x75, 0x6e, 0x6d, 0x65, 0x2e, - 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, - 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x07, 0x66, - 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x1a, 0x61, 0x0a, 0x03, 0x45, 0x6e, 0x76, 0x12, 0x40, 0x0a, - 0x0e, 0x75, 0x73, 0x65, 0x5f, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x5f, 0x65, 0x6e, 0x76, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, - 0x65, 0x52, 0x0c, 0x75, 0x73, 0x65, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x45, 0x6e, 0x76, 0x12, - 0x18, 0x0a, 0x07, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, - 0x52, 0x07, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x1a, 0x7a, 0x0a, 0x06, 0x46, 0x69, 0x6c, - 0x74, 0x65, 0x72, 0x12, 0x46, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0e, 0x32, 0x28, 0x2e, 0x72, 0x75, 0x6e, 0x6d, 0x65, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, - 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, - 0x2e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x42, 0x08, 0xba, 0x48, 0x05, - 0x82, 0x01, 0x02, 0x10, 0x01, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x28, 0x0a, 0x09, 0x63, - 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0a, - 0xba, 0x48, 0x07, 0x72, 0x05, 0x10, 0x01, 0x18, 0x80, 0x08, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x64, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x57, 0x0a, 0x07, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, - 0x12, 0x41, 0x0a, 0x06, 0x64, 0x6f, 0x63, 0x6b, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x24, 0x2e, 0x72, 0x75, 0x6e, 0x6d, 0x65, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, - 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, - 0x44, 0x6f, 0x63, 0x6b, 0x65, 0x72, 0x48, 0x00, 0x52, 0x06, 0x64, 0x6f, 0x63, 0x6b, 0x65, 0x72, - 0x88, 0x01, 0x01, 0x42, 0x09, 0x0a, 0x07, 0x5f, 0x64, 0x6f, 0x63, 0x6b, 0x65, 0x72, 0x1a, 0xd9, - 0x01, 0x0a, 0x06, 0x44, 0x6f, 0x63, 0x6b, 0x65, 0x72, 0x12, 0x34, 0x0a, 0x07, 0x65, 0x6e, 0x61, - 0x62, 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, - 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, - 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, - 0x14, 0x0a, 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, - 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x40, 0x0a, 0x05, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x72, 0x75, 0x6e, 0x6d, 0x65, 0x2e, 0x63, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x2e, 0x44, 0x6f, 0x63, 0x6b, 0x65, 0x72, 0x2e, 0x42, 0x75, 0x69, 0x6c, 0x64, - 0x52, 0x05, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x1a, 0x41, 0x0a, 0x05, 0x42, 0x75, 0x69, 0x6c, 0x64, - 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x1e, 0x0a, 0x0a, 0x64, 0x6f, - 0x63, 0x6b, 0x65, 0x72, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, - 0x64, 0x6f, 0x63, 0x6b, 0x65, 0x72, 0x66, 0x69, 0x6c, 0x65, 0x1a, 0xd3, 0x01, 0x0a, 0x06, 0x53, - 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, - 0x3a, 0x0a, 0x03, 0x74, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x72, - 0x75, 0x6e, 0x6d, 0x65, 0x2e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x76, 0x31, 0x61, 0x6c, - 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x53, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x2e, 0x54, 0x4c, 0x53, 0x52, 0x03, 0x74, 0x6c, 0x73, 0x1a, 0x73, 0x0a, 0x03, 0x54, - 0x4c, 0x53, 0x12, 0x34, 0x0a, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, - 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x63, 0x65, 0x72, 0x74, - 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63, 0x65, 0x72, - 0x74, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x5f, 0x66, 0x69, 0x6c, - 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6b, 0x65, 0x79, 0x46, 0x69, 0x6c, 0x65, - 0x1a, 0x85, 0x01, 0x0a, 0x03, 0x4c, 0x6f, 0x67, 0x12, 0x34, 0x0a, 0x07, 0x65, 0x6e, 0x61, 0x62, - 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, - 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, - 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x12, - 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, - 0x74, 0x68, 0x12, 0x34, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x62, 0x6f, 0x73, 0x65, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, - 0x07, 0x76, 0x65, 0x72, 0x62, 0x6f, 0x73, 0x65, 0x22, 0x5a, 0x0a, 0x0a, 0x46, 0x69, 0x6c, 0x74, - 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1b, 0x0a, 0x17, 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, - 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, - 0x44, 0x10, 0x00, 0x12, 0x15, 0x0a, 0x11, 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, 0x5f, 0x54, 0x59, - 0x50, 0x45, 0x5f, 0x42, 0x4c, 0x4f, 0x43, 0x4b, 0x10, 0x01, 0x12, 0x18, 0x0a, 0x14, 0x46, 0x49, - 0x4c, 0x54, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x44, 0x4f, 0x43, 0x55, 0x4d, 0x45, - 0x4e, 0x54, 0x10, 0x02, 0x42, 0x55, 0x5a, 0x53, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, - 0x6f, 0x6d, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x66, 0x75, 0x6c, 0x2f, 0x72, 0x75, 0x6e, 0x6d, - 0x65, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x2f, 0x72, 0x75, 0x6e, 0x6d, 0x65, 0x2f, 0x63, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x63, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x33, -} - -var ( - file_runme_config_v1alpha1_config_proto_rawDescOnce sync.Once - file_runme_config_v1alpha1_config_proto_rawDescData = file_runme_config_v1alpha1_config_proto_rawDesc -) - -func file_runme_config_v1alpha1_config_proto_rawDescGZIP() []byte { - file_runme_config_v1alpha1_config_proto_rawDescOnce.Do(func() { - file_runme_config_v1alpha1_config_proto_rawDescData = protoimpl.X.CompressGZIP(file_runme_config_v1alpha1_config_proto_rawDescData) - }) - return file_runme_config_v1alpha1_config_proto_rawDescData -} - -var file_runme_config_v1alpha1_config_proto_enumTypes = make([]protoimpl.EnumInfo, 1) -var file_runme_config_v1alpha1_config_proto_msgTypes = make([]protoimpl.MessageInfo, 10) -var file_runme_config_v1alpha1_config_proto_goTypes = []any{ - (Config_FilterType)(0), // 0: runme.config.v1alpha1.Config.FilterType - (*Config)(nil), // 1: runme.config.v1alpha1.Config - (*Config_Project)(nil), // 2: runme.config.v1alpha1.Config.Project - (*Config_Env)(nil), // 3: runme.config.v1alpha1.Config.Env - (*Config_Filter)(nil), // 4: runme.config.v1alpha1.Config.Filter - (*Config_Runtime)(nil), // 5: runme.config.v1alpha1.Config.Runtime - (*Config_Docker)(nil), // 6: runme.config.v1alpha1.Config.Docker - (*Config_Server)(nil), // 7: runme.config.v1alpha1.Config.Server - (*Config_Log)(nil), // 8: runme.config.v1alpha1.Config.Log - (*Config_Docker_Build)(nil), // 9: runme.config.v1alpha1.Config.Docker.Build - (*Config_Server_TLS)(nil), // 10: runme.config.v1alpha1.Config.Server.TLS - (*wrapperspb.BoolValue)(nil), // 11: google.protobuf.BoolValue -} -var file_runme_config_v1alpha1_config_proto_depIdxs = []int32{ - 2, // 0: runme.config.v1alpha1.Config.project:type_name -> runme.config.v1alpha1.Config.Project - 5, // 1: runme.config.v1alpha1.Config.runtime:type_name -> runme.config.v1alpha1.Config.Runtime - 7, // 2: runme.config.v1alpha1.Config.server:type_name -> runme.config.v1alpha1.Config.Server - 8, // 3: runme.config.v1alpha1.Config.log:type_name -> runme.config.v1alpha1.Config.Log - 11, // 4: runme.config.v1alpha1.Config.Project.find_repo_upward:type_name -> google.protobuf.BoolValue - 11, // 5: runme.config.v1alpha1.Config.Project.disable_gitignore:type_name -> google.protobuf.BoolValue - 3, // 6: runme.config.v1alpha1.Config.Project.env:type_name -> runme.config.v1alpha1.Config.Env - 4, // 7: runme.config.v1alpha1.Config.Project.filters:type_name -> runme.config.v1alpha1.Config.Filter - 11, // 8: runme.config.v1alpha1.Config.Env.use_system_env:type_name -> google.protobuf.BoolValue - 0, // 9: runme.config.v1alpha1.Config.Filter.type:type_name -> runme.config.v1alpha1.Config.FilterType - 6, // 10: runme.config.v1alpha1.Config.Runtime.docker:type_name -> runme.config.v1alpha1.Config.Docker - 11, // 11: runme.config.v1alpha1.Config.Docker.enabled:type_name -> google.protobuf.BoolValue - 9, // 12: runme.config.v1alpha1.Config.Docker.build:type_name -> runme.config.v1alpha1.Config.Docker.Build - 10, // 13: runme.config.v1alpha1.Config.Server.tls:type_name -> runme.config.v1alpha1.Config.Server.TLS - 11, // 14: runme.config.v1alpha1.Config.Log.enabled:type_name -> google.protobuf.BoolValue - 11, // 15: runme.config.v1alpha1.Config.Log.verbose:type_name -> google.protobuf.BoolValue - 11, // 16: runme.config.v1alpha1.Config.Server.TLS.enabled:type_name -> google.protobuf.BoolValue - 17, // [17:17] is the sub-list for method output_type - 17, // [17:17] is the sub-list for method input_type - 17, // [17:17] is the sub-list for extension type_name - 17, // [17:17] is the sub-list for extension extendee - 0, // [0:17] is the sub-list for field type_name -} - -func init() { file_runme_config_v1alpha1_config_proto_init() } -func file_runme_config_v1alpha1_config_proto_init() { - if File_runme_config_v1alpha1_config_proto != nil { - return - } - if !protoimpl.UnsafeEnabled { - file_runme_config_v1alpha1_config_proto_msgTypes[0].Exporter = func(v any, i int) any { - switch v := v.(*Config); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_runme_config_v1alpha1_config_proto_msgTypes[1].Exporter = func(v any, i int) any { - switch v := v.(*Config_Project); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_runme_config_v1alpha1_config_proto_msgTypes[2].Exporter = func(v any, i int) any { - switch v := v.(*Config_Env); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_runme_config_v1alpha1_config_proto_msgTypes[3].Exporter = func(v any, i int) any { - switch v := v.(*Config_Filter); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_runme_config_v1alpha1_config_proto_msgTypes[4].Exporter = func(v any, i int) any { - switch v := v.(*Config_Runtime); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_runme_config_v1alpha1_config_proto_msgTypes[5].Exporter = func(v any, i int) any { - switch v := v.(*Config_Docker); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_runme_config_v1alpha1_config_proto_msgTypes[6].Exporter = func(v any, i int) any { - switch v := v.(*Config_Server); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_runme_config_v1alpha1_config_proto_msgTypes[7].Exporter = func(v any, i int) any { - switch v := v.(*Config_Log); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_runme_config_v1alpha1_config_proto_msgTypes[8].Exporter = func(v any, i int) any { - switch v := v.(*Config_Docker_Build); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_runme_config_v1alpha1_config_proto_msgTypes[9].Exporter = func(v any, i int) any { - switch v := v.(*Config_Server_TLS); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - } - file_runme_config_v1alpha1_config_proto_msgTypes[4].OneofWrappers = []any{} - type x struct{} - out := protoimpl.TypeBuilder{ - File: protoimpl.DescBuilder{ - GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: file_runme_config_v1alpha1_config_proto_rawDesc, - NumEnums: 1, - NumMessages: 10, - NumExtensions: 0, - NumServices: 0, - }, - GoTypes: file_runme_config_v1alpha1_config_proto_goTypes, - DependencyIndexes: file_runme_config_v1alpha1_config_proto_depIdxs, - EnumInfos: file_runme_config_v1alpha1_config_proto_enumTypes, - MessageInfos: file_runme_config_v1alpha1_config_proto_msgTypes, - }.Build() - File_runme_config_v1alpha1_config_proto = out.File - file_runme_config_v1alpha1_config_proto_rawDesc = nil - file_runme_config_v1alpha1_config_proto_goTypes = nil - file_runme_config_v1alpha1_config_proto_depIdxs = nil -} diff --git a/pkg/api/gen/proto/go/runme/parser/v1/parser.pb.go b/pkg/api/gen/proto/go/runme/parser/v1/parser.pb.go index 599cb45ab..9358d1612 100644 --- a/pkg/api/gen/proto/go/runme/parser/v1/parser.pb.go +++ b/pkg/api/gen/proto/go/runme/parser/v1/parser.pb.go @@ -859,13 +859,14 @@ type Frontmatter struct { sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Shell string `protobuf:"bytes,1,opt,name=shell,proto3" json:"shell,omitempty"` - Cwd string `protobuf:"bytes,2,opt,name=cwd,proto3" json:"cwd,omitempty"` - SkipPrompts bool `protobuf:"varint,3,opt,name=skip_prompts,json=skipPrompts,proto3" json:"skip_prompts,omitempty"` - Runme *FrontmatterRunme `protobuf:"bytes,4,opt,name=runme,proto3" json:"runme,omitempty"` - Category string `protobuf:"bytes,5,opt,name=category,proto3" json:"category,omitempty"` - TerminalRows string `protobuf:"bytes,6,opt,name=terminal_rows,json=terminalRows,proto3" json:"terminal_rows,omitempty"` - Tag string `protobuf:"bytes,7,opt,name=tag,proto3" json:"tag,omitempty"` + Shell string `protobuf:"bytes,1,opt,name=shell,proto3" json:"shell,omitempty"` + Cwd string `protobuf:"bytes,2,opt,name=cwd,proto3" json:"cwd,omitempty"` + SkipPrompts bool `protobuf:"varint,3,opt,name=skip_prompts,json=skipPrompts,proto3" json:"skip_prompts,omitempty"` + Runme *FrontmatterRunme `protobuf:"bytes,4,opt,name=runme,proto3" json:"runme,omitempty"` + // Deprecated category in favor of Tag + Category string `protobuf:"bytes,5,opt,name=category,proto3" json:"category,omitempty"` + TerminalRows string `protobuf:"bytes,6,opt,name=terminal_rows,json=terminalRows,proto3" json:"terminal_rows,omitempty"` + Tag string `protobuf:"bytes,7,opt,name=tag,proto3" json:"tag,omitempty"` } func (x *Frontmatter) Reset() { diff --git a/pkg/api/gen/proto/gql/runme/config/v1alpha1/config.graphql b/pkg/api/gen/proto/gql/runme/config/v1alpha1/config.graphql deleted file mode 100644 index 6c768dd22..000000000 --- a/pkg/api/gen/proto/gql/runme/config/v1alpha1/config.graphql +++ /dev/null @@ -1,3 +0,0 @@ -type Query { - dummy: Boolean -} diff --git a/pkg/api/gen/proto/gql/runme/parser/v1/parser.graphql b/pkg/api/gen/proto/gql/runme/parser/v1/parser.graphql index 1608eeede..645f749a3 100644 --- a/pkg/api/gen/proto/gql/runme/parser/v1/parser.graphql +++ b/pkg/api/gen/proto/gql/runme/parser/v1/parser.graphql @@ -126,6 +126,10 @@ type Frontmatter { cwd: String skipPrompts: Boolean runme: FrontmatterRunme + """ + Deprecated category in favor of Tag + + """ category: String terminalRows: String tag: String @@ -135,6 +139,10 @@ input FrontmatterInput { cwd: String skipPrompts: Boolean runme: FrontmatterRunmeInput + """ + Deprecated category in favor of Tag + + """ category: String terminalRows: String tag: String diff --git a/pkg/api/gen/proto/gql/runme/reporter/v1alpha1/reporter.graphql b/pkg/api/gen/proto/gql/runme/reporter/v1alpha1/reporter.graphql index ff8a8e923..12bd1eedf 100644 --- a/pkg/api/gen/proto/gql/runme/reporter/v1alpha1/reporter.graphql +++ b/pkg/api/gen/proto/gql/runme/reporter/v1alpha1/reporter.graphql @@ -116,6 +116,10 @@ type Frontmatter { cwd: String skipPrompts: Boolean runme: FrontmatterRunme + """ + Deprecated category in favor of Tag + + """ category: String terminalRows: String tag: String @@ -125,6 +129,10 @@ input FrontmatterInput { cwd: String skipPrompts: Boolean runme: FrontmatterRunmeInput + """ + Deprecated category in favor of Tag + + """ category: String terminalRows: String tag: String diff --git a/pkg/api/gen/proto/ts/google/protobuf/descriptor_pb.d.ts b/pkg/api/gen/proto/ts/google/protobuf/descriptor_pb.d.ts deleted file mode 100644 index 04a52b4f8..000000000 --- a/pkg/api/gen/proto/ts/google/protobuf/descriptor_pb.d.ts +++ /dev/null @@ -1,2383 +0,0 @@ -/* eslint-disable */ -// @generated by protobuf-ts 2.9.4 with parameter output_javascript,optimize_code_size,long_type_string,add_pb_suffix,ts_nocheck,eslint_disable -// @generated from protobuf file "google/protobuf/descriptor.proto" (package "google.protobuf", syntax proto2) -// tslint:disable -// @ts-nocheck -// -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// -// -// Author: kenton@google.com (Kenton Varda) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// The messages in this file describe the definitions found in .proto files. -// A valid .proto file can be translated directly to a FileDescriptorProto -// without any other information (e.g. without reading its imports). -// -import type { BinaryWriteOptions } from "@protobuf-ts/runtime"; -import type { IBinaryWriter } from "@protobuf-ts/runtime"; -import type { BinaryReadOptions } from "@protobuf-ts/runtime"; -import type { IBinaryReader } from "@protobuf-ts/runtime"; -import type { PartialMessage } from "@protobuf-ts/runtime"; -import { MessageType } from "@protobuf-ts/runtime"; -/** - * The protocol compiler can output a FileDescriptorSet containing the .proto - * files it parses. - * - * @generated from protobuf message google.protobuf.FileDescriptorSet - */ -export interface FileDescriptorSet { - /** - * @generated from protobuf field: repeated google.protobuf.FileDescriptorProto file = 1; - */ - file: FileDescriptorProto[]; -} -/** - * Describes a complete .proto file. - * - * @generated from protobuf message google.protobuf.FileDescriptorProto - */ -export interface FileDescriptorProto { - /** - * @generated from protobuf field: optional string name = 1; - */ - name?: string; - /** - * @generated from protobuf field: optional string package = 2; - */ - package?: string; - /** - * Names of files imported by this file. - * - * @generated from protobuf field: repeated string dependency = 3; - */ - dependency: string[]; - /** - * Indexes of the public imported files in the dependency list above. - * - * @generated from protobuf field: repeated int32 public_dependency = 10; - */ - publicDependency: number[]; - /** - * Indexes of the weak imported files in the dependency list. - * For Google-internal migration only. Do not use. - * - * @generated from protobuf field: repeated int32 weak_dependency = 11; - */ - weakDependency: number[]; - /** - * All top-level definitions in this file. - * - * @generated from protobuf field: repeated google.protobuf.DescriptorProto message_type = 4; - */ - messageType: DescriptorProto[]; - /** - * @generated from protobuf field: repeated google.protobuf.EnumDescriptorProto enum_type = 5; - */ - enumType: EnumDescriptorProto[]; - /** - * @generated from protobuf field: repeated google.protobuf.ServiceDescriptorProto service = 6; - */ - service: ServiceDescriptorProto[]; - /** - * @generated from protobuf field: repeated google.protobuf.FieldDescriptorProto extension = 7; - */ - extension: FieldDescriptorProto[]; - /** - * @generated from protobuf field: optional google.protobuf.FileOptions options = 8; - */ - options?: FileOptions; - /** - * This field contains optional information about the original source code. - * You may safely remove this entire field without harming runtime - * functionality of the descriptors -- the information is needed only by - * development tools. - * - * @generated from protobuf field: optional google.protobuf.SourceCodeInfo source_code_info = 9; - */ - sourceCodeInfo?: SourceCodeInfo; - /** - * The syntax of the proto file. - * The supported values are "proto2", "proto3", and "editions". - * - * If `edition` is present, this value must be "editions". - * - * @generated from protobuf field: optional string syntax = 12; - */ - syntax?: string; - /** - * The edition of the proto file. - * - * @generated from protobuf field: optional google.protobuf.Edition edition = 14; - */ - edition?: Edition; -} -/** - * Describes a message type. - * - * @generated from protobuf message google.protobuf.DescriptorProto - */ -export interface DescriptorProto { - /** - * @generated from protobuf field: optional string name = 1; - */ - name?: string; - /** - * @generated from protobuf field: repeated google.protobuf.FieldDescriptorProto field = 2; - */ - field: FieldDescriptorProto[]; - /** - * @generated from protobuf field: repeated google.protobuf.FieldDescriptorProto extension = 6; - */ - extension: FieldDescriptorProto[]; - /** - * @generated from protobuf field: repeated google.protobuf.DescriptorProto nested_type = 3; - */ - nestedType: DescriptorProto[]; - /** - * @generated from protobuf field: repeated google.protobuf.EnumDescriptorProto enum_type = 4; - */ - enumType: EnumDescriptorProto[]; - /** - * @generated from protobuf field: repeated google.protobuf.DescriptorProto.ExtensionRange extension_range = 5; - */ - extensionRange: DescriptorProto_ExtensionRange[]; - /** - * @generated from protobuf field: repeated google.protobuf.OneofDescriptorProto oneof_decl = 8; - */ - oneofDecl: OneofDescriptorProto[]; - /** - * @generated from protobuf field: optional google.protobuf.MessageOptions options = 7; - */ - options?: MessageOptions; - /** - * @generated from protobuf field: repeated google.protobuf.DescriptorProto.ReservedRange reserved_range = 9; - */ - reservedRange: DescriptorProto_ReservedRange[]; - /** - * Reserved field names, which may not be used by fields in the same message. - * A given name may only be reserved once. - * - * @generated from protobuf field: repeated string reserved_name = 10; - */ - reservedName: string[]; -} -/** - * @generated from protobuf message google.protobuf.DescriptorProto.ExtensionRange - */ -export interface DescriptorProto_ExtensionRange { - /** - * @generated from protobuf field: optional int32 start = 1; - */ - start?: number; - /** - * @generated from protobuf field: optional int32 end = 2; - */ - end?: number; - /** - * @generated from protobuf field: optional google.protobuf.ExtensionRangeOptions options = 3; - */ - options?: ExtensionRangeOptions; -} -/** - * Range of reserved tag numbers. Reserved tag numbers may not be used by - * fields or extension ranges in the same message. Reserved ranges may - * not overlap. - * - * @generated from protobuf message google.protobuf.DescriptorProto.ReservedRange - */ -export interface DescriptorProto_ReservedRange { - /** - * @generated from protobuf field: optional int32 start = 1; - */ - start?: number; - /** - * @generated from protobuf field: optional int32 end = 2; - */ - end?: number; -} -/** - * @generated from protobuf message google.protobuf.ExtensionRangeOptions - */ -export interface ExtensionRangeOptions { - /** - * The parser stores options it doesn't recognize here. See above. - * - * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; - */ - uninterpretedOption: UninterpretedOption[]; - /** - * For external users: DO NOT USE. We are in the process of open sourcing - * extension declaration and executing internal cleanups before it can be - * used externally. - * - * @generated from protobuf field: repeated google.protobuf.ExtensionRangeOptions.Declaration declaration = 2; - */ - declaration: ExtensionRangeOptions_Declaration[]; - /** - * Any features defined in the specific edition. - * - * @generated from protobuf field: optional google.protobuf.FeatureSet features = 50; - */ - features?: FeatureSet; - /** - * The verification state of the range. - * TODO: flip the default to DECLARATION once all empty ranges - * are marked as UNVERIFIED. - * - * @generated from protobuf field: optional google.protobuf.ExtensionRangeOptions.VerificationState verification = 3; - */ - verification?: ExtensionRangeOptions_VerificationState; -} -/** - * @generated from protobuf message google.protobuf.ExtensionRangeOptions.Declaration - */ -export interface ExtensionRangeOptions_Declaration { - /** - * The extension number declared within the extension range. - * - * @generated from protobuf field: optional int32 number = 1; - */ - number?: number; - /** - * The fully-qualified name of the extension field. There must be a leading - * dot in front of the full name. - * - * @generated from protobuf field: optional string full_name = 2; - */ - fullName?: string; - /** - * The fully-qualified type name of the extension field. Unlike - * Metadata.type, Declaration.type must have a leading dot for messages - * and enums. - * - * @generated from protobuf field: optional string type = 3; - */ - type?: string; - /** - * If true, indicates that the number is reserved in the extension range, - * and any extension field with the number will fail to compile. Set this - * when a declared extension field is deleted. - * - * @generated from protobuf field: optional bool reserved = 5; - */ - reserved?: boolean; - /** - * If true, indicates that the extension must be defined as repeated. - * Otherwise the extension must be defined as optional. - * - * @generated from protobuf field: optional bool repeated = 6; - */ - repeated?: boolean; -} -/** - * The verification state of the extension range. - * - * @generated from protobuf enum google.protobuf.ExtensionRangeOptions.VerificationState - */ -export declare enum ExtensionRangeOptions_VerificationState { - /** - * All the extensions of the range must be declared. - * - * @generated from protobuf enum value: DECLARATION = 0; - */ - DECLARATION = 0, - /** - * @generated from protobuf enum value: UNVERIFIED = 1; - */ - UNVERIFIED = 1 -} -/** - * Describes a field within a message. - * - * @generated from protobuf message google.protobuf.FieldDescriptorProto - */ -export interface FieldDescriptorProto { - /** - * @generated from protobuf field: optional string name = 1; - */ - name?: string; - /** - * @generated from protobuf field: optional int32 number = 3; - */ - number?: number; - /** - * @generated from protobuf field: optional google.protobuf.FieldDescriptorProto.Label label = 4; - */ - label?: FieldDescriptorProto_Label; - /** - * If type_name is set, this need not be set. If both this and type_name - * are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. - * - * @generated from protobuf field: optional google.protobuf.FieldDescriptorProto.Type type = 5; - */ - type?: FieldDescriptorProto_Type; - /** - * For message and enum types, this is the name of the type. If the name - * starts with a '.', it is fully-qualified. Otherwise, C++-like scoping - * rules are used to find the type (i.e. first the nested types within this - * message are searched, then within the parent, on up to the root - * namespace). - * - * @generated from protobuf field: optional string type_name = 6; - */ - typeName?: string; - /** - * For extensions, this is the name of the type being extended. It is - * resolved in the same manner as type_name. - * - * @generated from protobuf field: optional string extendee = 2; - */ - extendee?: string; - /** - * For numeric types, contains the original text representation of the value. - * For booleans, "true" or "false". - * For strings, contains the default text contents (not escaped in any way). - * For bytes, contains the C escaped value. All bytes >= 128 are escaped. - * - * @generated from protobuf field: optional string default_value = 7; - */ - defaultValue?: string; - /** - * If set, gives the index of a oneof in the containing type's oneof_decl - * list. This field is a member of that oneof. - * - * @generated from protobuf field: optional int32 oneof_index = 9; - */ - oneofIndex?: number; - /** - * JSON name of this field. The value is set by protocol compiler. If the - * user has set a "json_name" option on this field, that option's value - * will be used. Otherwise, it's deduced from the field's name by converting - * it to camelCase. - * - * @generated from protobuf field: optional string json_name = 10; - */ - jsonName?: string; - /** - * @generated from protobuf field: optional google.protobuf.FieldOptions options = 8; - */ - options?: FieldOptions; - /** - * If true, this is a proto3 "optional". When a proto3 field is optional, it - * tracks presence regardless of field type. - * - * When proto3_optional is true, this field must belong to a oneof to signal - * to old proto3 clients that presence is tracked for this field. This oneof - * is known as a "synthetic" oneof, and this field must be its sole member - * (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs - * exist in the descriptor only, and do not generate any API. Synthetic oneofs - * must be ordered after all "real" oneofs. - * - * For message fields, proto3_optional doesn't create any semantic change, - * since non-repeated message fields always track presence. However it still - * indicates the semantic detail of whether the user wrote "optional" or not. - * This can be useful for round-tripping the .proto file. For consistency we - * give message fields a synthetic oneof also, even though it is not required - * to track presence. This is especially important because the parser can't - * tell if a field is a message or an enum, so it must always create a - * synthetic oneof. - * - * Proto2 optional fields do not set this flag, because they already indicate - * optional with `LABEL_OPTIONAL`. - * - * @generated from protobuf field: optional bool proto3_optional = 17; - */ - proto3Optional?: boolean; -} -/** - * @generated from protobuf enum google.protobuf.FieldDescriptorProto.Type - */ -export declare enum FieldDescriptorProto_Type { - /** - * @generated synthetic value - protobuf-ts requires all enums to have a 0 value - */ - UNSPECIFIED$ = 0, - /** - * 0 is reserved for errors. - * Order is weird for historical reasons. - * - * @generated from protobuf enum value: TYPE_DOUBLE = 1; - */ - DOUBLE = 1, - /** - * @generated from protobuf enum value: TYPE_FLOAT = 2; - */ - FLOAT = 2, - /** - * Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if - * negative values are likely. - * - * @generated from protobuf enum value: TYPE_INT64 = 3; - */ - INT64 = 3, - /** - * @generated from protobuf enum value: TYPE_UINT64 = 4; - */ - UINT64 = 4, - /** - * Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if - * negative values are likely. - * - * @generated from protobuf enum value: TYPE_INT32 = 5; - */ - INT32 = 5, - /** - * @generated from protobuf enum value: TYPE_FIXED64 = 6; - */ - FIXED64 = 6, - /** - * @generated from protobuf enum value: TYPE_FIXED32 = 7; - */ - FIXED32 = 7, - /** - * @generated from protobuf enum value: TYPE_BOOL = 8; - */ - BOOL = 8, - /** - * @generated from protobuf enum value: TYPE_STRING = 9; - */ - STRING = 9, - /** - * Tag-delimited aggregate. - * Group type is deprecated and not supported after google.protobuf. However, Proto3 - * implementations should still be able to parse the group wire format and - * treat group fields as unknown fields. In Editions, the group wire format - * can be enabled via the `message_encoding` feature. - * - * @generated from protobuf enum value: TYPE_GROUP = 10; - */ - GROUP = 10, - /** - * Length-delimited aggregate. - * - * @generated from protobuf enum value: TYPE_MESSAGE = 11; - */ - MESSAGE = 11, - /** - * New in version 2. - * - * @generated from protobuf enum value: TYPE_BYTES = 12; - */ - BYTES = 12, - /** - * @generated from protobuf enum value: TYPE_UINT32 = 13; - */ - UINT32 = 13, - /** - * @generated from protobuf enum value: TYPE_ENUM = 14; - */ - ENUM = 14, - /** - * @generated from protobuf enum value: TYPE_SFIXED32 = 15; - */ - SFIXED32 = 15, - /** - * @generated from protobuf enum value: TYPE_SFIXED64 = 16; - */ - SFIXED64 = 16, - /** - * Uses ZigZag encoding. - * - * @generated from protobuf enum value: TYPE_SINT32 = 17; - */ - SINT32 = 17, - /** - * Uses ZigZag encoding. - * - * @generated from protobuf enum value: TYPE_SINT64 = 18; - */ - SINT64 = 18 -} -/** - * @generated from protobuf enum google.protobuf.FieldDescriptorProto.Label - */ -export declare enum FieldDescriptorProto_Label { - /** - * @generated synthetic value - protobuf-ts requires all enums to have a 0 value - */ - UNSPECIFIED$ = 0, - /** - * 0 is reserved for errors - * - * @generated from protobuf enum value: LABEL_OPTIONAL = 1; - */ - OPTIONAL = 1, - /** - * @generated from protobuf enum value: LABEL_REPEATED = 3; - */ - REPEATED = 3, - /** - * The required label is only allowed in google.protobuf. In proto3 and Editions - * it's explicitly prohibited. In Editions, the `field_presence` feature - * can be used to get this behavior. - * - * @generated from protobuf enum value: LABEL_REQUIRED = 2; - */ - REQUIRED = 2 -} -/** - * Describes a oneof. - * - * @generated from protobuf message google.protobuf.OneofDescriptorProto - */ -export interface OneofDescriptorProto { - /** - * @generated from protobuf field: optional string name = 1; - */ - name?: string; - /** - * @generated from protobuf field: optional google.protobuf.OneofOptions options = 2; - */ - options?: OneofOptions; -} -/** - * Describes an enum type. - * - * @generated from protobuf message google.protobuf.EnumDescriptorProto - */ -export interface EnumDescriptorProto { - /** - * @generated from protobuf field: optional string name = 1; - */ - name?: string; - /** - * @generated from protobuf field: repeated google.protobuf.EnumValueDescriptorProto value = 2; - */ - value: EnumValueDescriptorProto[]; - /** - * @generated from protobuf field: optional google.protobuf.EnumOptions options = 3; - */ - options?: EnumOptions; - /** - * Range of reserved numeric values. Reserved numeric values may not be used - * by enum values in the same enum declaration. Reserved ranges may not - * overlap. - * - * @generated from protobuf field: repeated google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4; - */ - reservedRange: EnumDescriptorProto_EnumReservedRange[]; - /** - * Reserved enum value names, which may not be reused. A given name may only - * be reserved once. - * - * @generated from protobuf field: repeated string reserved_name = 5; - */ - reservedName: string[]; -} -/** - * Range of reserved numeric values. Reserved values may not be used by - * entries in the same enum. Reserved ranges may not overlap. - * - * Note that this is distinct from DescriptorProto.ReservedRange in that it - * is inclusive such that it can appropriately represent the entire int32 - * domain. - * - * @generated from protobuf message google.protobuf.EnumDescriptorProto.EnumReservedRange - */ -export interface EnumDescriptorProto_EnumReservedRange { - /** - * @generated from protobuf field: optional int32 start = 1; - */ - start?: number; - /** - * @generated from protobuf field: optional int32 end = 2; - */ - end?: number; -} -/** - * Describes a value within an enum. - * - * @generated from protobuf message google.protobuf.EnumValueDescriptorProto - */ -export interface EnumValueDescriptorProto { - /** - * @generated from protobuf field: optional string name = 1; - */ - name?: string; - /** - * @generated from protobuf field: optional int32 number = 2; - */ - number?: number; - /** - * @generated from protobuf field: optional google.protobuf.EnumValueOptions options = 3; - */ - options?: EnumValueOptions; -} -/** - * Describes a service. - * - * @generated from protobuf message google.protobuf.ServiceDescriptorProto - */ -export interface ServiceDescriptorProto { - /** - * @generated from protobuf field: optional string name = 1; - */ - name?: string; - /** - * @generated from protobuf field: repeated google.protobuf.MethodDescriptorProto method = 2; - */ - method: MethodDescriptorProto[]; - /** - * @generated from protobuf field: optional google.protobuf.ServiceOptions options = 3; - */ - options?: ServiceOptions; -} -/** - * Describes a method of a service. - * - * @generated from protobuf message google.protobuf.MethodDescriptorProto - */ -export interface MethodDescriptorProto { - /** - * @generated from protobuf field: optional string name = 1; - */ - name?: string; - /** - * Input and output type names. These are resolved in the same way as - * FieldDescriptorProto.type_name, but must refer to a message type. - * - * @generated from protobuf field: optional string input_type = 2; - */ - inputType?: string; - /** - * @generated from protobuf field: optional string output_type = 3; - */ - outputType?: string; - /** - * @generated from protobuf field: optional google.protobuf.MethodOptions options = 4; - */ - options?: MethodOptions; - /** - * Identifies if client streams multiple client messages - * - * @generated from protobuf field: optional bool client_streaming = 5; - */ - clientStreaming?: boolean; - /** - * Identifies if server streams multiple server messages - * - * @generated from protobuf field: optional bool server_streaming = 6; - */ - serverStreaming?: boolean; -} -/** - * @generated from protobuf message google.protobuf.FileOptions - */ -export interface FileOptions { - /** - * Sets the Java package where classes generated from this .proto will be - * placed. By default, the proto package is used, but this is often - * inappropriate because proto packages do not normally start with backwards - * domain names. - * - * @generated from protobuf field: optional string java_package = 1; - */ - javaPackage?: string; - /** - * Controls the name of the wrapper Java class generated for the .proto file. - * That class will always contain the .proto file's getDescriptor() method as - * well as any top-level extensions defined in the .proto file. - * If java_multiple_files is disabled, then all the other classes from the - * .proto file will be nested inside the single wrapper outer class. - * - * @generated from protobuf field: optional string java_outer_classname = 8; - */ - javaOuterClassname?: string; - /** - * If enabled, then the Java code generator will generate a separate .java - * file for each top-level message, enum, and service defined in the .proto - * file. Thus, these types will *not* be nested inside the wrapper class - * named by java_outer_classname. However, the wrapper class will still be - * generated to contain the file's getDescriptor() method as well as any - * top-level extensions defined in the file. - * - * @generated from protobuf field: optional bool java_multiple_files = 10; - */ - javaMultipleFiles?: boolean; - /** - * This option does nothing. - * - * @deprecated - * @generated from protobuf field: optional bool java_generate_equals_and_hash = 20 [deprecated = true]; - */ - javaGenerateEqualsAndHash?: boolean; - /** - * A proto2 file can set this to true to opt in to UTF-8 checking for Java, - * which will throw an exception if invalid UTF-8 is parsed from the wire or - * assigned to a string field. - * - * TODO: clarify exactly what kinds of field types this option - * applies to, and update these docs accordingly. - * - * Proto3 files already perform these checks. Setting the option explicitly to - * false has no effect: it cannot be used to opt proto3 files out of UTF-8 - * checks. - * - * @generated from protobuf field: optional bool java_string_check_utf8 = 27; - */ - javaStringCheckUtf8?: boolean; - /** - * @generated from protobuf field: optional google.protobuf.FileOptions.OptimizeMode optimize_for = 9; - */ - optimizeFor?: FileOptions_OptimizeMode; - /** - * Sets the Go package where structs generated from this .proto will be - * placed. If omitted, the Go package will be derived from the following: - * - The basename of the package import path, if provided. - * - Otherwise, the package statement in the .proto file, if present. - * - Otherwise, the basename of the .proto file, without extension. - * - * @generated from protobuf field: optional string go_package = 11; - */ - goPackage?: string; - /** - * Should generic services be generated in each language? "Generic" services - * are not specific to any particular RPC system. They are generated by the - * main code generators in each language (without additional plugins). - * Generic services were the only kind of service generation supported by - * early versions of google.protobuf. - * - * Generic services are now considered deprecated in favor of using plugins - * that generate code specific to your particular RPC system. Therefore, - * these default to false. Old code which depends on generic services should - * explicitly set them to true. - * - * @generated from protobuf field: optional bool cc_generic_services = 16; - */ - ccGenericServices?: boolean; - /** - * @generated from protobuf field: optional bool java_generic_services = 17; - */ - javaGenericServices?: boolean; - /** - * @generated from protobuf field: optional bool py_generic_services = 18; - */ - pyGenericServices?: boolean; - /** - * Is this file deprecated? - * Depending on the target platform, this can emit Deprecated annotations - * for everything in the file, or it will be completely ignored; in the very - * least, this is a formalization for deprecating files. - * - * @generated from protobuf field: optional bool deprecated = 23; - */ - deprecated?: boolean; - /** - * Enables the use of arenas for the proto messages in this file. This applies - * only to generated classes for C++. - * - * @generated from protobuf field: optional bool cc_enable_arenas = 31; - */ - ccEnableArenas?: boolean; - /** - * Sets the objective c class prefix which is prepended to all objective c - * generated classes from this .proto. There is no default. - * - * @generated from protobuf field: optional string objc_class_prefix = 36; - */ - objcClassPrefix?: string; - /** - * Namespace for generated classes; defaults to the package. - * - * @generated from protobuf field: optional string csharp_namespace = 37; - */ - csharpNamespace?: string; - /** - * By default Swift generators will take the proto package and CamelCase it - * replacing '.' with underscore and use that to prefix the types/symbols - * defined. When this options is provided, they will use this value instead - * to prefix the types/symbols defined. - * - * @generated from protobuf field: optional string swift_prefix = 39; - */ - swiftPrefix?: string; - /** - * Sets the php class prefix which is prepended to all php generated classes - * from this .proto. Default is empty. - * - * @generated from protobuf field: optional string php_class_prefix = 40; - */ - phpClassPrefix?: string; - /** - * Use this option to change the namespace of php generated classes. Default - * is empty. When this option is empty, the package name will be used for - * determining the namespace. - * - * @generated from protobuf field: optional string php_namespace = 41; - */ - phpNamespace?: string; - /** - * Use this option to change the namespace of php generated metadata classes. - * Default is empty. When this option is empty, the proto file name will be - * used for determining the namespace. - * - * @generated from protobuf field: optional string php_metadata_namespace = 44; - */ - phpMetadataNamespace?: string; - /** - * Use this option to change the package of ruby generated classes. Default - * is empty. When this option is not set, the package name will be used for - * determining the ruby package. - * - * @generated from protobuf field: optional string ruby_package = 45; - */ - rubyPackage?: string; - /** - * Any features defined in the specific edition. - * - * @generated from protobuf field: optional google.protobuf.FeatureSet features = 50; - */ - features?: FeatureSet; - /** - * The parser stores options it doesn't recognize here. - * See the documentation for the "Options" section above. - * - * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; - */ - uninterpretedOption: UninterpretedOption[]; -} -/** - * Generated classes can be optimized for speed or code size. - * - * @generated from protobuf enum google.protobuf.FileOptions.OptimizeMode - */ -export declare enum FileOptions_OptimizeMode { - /** - * @generated synthetic value - protobuf-ts requires all enums to have a 0 value - */ - UNSPECIFIED$ = 0, - /** - * Generate complete code for parsing, serialization, - * - * @generated from protobuf enum value: SPEED = 1; - */ - SPEED = 1, - /** - * etc. - * - * Use ReflectionOps to implement these methods. - * - * @generated from protobuf enum value: CODE_SIZE = 2; - */ - CODE_SIZE = 2, - /** - * Generate code using MessageLite and the lite runtime. - * - * @generated from protobuf enum value: LITE_RUNTIME = 3; - */ - LITE_RUNTIME = 3 -} -/** - * @generated from protobuf message google.protobuf.MessageOptions - */ -export interface MessageOptions { - /** - * Set true to use the old proto1 MessageSet wire format for extensions. - * This is provided for backwards-compatibility with the MessageSet wire - * format. You should not use this for any other reason: It's less - * efficient, has fewer features, and is more complicated. - * - * The message must be defined exactly as follows: - * message Foo { - * option message_set_wire_format = true; - * extensions 4 to max; - * } - * Note that the message cannot have any defined fields; MessageSets only - * have extensions. - * - * All extensions of your type must be singular messages; e.g. they cannot - * be int32s, enums, or repeated messages. - * - * Because this is an option, the above two restrictions are not enforced by - * the protocol compiler. - * - * @generated from protobuf field: optional bool message_set_wire_format = 1; - */ - messageSetWireFormat?: boolean; - /** - * Disables the generation of the standard "descriptor()" accessor, which can - * conflict with a field of the same name. This is meant to make migration - * from proto1 easier; new code should avoid fields named "descriptor". - * - * @generated from protobuf field: optional bool no_standard_descriptor_accessor = 2; - */ - noStandardDescriptorAccessor?: boolean; - /** - * Is this message deprecated? - * Depending on the target platform, this can emit Deprecated annotations - * for the message, or it will be completely ignored; in the very least, - * this is a formalization for deprecating messages. - * - * @generated from protobuf field: optional bool deprecated = 3; - */ - deprecated?: boolean; - /** - * Whether the message is an automatically generated map entry type for the - * maps field. - * - * For maps fields: - * map map_field = 1; - * The parsed descriptor looks like: - * message MapFieldEntry { - * option map_entry = true; - * optional KeyType key = 1; - * optional ValueType value = 2; - * } - * repeated MapFieldEntry map_field = 1; - * - * Implementations may choose not to generate the map_entry=true message, but - * use a native map in the target language to hold the keys and values. - * The reflection APIs in such implementations still need to work as - * if the field is a repeated message field. - * - * NOTE: Do not set the option in .proto files. Always use the maps syntax - * instead. The option should only be implicitly set by the proto compiler - * parser. - * - * @generated from protobuf field: optional bool map_entry = 7; - */ - mapEntry?: boolean; - /** - * Enable the legacy handling of JSON field name conflicts. This lowercases - * and strips underscored from the fields before comparison in proto3 only. - * The new behavior takes `json_name` into account and applies to proto2 as - * well. - * - * This should only be used as a temporary measure against broken builds due - * to the change in behavior for JSON field name conflicts. - * - * TODO This is legacy behavior we plan to remove once downstream - * teams have had time to migrate. - * - * @deprecated - * @generated from protobuf field: optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true]; - */ - deprecatedLegacyJsonFieldConflicts?: boolean; - /** - * Any features defined in the specific edition. - * - * @generated from protobuf field: optional google.protobuf.FeatureSet features = 12; - */ - features?: FeatureSet; - /** - * The parser stores options it doesn't recognize here. See above. - * - * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; - */ - uninterpretedOption: UninterpretedOption[]; -} -/** - * @generated from protobuf message google.protobuf.FieldOptions - */ -export interface FieldOptions { - /** - * The ctype option instructs the C++ code generator to use a different - * representation of the field than it normally would. See the specific - * options below. This option is only implemented to support use of - * [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of - * type "bytes" in the open source release -- sorry, we'll try to include - * other types in a future version! - * - * @generated from protobuf field: optional google.protobuf.FieldOptions.CType ctype = 1; - */ - ctype?: FieldOptions_CType; - /** - * The packed option can be enabled for repeated primitive fields to enable - * a more efficient representation on the wire. Rather than repeatedly - * writing the tag and type for each element, the entire array is encoded as - * a single length-delimited blob. In proto3, only explicit setting it to - * false will avoid using packed encoding. This option is prohibited in - * Editions, but the `repeated_field_encoding` feature can be used to control - * the behavior. - * - * @generated from protobuf field: optional bool packed = 2; - */ - packed?: boolean; - /** - * The jstype option determines the JavaScript type used for values of the - * field. The option is permitted only for 64 bit integral and fixed types - * (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING - * is represented as JavaScript string, which avoids loss of precision that - * can happen when a large value is converted to a floating point JavaScript. - * Specifying JS_NUMBER for the jstype causes the generated JavaScript code to - * use the JavaScript "number" type. The behavior of the default option - * JS_NORMAL is implementation dependent. - * - * This option is an enum to permit additional types to be added, e.g. - * goog.math.Integer. - * - * @generated from protobuf field: optional google.protobuf.FieldOptions.JSType jstype = 6; - */ - jstype?: FieldOptions_JSType; - /** - * Should this field be parsed lazily? Lazy applies only to message-type - * fields. It means that when the outer message is initially parsed, the - * inner message's contents will not be parsed but instead stored in encoded - * form. The inner message will actually be parsed when it is first accessed. - * - * This is only a hint. Implementations are free to choose whether to use - * eager or lazy parsing regardless of the value of this option. However, - * setting this option true suggests that the protocol author believes that - * using lazy parsing on this field is worth the additional bookkeeping - * overhead typically needed to implement it. - * - * This option does not affect the public interface of any generated code; - * all method signatures remain the same. Furthermore, thread-safety of the - * interface is not affected by this option; const methods remain safe to - * call from multiple threads concurrently, while non-const methods continue - * to require exclusive access. - * - * Note that lazy message fields are still eagerly verified to check - * ill-formed wireformat or missing required fields. Calling IsInitialized() - * on the outer message would fail if the inner message has missing required - * fields. Failed verification would result in parsing failure (except when - * uninitialized messages are acceptable). - * - * @generated from protobuf field: optional bool lazy = 5; - */ - lazy?: boolean; - /** - * unverified_lazy does no correctness checks on the byte stream. This should - * only be used where lazy with verification is prohibitive for performance - * reasons. - * - * @generated from protobuf field: optional bool unverified_lazy = 15; - */ - unverifiedLazy?: boolean; - /** - * Is this field deprecated? - * Depending on the target platform, this can emit Deprecated annotations - * for accessors, or it will be completely ignored; in the very least, this - * is a formalization for deprecating fields. - * - * @generated from protobuf field: optional bool deprecated = 3; - */ - deprecated?: boolean; - /** - * For Google-internal migration only. Do not use. - * - * @generated from protobuf field: optional bool weak = 10; - */ - weak?: boolean; - /** - * Indicate that the field value should not be printed out when using debug - * formats, e.g. when the field contains sensitive credentials. - * - * @generated from protobuf field: optional bool debug_redact = 16; - */ - debugRedact?: boolean; - /** - * @generated from protobuf field: optional google.protobuf.FieldOptions.OptionRetention retention = 17; - */ - retention?: FieldOptions_OptionRetention; - /** - * @generated from protobuf field: repeated google.protobuf.FieldOptions.OptionTargetType targets = 19; - */ - targets: FieldOptions_OptionTargetType[]; - /** - * @generated from protobuf field: repeated google.protobuf.FieldOptions.EditionDefault edition_defaults = 20; - */ - editionDefaults: FieldOptions_EditionDefault[]; - /** - * Any features defined in the specific edition. - * - * @generated from protobuf field: optional google.protobuf.FeatureSet features = 21; - */ - features?: FeatureSet; - /** - * @generated from protobuf field: optional google.protobuf.FieldOptions.FeatureSupport feature_support = 22; - */ - featureSupport?: FieldOptions_FeatureSupport; - /** - * The parser stores options it doesn't recognize here. See above. - * - * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; - */ - uninterpretedOption: UninterpretedOption[]; -} -/** - * @generated from protobuf message google.protobuf.FieldOptions.EditionDefault - */ -export interface FieldOptions_EditionDefault { - /** - * @generated from protobuf field: optional google.protobuf.Edition edition = 3; - */ - edition?: Edition; - /** - * @generated from protobuf field: optional string value = 2; - */ - value?: string; -} -/** - * Information about the support window of a feature. - * - * @generated from protobuf message google.protobuf.FieldOptions.FeatureSupport - */ -export interface FieldOptions_FeatureSupport { - /** - * The edition that this feature was first available in. In editions - * earlier than this one, the default assigned to EDITION_LEGACY will be - * used, and proto files will not be able to override it. - * - * @generated from protobuf field: optional google.protobuf.Edition edition_introduced = 1; - */ - editionIntroduced?: Edition; - /** - * The edition this feature becomes deprecated in. Using this after this - * edition may trigger warnings. - * - * @generated from protobuf field: optional google.protobuf.Edition edition_deprecated = 2; - */ - editionDeprecated?: Edition; - /** - * The deprecation warning text if this feature is used after the edition it - * was marked deprecated in. - * - * @generated from protobuf field: optional string deprecation_warning = 3; - */ - deprecationWarning?: string; - /** - * The edition this feature is no longer available in. In editions after - * this one, the last default assigned will be used, and proto files will - * not be able to override it. - * - * @generated from protobuf field: optional google.protobuf.Edition edition_removed = 4; - */ - editionRemoved?: Edition; -} -/** - * @generated from protobuf enum google.protobuf.FieldOptions.CType - */ -export declare enum FieldOptions_CType { - /** - * Default mode. - * - * @generated from protobuf enum value: STRING = 0; - */ - STRING = 0, - /** - * The option [ctype=CORD] may be applied to a non-repeated field of type - * "bytes". It indicates that in C++, the data should be stored in a Cord - * instead of a string. For very large strings, this may reduce memory - * fragmentation. It may also allow better performance when parsing from a - * Cord, or when parsing with aliasing enabled, as the parsed Cord may then - * alias the original buffer. - * - * @generated from protobuf enum value: CORD = 1; - */ - CORD = 1, - /** - * @generated from protobuf enum value: STRING_PIECE = 2; - */ - STRING_PIECE = 2 -} -/** - * @generated from protobuf enum google.protobuf.FieldOptions.JSType - */ -export declare enum FieldOptions_JSType { - /** - * Use the default type. - * - * @generated from protobuf enum value: JS_NORMAL = 0; - */ - JS_NORMAL = 0, - /** - * Use JavaScript strings. - * - * @generated from protobuf enum value: JS_STRING = 1; - */ - JS_STRING = 1, - /** - * Use JavaScript numbers. - * - * @generated from protobuf enum value: JS_NUMBER = 2; - */ - JS_NUMBER = 2 -} -/** - * If set to RETENTION_SOURCE, the option will be omitted from the binary. - * Note: as of January 2023, support for this is in progress and does not yet - * have an effect (b/264593489). - * - * @generated from protobuf enum google.protobuf.FieldOptions.OptionRetention - */ -export declare enum FieldOptions_OptionRetention { - /** - * @generated from protobuf enum value: RETENTION_UNKNOWN = 0; - */ - RETENTION_UNKNOWN = 0, - /** - * @generated from protobuf enum value: RETENTION_RUNTIME = 1; - */ - RETENTION_RUNTIME = 1, - /** - * @generated from protobuf enum value: RETENTION_SOURCE = 2; - */ - RETENTION_SOURCE = 2 -} -/** - * This indicates the types of entities that the field may apply to when used - * as an option. If it is unset, then the field may be freely used as an - * option on any kind of entity. Note: as of January 2023, support for this is - * in progress and does not yet have an effect (b/264593489). - * - * @generated from protobuf enum google.protobuf.FieldOptions.OptionTargetType - */ -export declare enum FieldOptions_OptionTargetType { - /** - * @generated from protobuf enum value: TARGET_TYPE_UNKNOWN = 0; - */ - TARGET_TYPE_UNKNOWN = 0, - /** - * @generated from protobuf enum value: TARGET_TYPE_FILE = 1; - */ - TARGET_TYPE_FILE = 1, - /** - * @generated from protobuf enum value: TARGET_TYPE_EXTENSION_RANGE = 2; - */ - TARGET_TYPE_EXTENSION_RANGE = 2, - /** - * @generated from protobuf enum value: TARGET_TYPE_MESSAGE = 3; - */ - TARGET_TYPE_MESSAGE = 3, - /** - * @generated from protobuf enum value: TARGET_TYPE_FIELD = 4; - */ - TARGET_TYPE_FIELD = 4, - /** - * @generated from protobuf enum value: TARGET_TYPE_ONEOF = 5; - */ - TARGET_TYPE_ONEOF = 5, - /** - * @generated from protobuf enum value: TARGET_TYPE_ENUM = 6; - */ - TARGET_TYPE_ENUM = 6, - /** - * @generated from protobuf enum value: TARGET_TYPE_ENUM_ENTRY = 7; - */ - TARGET_TYPE_ENUM_ENTRY = 7, - /** - * @generated from protobuf enum value: TARGET_TYPE_SERVICE = 8; - */ - TARGET_TYPE_SERVICE = 8, - /** - * @generated from protobuf enum value: TARGET_TYPE_METHOD = 9; - */ - TARGET_TYPE_METHOD = 9 -} -/** - * @generated from protobuf message google.protobuf.OneofOptions - */ -export interface OneofOptions { - /** - * Any features defined in the specific edition. - * - * @generated from protobuf field: optional google.protobuf.FeatureSet features = 1; - */ - features?: FeatureSet; - /** - * The parser stores options it doesn't recognize here. See above. - * - * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; - */ - uninterpretedOption: UninterpretedOption[]; -} -/** - * @generated from protobuf message google.protobuf.EnumOptions - */ -export interface EnumOptions { - /** - * Set this option to true to allow mapping different tag names to the same - * value. - * - * @generated from protobuf field: optional bool allow_alias = 2; - */ - allowAlias?: boolean; - /** - * Is this enum deprecated? - * Depending on the target platform, this can emit Deprecated annotations - * for the enum, or it will be completely ignored; in the very least, this - * is a formalization for deprecating enums. - * - * @generated from protobuf field: optional bool deprecated = 3; - */ - deprecated?: boolean; - /** - * Enable the legacy handling of JSON field name conflicts. This lowercases - * and strips underscored from the fields before comparison in proto3 only. - * The new behavior takes `json_name` into account and applies to proto2 as - * well. - * TODO Remove this legacy behavior once downstream teams have - * had time to migrate. - * - * @deprecated - * @generated from protobuf field: optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true]; - */ - deprecatedLegacyJsonFieldConflicts?: boolean; - /** - * Any features defined in the specific edition. - * - * @generated from protobuf field: optional google.protobuf.FeatureSet features = 7; - */ - features?: FeatureSet; - /** - * The parser stores options it doesn't recognize here. See above. - * - * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; - */ - uninterpretedOption: UninterpretedOption[]; -} -/** - * @generated from protobuf message google.protobuf.EnumValueOptions - */ -export interface EnumValueOptions { - /** - * Is this enum value deprecated? - * Depending on the target platform, this can emit Deprecated annotations - * for the enum value, or it will be completely ignored; in the very least, - * this is a formalization for deprecating enum values. - * - * @generated from protobuf field: optional bool deprecated = 1; - */ - deprecated?: boolean; - /** - * Any features defined in the specific edition. - * - * @generated from protobuf field: optional google.protobuf.FeatureSet features = 2; - */ - features?: FeatureSet; - /** - * Indicate that fields annotated with this enum value should not be printed - * out when using debug formats, e.g. when the field contains sensitive - * credentials. - * - * @generated from protobuf field: optional bool debug_redact = 3; - */ - debugRedact?: boolean; - /** - * Information about the support window of a feature value. - * - * @generated from protobuf field: optional google.protobuf.FieldOptions.FeatureSupport feature_support = 4; - */ - featureSupport?: FieldOptions_FeatureSupport; - /** - * The parser stores options it doesn't recognize here. See above. - * - * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; - */ - uninterpretedOption: UninterpretedOption[]; -} -/** - * @generated from protobuf message google.protobuf.ServiceOptions - */ -export interface ServiceOptions { - /** - * Any features defined in the specific edition. - * - * @generated from protobuf field: optional google.protobuf.FeatureSet features = 34; - */ - features?: FeatureSet; - /** - * Is this service deprecated? - * Depending on the target platform, this can emit Deprecated annotations - * for the service, or it will be completely ignored; in the very least, - * this is a formalization for deprecating services. - * - * @generated from protobuf field: optional bool deprecated = 33; - */ - deprecated?: boolean; - /** - * The parser stores options it doesn't recognize here. See above. - * - * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; - */ - uninterpretedOption: UninterpretedOption[]; -} -/** - * @generated from protobuf message google.protobuf.MethodOptions - */ -export interface MethodOptions { - /** - * Is this method deprecated? - * Depending on the target platform, this can emit Deprecated annotations - * for the method, or it will be completely ignored; in the very least, - * this is a formalization for deprecating methods. - * - * @generated from protobuf field: optional bool deprecated = 33; - */ - deprecated?: boolean; - /** - * @generated from protobuf field: optional google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34; - */ - idempotencyLevel?: MethodOptions_IdempotencyLevel; - /** - * Any features defined in the specific edition. - * - * @generated from protobuf field: optional google.protobuf.FeatureSet features = 35; - */ - features?: FeatureSet; - /** - * The parser stores options it doesn't recognize here. See above. - * - * @generated from protobuf field: repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; - */ - uninterpretedOption: UninterpretedOption[]; -} -/** - * Is this method side-effect-free (or safe in HTTP parlance), or idempotent, - * or neither? HTTP based RPC implementation may choose GET verb for safe - * methods, and PUT verb for idempotent methods instead of the default POST. - * - * @generated from protobuf enum google.protobuf.MethodOptions.IdempotencyLevel - */ -export declare enum MethodOptions_IdempotencyLevel { - /** - * @generated from protobuf enum value: IDEMPOTENCY_UNKNOWN = 0; - */ - IDEMPOTENCY_UNKNOWN = 0, - /** - * implies idempotent - * - * @generated from protobuf enum value: NO_SIDE_EFFECTS = 1; - */ - NO_SIDE_EFFECTS = 1, - /** - * idempotent, but may have side effects - * - * @generated from protobuf enum value: IDEMPOTENT = 2; - */ - IDEMPOTENT = 2 -} -/** - * A message representing a option the parser does not recognize. This only - * appears in options protos created by the compiler::Parser class. - * DescriptorPool resolves these when building Descriptor objects. Therefore, - * options protos in descriptor objects (e.g. returned by Descriptor::options(), - * or produced by Descriptor::CopyTo()) will never have UninterpretedOptions - * in them. - * - * @generated from protobuf message google.protobuf.UninterpretedOption - */ -export interface UninterpretedOption { - /** - * @generated from protobuf field: repeated google.protobuf.UninterpretedOption.NamePart name = 2; - */ - name: UninterpretedOption_NamePart[]; - /** - * The value of the uninterpreted option, in whatever type the tokenizer - * identified it as during parsing. Exactly one of these should be set. - * - * @generated from protobuf field: optional string identifier_value = 3; - */ - identifierValue?: string; - /** - * @generated from protobuf field: optional uint64 positive_int_value = 4; - */ - positiveIntValue?: string; - /** - * @generated from protobuf field: optional int64 negative_int_value = 5; - */ - negativeIntValue?: string; - /** - * @generated from protobuf field: optional double double_value = 6; - */ - doubleValue?: number; - /** - * @generated from protobuf field: optional bytes string_value = 7; - */ - stringValue?: Uint8Array; - /** - * @generated from protobuf field: optional string aggregate_value = 8; - */ - aggregateValue?: string; -} -/** - * The name of the uninterpreted option. Each string represents a segment in - * a dot-separated name. is_extension is true iff a segment represents an - * extension (denoted with parentheses in options specs in .proto files). - * E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents - * "foo.(bar.baz).moo". - * - * @generated from protobuf message google.protobuf.UninterpretedOption.NamePart - */ -export interface UninterpretedOption_NamePart { - /** - * @generated from protobuf field: string name_part = 1; - */ - namePart: string; - /** - * @generated from protobuf field: bool is_extension = 2; - */ - isExtension: boolean; -} -/** - * TODO Enums in C++ gencode (and potentially other languages) are - * not well scoped. This means that each of the feature enums below can clash - * with each other. The short names we've chosen maximize call-site - * readability, but leave us very open to this scenario. A future feature will - * be designed and implemented to handle this, hopefully before we ever hit a - * conflict here. - * - * @generated from protobuf message google.protobuf.FeatureSet - */ -export interface FeatureSet { - /** - * @generated from protobuf field: optional google.protobuf.FeatureSet.FieldPresence field_presence = 1; - */ - fieldPresence?: FeatureSet_FieldPresence; - /** - * @generated from protobuf field: optional google.protobuf.FeatureSet.EnumType enum_type = 2; - */ - enumType?: FeatureSet_EnumType; - /** - * @generated from protobuf field: optional google.protobuf.FeatureSet.RepeatedFieldEncoding repeated_field_encoding = 3; - */ - repeatedFieldEncoding?: FeatureSet_RepeatedFieldEncoding; - /** - * @generated from protobuf field: optional google.protobuf.FeatureSet.Utf8Validation utf8_validation = 4; - */ - utf8Validation?: FeatureSet_Utf8Validation; - /** - * @generated from protobuf field: optional google.protobuf.FeatureSet.MessageEncoding message_encoding = 5; - */ - messageEncoding?: FeatureSet_MessageEncoding; - /** - * @generated from protobuf field: optional google.protobuf.FeatureSet.JsonFormat json_format = 6; - */ - jsonFormat?: FeatureSet_JsonFormat; -} -/** - * @generated from protobuf enum google.protobuf.FeatureSet.FieldPresence - */ -export declare enum FeatureSet_FieldPresence { - /** - * @generated from protobuf enum value: FIELD_PRESENCE_UNKNOWN = 0; - */ - FIELD_PRESENCE_UNKNOWN = 0, - /** - * @generated from protobuf enum value: EXPLICIT = 1; - */ - EXPLICIT = 1, - /** - * @generated from protobuf enum value: IMPLICIT = 2; - */ - IMPLICIT = 2, - /** - * @generated from protobuf enum value: LEGACY_REQUIRED = 3; - */ - LEGACY_REQUIRED = 3 -} -/** - * @generated from protobuf enum google.protobuf.FeatureSet.EnumType - */ -export declare enum FeatureSet_EnumType { - /** - * @generated from protobuf enum value: ENUM_TYPE_UNKNOWN = 0; - */ - ENUM_TYPE_UNKNOWN = 0, - /** - * @generated from protobuf enum value: OPEN = 1; - */ - OPEN = 1, - /** - * @generated from protobuf enum value: CLOSED = 2; - */ - CLOSED = 2 -} -/** - * @generated from protobuf enum google.protobuf.FeatureSet.RepeatedFieldEncoding - */ -export declare enum FeatureSet_RepeatedFieldEncoding { - /** - * @generated from protobuf enum value: REPEATED_FIELD_ENCODING_UNKNOWN = 0; - */ - REPEATED_FIELD_ENCODING_UNKNOWN = 0, - /** - * @generated from protobuf enum value: PACKED = 1; - */ - PACKED = 1, - /** - * @generated from protobuf enum value: EXPANDED = 2; - */ - EXPANDED = 2 -} -/** - * @generated from protobuf enum google.protobuf.FeatureSet.Utf8Validation - */ -export declare enum FeatureSet_Utf8Validation { - /** - * @generated from protobuf enum value: UTF8_VALIDATION_UNKNOWN = 0; - */ - UTF8_VALIDATION_UNKNOWN = 0, - /** - * @generated from protobuf enum value: VERIFY = 2; - */ - VERIFY = 2, - /** - * @generated from protobuf enum value: NONE = 3; - */ - NONE = 3 -} -/** - * @generated from protobuf enum google.protobuf.FeatureSet.MessageEncoding - */ -export declare enum FeatureSet_MessageEncoding { - /** - * @generated from protobuf enum value: MESSAGE_ENCODING_UNKNOWN = 0; - */ - MESSAGE_ENCODING_UNKNOWN = 0, - /** - * @generated from protobuf enum value: LENGTH_PREFIXED = 1; - */ - LENGTH_PREFIXED = 1, - /** - * @generated from protobuf enum value: DELIMITED = 2; - */ - DELIMITED = 2 -} -/** - * @generated from protobuf enum google.protobuf.FeatureSet.JsonFormat - */ -export declare enum FeatureSet_JsonFormat { - /** - * @generated from protobuf enum value: JSON_FORMAT_UNKNOWN = 0; - */ - JSON_FORMAT_UNKNOWN = 0, - /** - * @generated from protobuf enum value: ALLOW = 1; - */ - ALLOW = 1, - /** - * @generated from protobuf enum value: LEGACY_BEST_EFFORT = 2; - */ - LEGACY_BEST_EFFORT = 2 -} -/** - * A compiled specification for the defaults of a set of features. These - * messages are generated from FeatureSet extensions and can be used to seed - * feature resolution. The resolution with this object becomes a simple search - * for the closest matching edition, followed by proto merges. - * - * @generated from protobuf message google.protobuf.FeatureSetDefaults - */ -export interface FeatureSetDefaults { - /** - * @generated from protobuf field: repeated google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults = 1; - */ - defaults: FeatureSetDefaults_FeatureSetEditionDefault[]; - /** - * The minimum supported edition (inclusive) when this was constructed. - * Editions before this will not have defaults. - * - * @generated from protobuf field: optional google.protobuf.Edition minimum_edition = 4; - */ - minimumEdition?: Edition; - /** - * The maximum known edition (inclusive) when this was constructed. Editions - * after this will not have reliable defaults. - * - * @generated from protobuf field: optional google.protobuf.Edition maximum_edition = 5; - */ - maximumEdition?: Edition; -} -/** - * A map from every known edition with a unique set of defaults to its - * defaults. Not all editions may be contained here. For a given edition, - * the defaults at the closest matching edition ordered at or before it should - * be used. This field must be in strict ascending order by edition. - * - * @generated from protobuf message google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault - */ -export interface FeatureSetDefaults_FeatureSetEditionDefault { - /** - * @generated from protobuf field: optional google.protobuf.Edition edition = 3; - */ - edition?: Edition; - /** - * Defaults of features that can be overridden in this edition. - * - * @generated from protobuf field: optional google.protobuf.FeatureSet overridable_features = 4; - */ - overridableFeatures?: FeatureSet; - /** - * Defaults of features that can't be overridden in this edition. - * - * @generated from protobuf field: optional google.protobuf.FeatureSet fixed_features = 5; - */ - fixedFeatures?: FeatureSet; -} -/** - * Encapsulates information about the original source file from which a - * FileDescriptorProto was generated. - * - * @generated from protobuf message google.protobuf.SourceCodeInfo - */ -export interface SourceCodeInfo { - /** - * A Location identifies a piece of source code in a .proto file which - * corresponds to a particular definition. This information is intended - * to be useful to IDEs, code indexers, documentation generators, and similar - * tools. - * - * For example, say we have a file like: - * message Foo { - * optional string foo = 1; - * } - * Let's look at just the field definition: - * optional string foo = 1; - * ^ ^^ ^^ ^ ^^^ - * a bc de f ghi - * We have the following locations: - * span path represents - * [a,i) [ 4, 0, 2, 0 ] The whole field definition. - * [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). - * [c,d) [ 4, 0, 2, 0, 5 ] The type (string). - * [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). - * [g,h) [ 4, 0, 2, 0, 3 ] The number (1). - * - * Notes: - * - A location may refer to a repeated field itself (i.e. not to any - * particular index within it). This is used whenever a set of elements are - * logically enclosed in a single code segment. For example, an entire - * extend block (possibly containing multiple extension definitions) will - * have an outer location whose path refers to the "extensions" repeated - * field without an index. - * - Multiple locations may have the same path. This happens when a single - * logical declaration is spread out across multiple places. The most - * obvious example is the "extend" block again -- there may be multiple - * extend blocks in the same scope, each of which will have the same path. - * - A location's span is not always a subset of its parent's span. For - * example, the "extendee" of an extension declaration appears at the - * beginning of the "extend" block and is shared by all extensions within - * the block. - * - Just because a location's span is a subset of some other location's span - * does not mean that it is a descendant. For example, a "group" defines - * both a type and a field in a single declaration. Thus, the locations - * corresponding to the type and field and their components will overlap. - * - Code which tries to interpret locations should probably be designed to - * ignore those that it doesn't understand, as more types of locations could - * be recorded in the future. - * - * @generated from protobuf field: repeated google.protobuf.SourceCodeInfo.Location location = 1; - */ - location: SourceCodeInfo_Location[]; -} -/** - * @generated from protobuf message google.protobuf.SourceCodeInfo.Location - */ -export interface SourceCodeInfo_Location { - /** - * Identifies which part of the FileDescriptorProto was defined at this - * location. - * - * Each element is a field number or an index. They form a path from - * the root FileDescriptorProto to the place where the definition appears. - * For example, this path: - * [ 4, 3, 2, 7, 1 ] - * refers to: - * file.message_type(3) // 4, 3 - * .field(7) // 2, 7 - * .name() // 1 - * This is because FileDescriptorProto.message_type has field number 4: - * repeated DescriptorProto message_type = 4; - * and DescriptorProto.field has field number 2: - * repeated FieldDescriptorProto field = 2; - * and FieldDescriptorProto.name has field number 1: - * optional string name = 1; - * - * Thus, the above path gives the location of a field name. If we removed - * the last element: - * [ 4, 3, 2, 7 ] - * this path refers to the whole field declaration (from the beginning - * of the label to the terminating semicolon). - * - * @generated from protobuf field: repeated int32 path = 1 [packed = true]; - */ - path: number[]; - /** - * Always has exactly three or four elements: start line, start column, - * end line (optional, otherwise assumed same as start line), end column. - * These are packed into a single field for efficiency. Note that line - * and column numbers are zero-based -- typically you will want to add - * 1 to each before displaying to a user. - * - * @generated from protobuf field: repeated int32 span = 2 [packed = true]; - */ - span: number[]; - /** - * If this SourceCodeInfo represents a complete declaration, these are any - * comments appearing before and after the declaration which appear to be - * attached to the declaration. - * - * A series of line comments appearing on consecutive lines, with no other - * tokens appearing on those lines, will be treated as a single comment. - * - * leading_detached_comments will keep paragraphs of comments that appear - * before (but not connected to) the current element. Each paragraph, - * separated by empty lines, will be one comment element in the repeated - * field. - * - * Only the comment content is provided; comment markers (e.g. //) are - * stripped out. For block comments, leading whitespace and an asterisk - * will be stripped from the beginning of each line other than the first. - * Newlines are included in the output. - * - * Examples: - * - * optional int32 foo = 1; // Comment attached to foo. - * // Comment attached to bar. - * optional int32 bar = 2; - * - * optional string baz = 3; - * // Comment attached to baz. - * // Another line attached to baz. - * - * // Comment attached to moo. - * // - * // Another line attached to moo. - * optional double moo = 4; - * - * // Detached comment for corge. This is not leading or trailing comments - * // to moo or corge because there are blank lines separating it from - * // both. - * - * // Detached comment for corge paragraph 2. - * - * optional string corge = 5; - * /* Block comment attached - * * to corge. Leading asterisks - * * will be removed. *\/ - * /* Block comment attached to - * * grault. *\/ - * optional int32 grault = 6; - * - * // ignored detached comments. - * - * @generated from protobuf field: optional string leading_comments = 3; - */ - leadingComments?: string; - /** - * @generated from protobuf field: optional string trailing_comments = 4; - */ - trailingComments?: string; - /** - * @generated from protobuf field: repeated string leading_detached_comments = 6; - */ - leadingDetachedComments: string[]; -} -/** - * Describes the relationship between generated code and its original source - * file. A GeneratedCodeInfo message is associated with only one generated - * source file, but may contain references to different source .proto files. - * - * @generated from protobuf message google.protobuf.GeneratedCodeInfo - */ -export interface GeneratedCodeInfo { - /** - * An Annotation connects some span of text in generated code to an element - * of its generating .proto file. - * - * @generated from protobuf field: repeated google.protobuf.GeneratedCodeInfo.Annotation annotation = 1; - */ - annotation: GeneratedCodeInfo_Annotation[]; -} -/** - * @generated from protobuf message google.protobuf.GeneratedCodeInfo.Annotation - */ -export interface GeneratedCodeInfo_Annotation { - /** - * Identifies the element in the original source .proto file. This field - * is formatted the same as SourceCodeInfo.Location.path. - * - * @generated from protobuf field: repeated int32 path = 1 [packed = true]; - */ - path: number[]; - /** - * Identifies the filesystem path to the original source .proto. - * - * @generated from protobuf field: optional string source_file = 2; - */ - sourceFile?: string; - /** - * Identifies the starting offset in bytes in the generated code - * that relates to the identified object. - * - * @generated from protobuf field: optional int32 begin = 3; - */ - begin?: number; - /** - * Identifies the ending offset in bytes in the generated code that - * relates to the identified object. The end offset should be one past - * the last relevant byte (so the length of the text = end - begin). - * - * @generated from protobuf field: optional int32 end = 4; - */ - end?: number; - /** - * @generated from protobuf field: optional google.protobuf.GeneratedCodeInfo.Annotation.Semantic semantic = 5; - */ - semantic?: GeneratedCodeInfo_Annotation_Semantic; -} -/** - * Represents the identified object's effect on the element in the original - * .proto file. - * - * @generated from protobuf enum google.protobuf.GeneratedCodeInfo.Annotation.Semantic - */ -export declare enum GeneratedCodeInfo_Annotation_Semantic { - /** - * There is no effect or the effect is indescribable. - * - * @generated from protobuf enum value: NONE = 0; - */ - NONE = 0, - /** - * The element is set or otherwise mutated. - * - * @generated from protobuf enum value: SET = 1; - */ - SET = 1, - /** - * An alias to the element is returned. - * - * @generated from protobuf enum value: ALIAS = 2; - */ - ALIAS = 2 -} -/** - * The full set of known editions. - * - * @generated from protobuf enum google.protobuf.Edition - */ -export declare enum Edition { - /** - * A placeholder for an unknown edition value. - * - * @generated from protobuf enum value: EDITION_UNKNOWN = 0; - */ - EDITION_UNKNOWN = 0, - /** - * A placeholder edition for specifying default behaviors *before* a feature - * was first introduced. This is effectively an "infinite past". - * - * @generated from protobuf enum value: EDITION_LEGACY = 900; - */ - EDITION_LEGACY = 900, - /** - * Legacy syntax "editions". These pre-date editions, but behave much like - * distinct editions. These can't be used to specify the edition of proto - * files, but feature definitions must supply proto2/proto3 defaults for - * backwards compatibility. - * - * @generated from protobuf enum value: EDITION_PROTO2 = 998; - */ - EDITION_PROTO2 = 998, - /** - * @generated from protobuf enum value: EDITION_PROTO3 = 999; - */ - EDITION_PROTO3 = 999, - /** - * Editions that have been released. The specific values are arbitrary and - * should not be depended on, but they will always be time-ordered for easy - * comparison. - * - * @generated from protobuf enum value: EDITION_2023 = 1000; - */ - EDITION_2023 = 1000, - /** - * @generated from protobuf enum value: EDITION_2024 = 1001; - */ - EDITION_2024 = 1001, - /** - * Placeholder editions for testing feature resolution. These should not be - * used or relyed on outside of tests. - * - * @generated from protobuf enum value: EDITION_1_TEST_ONLY = 1; - */ - EDITION_1_TEST_ONLY = 1, - /** - * @generated from protobuf enum value: EDITION_2_TEST_ONLY = 2; - */ - EDITION_2_TEST_ONLY = 2, - /** - * @generated from protobuf enum value: EDITION_99997_TEST_ONLY = 99997; - */ - EDITION_99997_TEST_ONLY = 99997, - /** - * @generated from protobuf enum value: EDITION_99998_TEST_ONLY = 99998; - */ - EDITION_99998_TEST_ONLY = 99998, - /** - * @generated from protobuf enum value: EDITION_99999_TEST_ONLY = 99999; - */ - EDITION_99999_TEST_ONLY = 99999, - /** - * Placeholder for specifying unbounded edition support. This should only - * ever be used by plugins that can expect to never require any changes to - * support a new edition. - * - * @generated from protobuf enum value: EDITION_MAX = 2147483647; - */ - EDITION_MAX = 2147483647 -} -declare class FileDescriptorSet$Type extends MessageType { - constructor(); - create(value?: PartialMessage): FileDescriptorSet; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FileDescriptorSet): FileDescriptorSet; - internalBinaryWrite(message: FileDescriptorSet, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.FileDescriptorSet - */ -export declare const FileDescriptorSet: FileDescriptorSet$Type; -declare class FileDescriptorProto$Type extends MessageType { - constructor(); - create(value?: PartialMessage): FileDescriptorProto; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FileDescriptorProto): FileDescriptorProto; - internalBinaryWrite(message: FileDescriptorProto, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.FileDescriptorProto - */ -export declare const FileDescriptorProto: FileDescriptorProto$Type; -declare class DescriptorProto$Type extends MessageType { - constructor(); - create(value?: PartialMessage): DescriptorProto; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DescriptorProto): DescriptorProto; - internalBinaryWrite(message: DescriptorProto, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.DescriptorProto - */ -export declare const DescriptorProto: DescriptorProto$Type; -declare class DescriptorProto_ExtensionRange$Type extends MessageType { - constructor(); - create(value?: PartialMessage): DescriptorProto_ExtensionRange; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DescriptorProto_ExtensionRange): DescriptorProto_ExtensionRange; - internalBinaryWrite(message: DescriptorProto_ExtensionRange, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.DescriptorProto.ExtensionRange - */ -export declare const DescriptorProto_ExtensionRange: DescriptorProto_ExtensionRange$Type; -declare class DescriptorProto_ReservedRange$Type extends MessageType { - constructor(); - create(value?: PartialMessage): DescriptorProto_ReservedRange; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DescriptorProto_ReservedRange): DescriptorProto_ReservedRange; - internalBinaryWrite(message: DescriptorProto_ReservedRange, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.DescriptorProto.ReservedRange - */ -export declare const DescriptorProto_ReservedRange: DescriptorProto_ReservedRange$Type; -declare class ExtensionRangeOptions$Type extends MessageType { - constructor(); - create(value?: PartialMessage): ExtensionRangeOptions; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExtensionRangeOptions): ExtensionRangeOptions; - internalBinaryWrite(message: ExtensionRangeOptions, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.ExtensionRangeOptions - */ -export declare const ExtensionRangeOptions: ExtensionRangeOptions$Type; -declare class ExtensionRangeOptions_Declaration$Type extends MessageType { - constructor(); - create(value?: PartialMessage): ExtensionRangeOptions_Declaration; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExtensionRangeOptions_Declaration): ExtensionRangeOptions_Declaration; - internalBinaryWrite(message: ExtensionRangeOptions_Declaration, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.ExtensionRangeOptions.Declaration - */ -export declare const ExtensionRangeOptions_Declaration: ExtensionRangeOptions_Declaration$Type; -declare class FieldDescriptorProto$Type extends MessageType { - constructor(); - create(value?: PartialMessage): FieldDescriptorProto; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FieldDescriptorProto): FieldDescriptorProto; - internalBinaryWrite(message: FieldDescriptorProto, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.FieldDescriptorProto - */ -export declare const FieldDescriptorProto: FieldDescriptorProto$Type; -declare class OneofDescriptorProto$Type extends MessageType { - constructor(); - create(value?: PartialMessage): OneofDescriptorProto; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OneofDescriptorProto): OneofDescriptorProto; - internalBinaryWrite(message: OneofDescriptorProto, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.OneofDescriptorProto - */ -export declare const OneofDescriptorProto: OneofDescriptorProto$Type; -declare class EnumDescriptorProto$Type extends MessageType { - constructor(); - create(value?: PartialMessage): EnumDescriptorProto; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EnumDescriptorProto): EnumDescriptorProto; - internalBinaryWrite(message: EnumDescriptorProto, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.EnumDescriptorProto - */ -export declare const EnumDescriptorProto: EnumDescriptorProto$Type; -declare class EnumDescriptorProto_EnumReservedRange$Type extends MessageType { - constructor(); - create(value?: PartialMessage): EnumDescriptorProto_EnumReservedRange; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EnumDescriptorProto_EnumReservedRange): EnumDescriptorProto_EnumReservedRange; - internalBinaryWrite(message: EnumDescriptorProto_EnumReservedRange, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.EnumDescriptorProto.EnumReservedRange - */ -export declare const EnumDescriptorProto_EnumReservedRange: EnumDescriptorProto_EnumReservedRange$Type; -declare class EnumValueDescriptorProto$Type extends MessageType { - constructor(); - create(value?: PartialMessage): EnumValueDescriptorProto; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EnumValueDescriptorProto): EnumValueDescriptorProto; - internalBinaryWrite(message: EnumValueDescriptorProto, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.EnumValueDescriptorProto - */ -export declare const EnumValueDescriptorProto: EnumValueDescriptorProto$Type; -declare class ServiceDescriptorProto$Type extends MessageType { - constructor(); - create(value?: PartialMessage): ServiceDescriptorProto; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ServiceDescriptorProto): ServiceDescriptorProto; - internalBinaryWrite(message: ServiceDescriptorProto, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.ServiceDescriptorProto - */ -export declare const ServiceDescriptorProto: ServiceDescriptorProto$Type; -declare class MethodDescriptorProto$Type extends MessageType { - constructor(); - create(value?: PartialMessage): MethodDescriptorProto; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MethodDescriptorProto): MethodDescriptorProto; - internalBinaryWrite(message: MethodDescriptorProto, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.MethodDescriptorProto - */ -export declare const MethodDescriptorProto: MethodDescriptorProto$Type; -declare class FileOptions$Type extends MessageType { - constructor(); - create(value?: PartialMessage): FileOptions; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FileOptions): FileOptions; - internalBinaryWrite(message: FileOptions, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.FileOptions - */ -export declare const FileOptions: FileOptions$Type; -declare class MessageOptions$Type extends MessageType { - constructor(); - create(value?: PartialMessage): MessageOptions; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MessageOptions): MessageOptions; - internalBinaryWrite(message: MessageOptions, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.MessageOptions - */ -export declare const MessageOptions: MessageOptions$Type; -declare class FieldOptions$Type extends MessageType { - constructor(); - create(value?: PartialMessage): FieldOptions; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FieldOptions): FieldOptions; - internalBinaryWrite(message: FieldOptions, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.FieldOptions - */ -export declare const FieldOptions: FieldOptions$Type; -declare class FieldOptions_EditionDefault$Type extends MessageType { - constructor(); - create(value?: PartialMessage): FieldOptions_EditionDefault; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FieldOptions_EditionDefault): FieldOptions_EditionDefault; - internalBinaryWrite(message: FieldOptions_EditionDefault, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.FieldOptions.EditionDefault - */ -export declare const FieldOptions_EditionDefault: FieldOptions_EditionDefault$Type; -declare class FieldOptions_FeatureSupport$Type extends MessageType { - constructor(); - create(value?: PartialMessage): FieldOptions_FeatureSupport; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FieldOptions_FeatureSupport): FieldOptions_FeatureSupport; - internalBinaryWrite(message: FieldOptions_FeatureSupport, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.FieldOptions.FeatureSupport - */ -export declare const FieldOptions_FeatureSupport: FieldOptions_FeatureSupport$Type; -declare class OneofOptions$Type extends MessageType { - constructor(); - create(value?: PartialMessage): OneofOptions; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OneofOptions): OneofOptions; - internalBinaryWrite(message: OneofOptions, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.OneofOptions - */ -export declare const OneofOptions: OneofOptions$Type; -declare class EnumOptions$Type extends MessageType { - constructor(); - create(value?: PartialMessage): EnumOptions; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EnumOptions): EnumOptions; - internalBinaryWrite(message: EnumOptions, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.EnumOptions - */ -export declare const EnumOptions: EnumOptions$Type; -declare class EnumValueOptions$Type extends MessageType { - constructor(); - create(value?: PartialMessage): EnumValueOptions; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EnumValueOptions): EnumValueOptions; - internalBinaryWrite(message: EnumValueOptions, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.EnumValueOptions - */ -export declare const EnumValueOptions: EnumValueOptions$Type; -declare class ServiceOptions$Type extends MessageType { - constructor(); - create(value?: PartialMessage): ServiceOptions; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ServiceOptions): ServiceOptions; - internalBinaryWrite(message: ServiceOptions, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.ServiceOptions - */ -export declare const ServiceOptions: ServiceOptions$Type; -declare class MethodOptions$Type extends MessageType { - constructor(); - create(value?: PartialMessage): MethodOptions; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MethodOptions): MethodOptions; - internalBinaryWrite(message: MethodOptions, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.MethodOptions - */ -export declare const MethodOptions: MethodOptions$Type; -declare class UninterpretedOption$Type extends MessageType { - constructor(); - create(value?: PartialMessage): UninterpretedOption; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UninterpretedOption): UninterpretedOption; - internalBinaryWrite(message: UninterpretedOption, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.UninterpretedOption - */ -export declare const UninterpretedOption: UninterpretedOption$Type; -declare class UninterpretedOption_NamePart$Type extends MessageType { - constructor(); - create(value?: PartialMessage): UninterpretedOption_NamePart; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UninterpretedOption_NamePart): UninterpretedOption_NamePart; - internalBinaryWrite(message: UninterpretedOption_NamePart, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.UninterpretedOption.NamePart - */ -export declare const UninterpretedOption_NamePart: UninterpretedOption_NamePart$Type; -declare class FeatureSet$Type extends MessageType { - constructor(); - create(value?: PartialMessage): FeatureSet; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FeatureSet): FeatureSet; - internalBinaryWrite(message: FeatureSet, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.FeatureSet - */ -export declare const FeatureSet: FeatureSet$Type; -declare class FeatureSetDefaults$Type extends MessageType { - constructor(); - create(value?: PartialMessage): FeatureSetDefaults; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FeatureSetDefaults): FeatureSetDefaults; - internalBinaryWrite(message: FeatureSetDefaults, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.FeatureSetDefaults - */ -export declare const FeatureSetDefaults: FeatureSetDefaults$Type; -declare class FeatureSetDefaults_FeatureSetEditionDefault$Type extends MessageType { - constructor(); - create(value?: PartialMessage): FeatureSetDefaults_FeatureSetEditionDefault; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FeatureSetDefaults_FeatureSetEditionDefault): FeatureSetDefaults_FeatureSetEditionDefault; - internalBinaryWrite(message: FeatureSetDefaults_FeatureSetEditionDefault, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault - */ -export declare const FeatureSetDefaults_FeatureSetEditionDefault: FeatureSetDefaults_FeatureSetEditionDefault$Type; -declare class SourceCodeInfo$Type extends MessageType { - constructor(); - create(value?: PartialMessage): SourceCodeInfo; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SourceCodeInfo): SourceCodeInfo; - internalBinaryWrite(message: SourceCodeInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.SourceCodeInfo - */ -export declare const SourceCodeInfo: SourceCodeInfo$Type; -declare class SourceCodeInfo_Location$Type extends MessageType { - constructor(); - create(value?: PartialMessage): SourceCodeInfo_Location; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SourceCodeInfo_Location): SourceCodeInfo_Location; - internalBinaryWrite(message: SourceCodeInfo_Location, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.SourceCodeInfo.Location - */ -export declare const SourceCodeInfo_Location: SourceCodeInfo_Location$Type; -declare class GeneratedCodeInfo$Type extends MessageType { - constructor(); - create(value?: PartialMessage): GeneratedCodeInfo; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GeneratedCodeInfo): GeneratedCodeInfo; - internalBinaryWrite(message: GeneratedCodeInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.GeneratedCodeInfo - */ -export declare const GeneratedCodeInfo: GeneratedCodeInfo$Type; -declare class GeneratedCodeInfo_Annotation$Type extends MessageType { - constructor(); - create(value?: PartialMessage): GeneratedCodeInfo_Annotation; - internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GeneratedCodeInfo_Annotation): GeneratedCodeInfo_Annotation; - internalBinaryWrite(message: GeneratedCodeInfo_Annotation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter; -} -/** - * @generated MessageType for protobuf message google.protobuf.GeneratedCodeInfo.Annotation - */ -export declare const GeneratedCodeInfo_Annotation: GeneratedCodeInfo_Annotation$Type; -export {}; diff --git a/pkg/api/gen/proto/ts/google/protobuf/descriptor_pb.js b/pkg/api/gen/proto/ts/google/protobuf/descriptor_pb.js deleted file mode 100644 index 41c472eaa..000000000 --- a/pkg/api/gen/proto/ts/google/protobuf/descriptor_pb.js +++ /dev/null @@ -1,3153 +0,0 @@ -/* eslint-disable */ -// @generated by protobuf-ts 2.9.4 with parameter output_javascript,optimize_code_size,long_type_string,add_pb_suffix,ts_nocheck,eslint_disable -// @generated from protobuf file "google/protobuf/descriptor.proto" (package "google.protobuf", syntax proto2) -// tslint:disable -// @ts-nocheck -// -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// -// -// Author: kenton@google.com (Kenton Varda) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// The messages in this file describe the definitions found in .proto files. -// A valid .proto file can be translated directly to a FileDescriptorProto -// without any other information (e.g. without reading its imports). -// -import { WireType } from "@protobuf-ts/runtime"; -import { UnknownFieldHandler } from "@protobuf-ts/runtime"; -import { reflectionMergePartial } from "@protobuf-ts/runtime"; -import { MessageType } from "@protobuf-ts/runtime"; -/** - * The verification state of the extension range. - * - * @generated from protobuf enum google.protobuf.ExtensionRangeOptions.VerificationState - */ -export var ExtensionRangeOptions_VerificationState; -(function (ExtensionRangeOptions_VerificationState) { - /** - * All the extensions of the range must be declared. - * - * @generated from protobuf enum value: DECLARATION = 0; - */ - ExtensionRangeOptions_VerificationState[ExtensionRangeOptions_VerificationState["DECLARATION"] = 0] = "DECLARATION"; - /** - * @generated from protobuf enum value: UNVERIFIED = 1; - */ - ExtensionRangeOptions_VerificationState[ExtensionRangeOptions_VerificationState["UNVERIFIED"] = 1] = "UNVERIFIED"; -})(ExtensionRangeOptions_VerificationState || (ExtensionRangeOptions_VerificationState = {})); -/** - * @generated from protobuf enum google.protobuf.FieldDescriptorProto.Type - */ -export var FieldDescriptorProto_Type; -(function (FieldDescriptorProto_Type) { - /** - * @generated synthetic value - protobuf-ts requires all enums to have a 0 value - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["UNSPECIFIED$"] = 0] = "UNSPECIFIED$"; - /** - * 0 is reserved for errors. - * Order is weird for historical reasons. - * - * @generated from protobuf enum value: TYPE_DOUBLE = 1; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["DOUBLE"] = 1] = "DOUBLE"; - /** - * @generated from protobuf enum value: TYPE_FLOAT = 2; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["FLOAT"] = 2] = "FLOAT"; - /** - * Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if - * negative values are likely. - * - * @generated from protobuf enum value: TYPE_INT64 = 3; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["INT64"] = 3] = "INT64"; - /** - * @generated from protobuf enum value: TYPE_UINT64 = 4; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["UINT64"] = 4] = "UINT64"; - /** - * Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if - * negative values are likely. - * - * @generated from protobuf enum value: TYPE_INT32 = 5; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["INT32"] = 5] = "INT32"; - /** - * @generated from protobuf enum value: TYPE_FIXED64 = 6; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["FIXED64"] = 6] = "FIXED64"; - /** - * @generated from protobuf enum value: TYPE_FIXED32 = 7; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["FIXED32"] = 7] = "FIXED32"; - /** - * @generated from protobuf enum value: TYPE_BOOL = 8; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["BOOL"] = 8] = "BOOL"; - /** - * @generated from protobuf enum value: TYPE_STRING = 9; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["STRING"] = 9] = "STRING"; - /** - * Tag-delimited aggregate. - * Group type is deprecated and not supported after google.protobuf. However, Proto3 - * implementations should still be able to parse the group wire format and - * treat group fields as unknown fields. In Editions, the group wire format - * can be enabled via the `message_encoding` feature. - * - * @generated from protobuf enum value: TYPE_GROUP = 10; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["GROUP"] = 10] = "GROUP"; - /** - * Length-delimited aggregate. - * - * @generated from protobuf enum value: TYPE_MESSAGE = 11; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["MESSAGE"] = 11] = "MESSAGE"; - /** - * New in version 2. - * - * @generated from protobuf enum value: TYPE_BYTES = 12; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["BYTES"] = 12] = "BYTES"; - /** - * @generated from protobuf enum value: TYPE_UINT32 = 13; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["UINT32"] = 13] = "UINT32"; - /** - * @generated from protobuf enum value: TYPE_ENUM = 14; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["ENUM"] = 14] = "ENUM"; - /** - * @generated from protobuf enum value: TYPE_SFIXED32 = 15; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["SFIXED32"] = 15] = "SFIXED32"; - /** - * @generated from protobuf enum value: TYPE_SFIXED64 = 16; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["SFIXED64"] = 16] = "SFIXED64"; - /** - * Uses ZigZag encoding. - * - * @generated from protobuf enum value: TYPE_SINT32 = 17; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["SINT32"] = 17] = "SINT32"; - /** - * Uses ZigZag encoding. - * - * @generated from protobuf enum value: TYPE_SINT64 = 18; - */ - FieldDescriptorProto_Type[FieldDescriptorProto_Type["SINT64"] = 18] = "SINT64"; -})(FieldDescriptorProto_Type || (FieldDescriptorProto_Type = {})); -/** - * @generated from protobuf enum google.protobuf.FieldDescriptorProto.Label - */ -export var FieldDescriptorProto_Label; -(function (FieldDescriptorProto_Label) { - /** - * @generated synthetic value - protobuf-ts requires all enums to have a 0 value - */ - FieldDescriptorProto_Label[FieldDescriptorProto_Label["UNSPECIFIED$"] = 0] = "UNSPECIFIED$"; - /** - * 0 is reserved for errors - * - * @generated from protobuf enum value: LABEL_OPTIONAL = 1; - */ - FieldDescriptorProto_Label[FieldDescriptorProto_Label["OPTIONAL"] = 1] = "OPTIONAL"; - /** - * @generated from protobuf enum value: LABEL_REPEATED = 3; - */ - FieldDescriptorProto_Label[FieldDescriptorProto_Label["REPEATED"] = 3] = "REPEATED"; - /** - * The required label is only allowed in google.protobuf. In proto3 and Editions - * it's explicitly prohibited. In Editions, the `field_presence` feature - * can be used to get this behavior. - * - * @generated from protobuf enum value: LABEL_REQUIRED = 2; - */ - FieldDescriptorProto_Label[FieldDescriptorProto_Label["REQUIRED"] = 2] = "REQUIRED"; -})(FieldDescriptorProto_Label || (FieldDescriptorProto_Label = {})); -/** - * Generated classes can be optimized for speed or code size. - * - * @generated from protobuf enum google.protobuf.FileOptions.OptimizeMode - */ -export var FileOptions_OptimizeMode; -(function (FileOptions_OptimizeMode) { - /** - * @generated synthetic value - protobuf-ts requires all enums to have a 0 value - */ - FileOptions_OptimizeMode[FileOptions_OptimizeMode["UNSPECIFIED$"] = 0] = "UNSPECIFIED$"; - /** - * Generate complete code for parsing, serialization, - * - * @generated from protobuf enum value: SPEED = 1; - */ - FileOptions_OptimizeMode[FileOptions_OptimizeMode["SPEED"] = 1] = "SPEED"; - /** - * etc. - * - * Use ReflectionOps to implement these methods. - * - * @generated from protobuf enum value: CODE_SIZE = 2; - */ - FileOptions_OptimizeMode[FileOptions_OptimizeMode["CODE_SIZE"] = 2] = "CODE_SIZE"; - /** - * Generate code using MessageLite and the lite runtime. - * - * @generated from protobuf enum value: LITE_RUNTIME = 3; - */ - FileOptions_OptimizeMode[FileOptions_OptimizeMode["LITE_RUNTIME"] = 3] = "LITE_RUNTIME"; -})(FileOptions_OptimizeMode || (FileOptions_OptimizeMode = {})); -/** - * @generated from protobuf enum google.protobuf.FieldOptions.CType - */ -export var FieldOptions_CType; -(function (FieldOptions_CType) { - /** - * Default mode. - * - * @generated from protobuf enum value: STRING = 0; - */ - FieldOptions_CType[FieldOptions_CType["STRING"] = 0] = "STRING"; - /** - * The option [ctype=CORD] may be applied to a non-repeated field of type - * "bytes". It indicates that in C++, the data should be stored in a Cord - * instead of a string. For very large strings, this may reduce memory - * fragmentation. It may also allow better performance when parsing from a - * Cord, or when parsing with aliasing enabled, as the parsed Cord may then - * alias the original buffer. - * - * @generated from protobuf enum value: CORD = 1; - */ - FieldOptions_CType[FieldOptions_CType["CORD"] = 1] = "CORD"; - /** - * @generated from protobuf enum value: STRING_PIECE = 2; - */ - FieldOptions_CType[FieldOptions_CType["STRING_PIECE"] = 2] = "STRING_PIECE"; -})(FieldOptions_CType || (FieldOptions_CType = {})); -/** - * @generated from protobuf enum google.protobuf.FieldOptions.JSType - */ -export var FieldOptions_JSType; -(function (FieldOptions_JSType) { - /** - * Use the default type. - * - * @generated from protobuf enum value: JS_NORMAL = 0; - */ - FieldOptions_JSType[FieldOptions_JSType["JS_NORMAL"] = 0] = "JS_NORMAL"; - /** - * Use JavaScript strings. - * - * @generated from protobuf enum value: JS_STRING = 1; - */ - FieldOptions_JSType[FieldOptions_JSType["JS_STRING"] = 1] = "JS_STRING"; - /** - * Use JavaScript numbers. - * - * @generated from protobuf enum value: JS_NUMBER = 2; - */ - FieldOptions_JSType[FieldOptions_JSType["JS_NUMBER"] = 2] = "JS_NUMBER"; -})(FieldOptions_JSType || (FieldOptions_JSType = {})); -/** - * If set to RETENTION_SOURCE, the option will be omitted from the binary. - * Note: as of January 2023, support for this is in progress and does not yet - * have an effect (b/264593489). - * - * @generated from protobuf enum google.protobuf.FieldOptions.OptionRetention - */ -export var FieldOptions_OptionRetention; -(function (FieldOptions_OptionRetention) { - /** - * @generated from protobuf enum value: RETENTION_UNKNOWN = 0; - */ - FieldOptions_OptionRetention[FieldOptions_OptionRetention["RETENTION_UNKNOWN"] = 0] = "RETENTION_UNKNOWN"; - /** - * @generated from protobuf enum value: RETENTION_RUNTIME = 1; - */ - FieldOptions_OptionRetention[FieldOptions_OptionRetention["RETENTION_RUNTIME"] = 1] = "RETENTION_RUNTIME"; - /** - * @generated from protobuf enum value: RETENTION_SOURCE = 2; - */ - FieldOptions_OptionRetention[FieldOptions_OptionRetention["RETENTION_SOURCE"] = 2] = "RETENTION_SOURCE"; -})(FieldOptions_OptionRetention || (FieldOptions_OptionRetention = {})); -/** - * This indicates the types of entities that the field may apply to when used - * as an option. If it is unset, then the field may be freely used as an - * option on any kind of entity. Note: as of January 2023, support for this is - * in progress and does not yet have an effect (b/264593489). - * - * @generated from protobuf enum google.protobuf.FieldOptions.OptionTargetType - */ -export var FieldOptions_OptionTargetType; -(function (FieldOptions_OptionTargetType) { - /** - * @generated from protobuf enum value: TARGET_TYPE_UNKNOWN = 0; - */ - FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_UNKNOWN"] = 0] = "TARGET_TYPE_UNKNOWN"; - /** - * @generated from protobuf enum value: TARGET_TYPE_FILE = 1; - */ - FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_FILE"] = 1] = "TARGET_TYPE_FILE"; - /** - * @generated from protobuf enum value: TARGET_TYPE_EXTENSION_RANGE = 2; - */ - FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_EXTENSION_RANGE"] = 2] = "TARGET_TYPE_EXTENSION_RANGE"; - /** - * @generated from protobuf enum value: TARGET_TYPE_MESSAGE = 3; - */ - FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_MESSAGE"] = 3] = "TARGET_TYPE_MESSAGE"; - /** - * @generated from protobuf enum value: TARGET_TYPE_FIELD = 4; - */ - FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_FIELD"] = 4] = "TARGET_TYPE_FIELD"; - /** - * @generated from protobuf enum value: TARGET_TYPE_ONEOF = 5; - */ - FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_ONEOF"] = 5] = "TARGET_TYPE_ONEOF"; - /** - * @generated from protobuf enum value: TARGET_TYPE_ENUM = 6; - */ - FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_ENUM"] = 6] = "TARGET_TYPE_ENUM"; - /** - * @generated from protobuf enum value: TARGET_TYPE_ENUM_ENTRY = 7; - */ - FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_ENUM_ENTRY"] = 7] = "TARGET_TYPE_ENUM_ENTRY"; - /** - * @generated from protobuf enum value: TARGET_TYPE_SERVICE = 8; - */ - FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_SERVICE"] = 8] = "TARGET_TYPE_SERVICE"; - /** - * @generated from protobuf enum value: TARGET_TYPE_METHOD = 9; - */ - FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_METHOD"] = 9] = "TARGET_TYPE_METHOD"; -})(FieldOptions_OptionTargetType || (FieldOptions_OptionTargetType = {})); -/** - * Is this method side-effect-free (or safe in HTTP parlance), or idempotent, - * or neither? HTTP based RPC implementation may choose GET verb for safe - * methods, and PUT verb for idempotent methods instead of the default POST. - * - * @generated from protobuf enum google.protobuf.MethodOptions.IdempotencyLevel - */ -export var MethodOptions_IdempotencyLevel; -(function (MethodOptions_IdempotencyLevel) { - /** - * @generated from protobuf enum value: IDEMPOTENCY_UNKNOWN = 0; - */ - MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["IDEMPOTENCY_UNKNOWN"] = 0] = "IDEMPOTENCY_UNKNOWN"; - /** - * implies idempotent - * - * @generated from protobuf enum value: NO_SIDE_EFFECTS = 1; - */ - MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["NO_SIDE_EFFECTS"] = 1] = "NO_SIDE_EFFECTS"; - /** - * idempotent, but may have side effects - * - * @generated from protobuf enum value: IDEMPOTENT = 2; - */ - MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["IDEMPOTENT"] = 2] = "IDEMPOTENT"; -})(MethodOptions_IdempotencyLevel || (MethodOptions_IdempotencyLevel = {})); -/** - * @generated from protobuf enum google.protobuf.FeatureSet.FieldPresence - */ -export var FeatureSet_FieldPresence; -(function (FeatureSet_FieldPresence) { - /** - * @generated from protobuf enum value: FIELD_PRESENCE_UNKNOWN = 0; - */ - FeatureSet_FieldPresence[FeatureSet_FieldPresence["FIELD_PRESENCE_UNKNOWN"] = 0] = "FIELD_PRESENCE_UNKNOWN"; - /** - * @generated from protobuf enum value: EXPLICIT = 1; - */ - FeatureSet_FieldPresence[FeatureSet_FieldPresence["EXPLICIT"] = 1] = "EXPLICIT"; - /** - * @generated from protobuf enum value: IMPLICIT = 2; - */ - FeatureSet_FieldPresence[FeatureSet_FieldPresence["IMPLICIT"] = 2] = "IMPLICIT"; - /** - * @generated from protobuf enum value: LEGACY_REQUIRED = 3; - */ - FeatureSet_FieldPresence[FeatureSet_FieldPresence["LEGACY_REQUIRED"] = 3] = "LEGACY_REQUIRED"; -})(FeatureSet_FieldPresence || (FeatureSet_FieldPresence = {})); -/** - * @generated from protobuf enum google.protobuf.FeatureSet.EnumType - */ -export var FeatureSet_EnumType; -(function (FeatureSet_EnumType) { - /** - * @generated from protobuf enum value: ENUM_TYPE_UNKNOWN = 0; - */ - FeatureSet_EnumType[FeatureSet_EnumType["ENUM_TYPE_UNKNOWN"] = 0] = "ENUM_TYPE_UNKNOWN"; - /** - * @generated from protobuf enum value: OPEN = 1; - */ - FeatureSet_EnumType[FeatureSet_EnumType["OPEN"] = 1] = "OPEN"; - /** - * @generated from protobuf enum value: CLOSED = 2; - */ - FeatureSet_EnumType[FeatureSet_EnumType["CLOSED"] = 2] = "CLOSED"; -})(FeatureSet_EnumType || (FeatureSet_EnumType = {})); -/** - * @generated from protobuf enum google.protobuf.FeatureSet.RepeatedFieldEncoding - */ -export var FeatureSet_RepeatedFieldEncoding; -(function (FeatureSet_RepeatedFieldEncoding) { - /** - * @generated from protobuf enum value: REPEATED_FIELD_ENCODING_UNKNOWN = 0; - */ - FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["REPEATED_FIELD_ENCODING_UNKNOWN"] = 0] = "REPEATED_FIELD_ENCODING_UNKNOWN"; - /** - * @generated from protobuf enum value: PACKED = 1; - */ - FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["PACKED"] = 1] = "PACKED"; - /** - * @generated from protobuf enum value: EXPANDED = 2; - */ - FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["EXPANDED"] = 2] = "EXPANDED"; -})(FeatureSet_RepeatedFieldEncoding || (FeatureSet_RepeatedFieldEncoding = {})); -/** - * @generated from protobuf enum google.protobuf.FeatureSet.Utf8Validation - */ -export var FeatureSet_Utf8Validation; -(function (FeatureSet_Utf8Validation) { - /** - * @generated from protobuf enum value: UTF8_VALIDATION_UNKNOWN = 0; - */ - FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["UTF8_VALIDATION_UNKNOWN"] = 0] = "UTF8_VALIDATION_UNKNOWN"; - /** - * @generated from protobuf enum value: VERIFY = 2; - */ - FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["VERIFY"] = 2] = "VERIFY"; - /** - * @generated from protobuf enum value: NONE = 3; - */ - FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["NONE"] = 3] = "NONE"; -})(FeatureSet_Utf8Validation || (FeatureSet_Utf8Validation = {})); -/** - * @generated from protobuf enum google.protobuf.FeatureSet.MessageEncoding - */ -export var FeatureSet_MessageEncoding; -(function (FeatureSet_MessageEncoding) { - /** - * @generated from protobuf enum value: MESSAGE_ENCODING_UNKNOWN = 0; - */ - FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["MESSAGE_ENCODING_UNKNOWN"] = 0] = "MESSAGE_ENCODING_UNKNOWN"; - /** - * @generated from protobuf enum value: LENGTH_PREFIXED = 1; - */ - FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["LENGTH_PREFIXED"] = 1] = "LENGTH_PREFIXED"; - /** - * @generated from protobuf enum value: DELIMITED = 2; - */ - FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["DELIMITED"] = 2] = "DELIMITED"; -})(FeatureSet_MessageEncoding || (FeatureSet_MessageEncoding = {})); -/** - * @generated from protobuf enum google.protobuf.FeatureSet.JsonFormat - */ -export var FeatureSet_JsonFormat; -(function (FeatureSet_JsonFormat) { - /** - * @generated from protobuf enum value: JSON_FORMAT_UNKNOWN = 0; - */ - FeatureSet_JsonFormat[FeatureSet_JsonFormat["JSON_FORMAT_UNKNOWN"] = 0] = "JSON_FORMAT_UNKNOWN"; - /** - * @generated from protobuf enum value: ALLOW = 1; - */ - FeatureSet_JsonFormat[FeatureSet_JsonFormat["ALLOW"] = 1] = "ALLOW"; - /** - * @generated from protobuf enum value: LEGACY_BEST_EFFORT = 2; - */ - FeatureSet_JsonFormat[FeatureSet_JsonFormat["LEGACY_BEST_EFFORT"] = 2] = "LEGACY_BEST_EFFORT"; -})(FeatureSet_JsonFormat || (FeatureSet_JsonFormat = {})); -/** - * Represents the identified object's effect on the element in the original - * .proto file. - * - * @generated from protobuf enum google.protobuf.GeneratedCodeInfo.Annotation.Semantic - */ -export var GeneratedCodeInfo_Annotation_Semantic; -(function (GeneratedCodeInfo_Annotation_Semantic) { - /** - * There is no effect or the effect is indescribable. - * - * @generated from protobuf enum value: NONE = 0; - */ - GeneratedCodeInfo_Annotation_Semantic[GeneratedCodeInfo_Annotation_Semantic["NONE"] = 0] = "NONE"; - /** - * The element is set or otherwise mutated. - * - * @generated from protobuf enum value: SET = 1; - */ - GeneratedCodeInfo_Annotation_Semantic[GeneratedCodeInfo_Annotation_Semantic["SET"] = 1] = "SET"; - /** - * An alias to the element is returned. - * - * @generated from protobuf enum value: ALIAS = 2; - */ - GeneratedCodeInfo_Annotation_Semantic[GeneratedCodeInfo_Annotation_Semantic["ALIAS"] = 2] = "ALIAS"; -})(GeneratedCodeInfo_Annotation_Semantic || (GeneratedCodeInfo_Annotation_Semantic = {})); -/** - * The full set of known editions. - * - * @generated from protobuf enum google.protobuf.Edition - */ -export var Edition; -(function (Edition) { - /** - * A placeholder for an unknown edition value. - * - * @generated from protobuf enum value: EDITION_UNKNOWN = 0; - */ - Edition[Edition["EDITION_UNKNOWN"] = 0] = "EDITION_UNKNOWN"; - /** - * A placeholder edition for specifying default behaviors *before* a feature - * was first introduced. This is effectively an "infinite past". - * - * @generated from protobuf enum value: EDITION_LEGACY = 900; - */ - Edition[Edition["EDITION_LEGACY"] = 900] = "EDITION_LEGACY"; - /** - * Legacy syntax "editions". These pre-date editions, but behave much like - * distinct editions. These can't be used to specify the edition of proto - * files, but feature definitions must supply proto2/proto3 defaults for - * backwards compatibility. - * - * @generated from protobuf enum value: EDITION_PROTO2 = 998; - */ - Edition[Edition["EDITION_PROTO2"] = 998] = "EDITION_PROTO2"; - /** - * @generated from protobuf enum value: EDITION_PROTO3 = 999; - */ - Edition[Edition["EDITION_PROTO3"] = 999] = "EDITION_PROTO3"; - /** - * Editions that have been released. The specific values are arbitrary and - * should not be depended on, but they will always be time-ordered for easy - * comparison. - * - * @generated from protobuf enum value: EDITION_2023 = 1000; - */ - Edition[Edition["EDITION_2023"] = 1000] = "EDITION_2023"; - /** - * @generated from protobuf enum value: EDITION_2024 = 1001; - */ - Edition[Edition["EDITION_2024"] = 1001] = "EDITION_2024"; - /** - * Placeholder editions for testing feature resolution. These should not be - * used or relyed on outside of tests. - * - * @generated from protobuf enum value: EDITION_1_TEST_ONLY = 1; - */ - Edition[Edition["EDITION_1_TEST_ONLY"] = 1] = "EDITION_1_TEST_ONLY"; - /** - * @generated from protobuf enum value: EDITION_2_TEST_ONLY = 2; - */ - Edition[Edition["EDITION_2_TEST_ONLY"] = 2] = "EDITION_2_TEST_ONLY"; - /** - * @generated from protobuf enum value: EDITION_99997_TEST_ONLY = 99997; - */ - Edition[Edition["EDITION_99997_TEST_ONLY"] = 99997] = "EDITION_99997_TEST_ONLY"; - /** - * @generated from protobuf enum value: EDITION_99998_TEST_ONLY = 99998; - */ - Edition[Edition["EDITION_99998_TEST_ONLY"] = 99998] = "EDITION_99998_TEST_ONLY"; - /** - * @generated from protobuf enum value: EDITION_99999_TEST_ONLY = 99999; - */ - Edition[Edition["EDITION_99999_TEST_ONLY"] = 99999] = "EDITION_99999_TEST_ONLY"; - /** - * Placeholder for specifying unbounded edition support. This should only - * ever be used by plugins that can expect to never require any changes to - * support a new edition. - * - * @generated from protobuf enum value: EDITION_MAX = 2147483647; - */ - Edition[Edition["EDITION_MAX"] = 2147483647] = "EDITION_MAX"; -})(Edition || (Edition = {})); -// @generated message type with reflection information, may provide speed optimized methods -class FileDescriptorSet$Type extends MessageType { - constructor() { - super("google.protobuf.FileDescriptorSet", [ - { no: 1, name: "file", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FileDescriptorProto } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.file = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* repeated google.protobuf.FileDescriptorProto file */ 1: - message.file.push(FileDescriptorProto.internalBinaryRead(reader, reader.uint32(), options)); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* repeated google.protobuf.FileDescriptorProto file = 1; */ - for (let i = 0; i < message.file.length; i++) - FileDescriptorProto.internalBinaryWrite(message.file[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.FileDescriptorSet - */ -export const FileDescriptorSet = new FileDescriptorSet$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class FileDescriptorProto$Type extends MessageType { - constructor() { - super("google.protobuf.FileDescriptorProto", [ - { no: 1, name: "name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 2, name: "package", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 3, name: "dependency", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }, - { no: 10, name: "public_dependency", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 5 /*ScalarType.INT32*/ }, - { no: 11, name: "weak_dependency", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 5 /*ScalarType.INT32*/ }, - { no: 4, name: "message_type", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DescriptorProto }, - { no: 5, name: "enum_type", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => EnumDescriptorProto }, - { no: 6, name: "service", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ServiceDescriptorProto }, - { no: 7, name: "extension", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FieldDescriptorProto }, - { no: 8, name: "options", kind: "message", T: () => FileOptions }, - { no: 9, name: "source_code_info", kind: "message", T: () => SourceCodeInfo }, - { no: 12, name: "syntax", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 14, name: "edition", kind: "enum", opt: true, T: () => ["google.protobuf.Edition", Edition] } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.dependency = []; - message.publicDependency = []; - message.weakDependency = []; - message.messageType = []; - message.enumType = []; - message.service = []; - message.extension = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional string name */ 1: - message.name = reader.string(); - break; - case /* optional string package */ 2: - message.package = reader.string(); - break; - case /* repeated string dependency */ 3: - message.dependency.push(reader.string()); - break; - case /* repeated int32 public_dependency */ 10: - if (wireType === WireType.LengthDelimited) - for (let e = reader.int32() + reader.pos; reader.pos < e;) - message.publicDependency.push(reader.int32()); - else - message.publicDependency.push(reader.int32()); - break; - case /* repeated int32 weak_dependency */ 11: - if (wireType === WireType.LengthDelimited) - for (let e = reader.int32() + reader.pos; reader.pos < e;) - message.weakDependency.push(reader.int32()); - else - message.weakDependency.push(reader.int32()); - break; - case /* repeated google.protobuf.DescriptorProto message_type */ 4: - message.messageType.push(DescriptorProto.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* repeated google.protobuf.EnumDescriptorProto enum_type */ 5: - message.enumType.push(EnumDescriptorProto.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* repeated google.protobuf.ServiceDescriptorProto service */ 6: - message.service.push(ServiceDescriptorProto.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* repeated google.protobuf.FieldDescriptorProto extension */ 7: - message.extension.push(FieldDescriptorProto.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* optional google.protobuf.FileOptions options */ 8: - message.options = FileOptions.internalBinaryRead(reader, reader.uint32(), options, message.options); - break; - case /* optional google.protobuf.SourceCodeInfo source_code_info */ 9: - message.sourceCodeInfo = SourceCodeInfo.internalBinaryRead(reader, reader.uint32(), options, message.sourceCodeInfo); - break; - case /* optional string syntax */ 12: - message.syntax = reader.string(); - break; - case /* optional google.protobuf.Edition edition */ 14: - message.edition = reader.int32(); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional string name = 1; */ - if (message.name !== undefined) - writer.tag(1, WireType.LengthDelimited).string(message.name); - /* optional string package = 2; */ - if (message.package !== undefined) - writer.tag(2, WireType.LengthDelimited).string(message.package); - /* repeated string dependency = 3; */ - for (let i = 0; i < message.dependency.length; i++) - writer.tag(3, WireType.LengthDelimited).string(message.dependency[i]); - /* repeated int32 public_dependency = 10; */ - for (let i = 0; i < message.publicDependency.length; i++) - writer.tag(10, WireType.Varint).int32(message.publicDependency[i]); - /* repeated int32 weak_dependency = 11; */ - for (let i = 0; i < message.weakDependency.length; i++) - writer.tag(11, WireType.Varint).int32(message.weakDependency[i]); - /* repeated google.protobuf.DescriptorProto message_type = 4; */ - for (let i = 0; i < message.messageType.length; i++) - DescriptorProto.internalBinaryWrite(message.messageType[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.EnumDescriptorProto enum_type = 5; */ - for (let i = 0; i < message.enumType.length; i++) - EnumDescriptorProto.internalBinaryWrite(message.enumType[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.ServiceDescriptorProto service = 6; */ - for (let i = 0; i < message.service.length; i++) - ServiceDescriptorProto.internalBinaryWrite(message.service[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.FieldDescriptorProto extension = 7; */ - for (let i = 0; i < message.extension.length; i++) - FieldDescriptorProto.internalBinaryWrite(message.extension[i], writer.tag(7, WireType.LengthDelimited).fork(), options).join(); - /* optional google.protobuf.FileOptions options = 8; */ - if (message.options) - FileOptions.internalBinaryWrite(message.options, writer.tag(8, WireType.LengthDelimited).fork(), options).join(); - /* optional google.protobuf.SourceCodeInfo source_code_info = 9; */ - if (message.sourceCodeInfo) - SourceCodeInfo.internalBinaryWrite(message.sourceCodeInfo, writer.tag(9, WireType.LengthDelimited).fork(), options).join(); - /* optional string syntax = 12; */ - if (message.syntax !== undefined) - writer.tag(12, WireType.LengthDelimited).string(message.syntax); - /* optional google.protobuf.Edition edition = 14; */ - if (message.edition !== undefined) - writer.tag(14, WireType.Varint).int32(message.edition); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.FileDescriptorProto - */ -export const FileDescriptorProto = new FileDescriptorProto$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class DescriptorProto$Type extends MessageType { - constructor() { - super("google.protobuf.DescriptorProto", [ - { no: 1, name: "name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 2, name: "field", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FieldDescriptorProto }, - { no: 6, name: "extension", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FieldDescriptorProto }, - { no: 3, name: "nested_type", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DescriptorProto }, - { no: 4, name: "enum_type", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => EnumDescriptorProto }, - { no: 5, name: "extension_range", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DescriptorProto_ExtensionRange }, - { no: 8, name: "oneof_decl", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => OneofDescriptorProto }, - { no: 7, name: "options", kind: "message", T: () => MessageOptions }, - { no: 9, name: "reserved_range", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DescriptorProto_ReservedRange }, - { no: 10, name: "reserved_name", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.field = []; - message.extension = []; - message.nestedType = []; - message.enumType = []; - message.extensionRange = []; - message.oneofDecl = []; - message.reservedRange = []; - message.reservedName = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional string name */ 1: - message.name = reader.string(); - break; - case /* repeated google.protobuf.FieldDescriptorProto field */ 2: - message.field.push(FieldDescriptorProto.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* repeated google.protobuf.FieldDescriptorProto extension */ 6: - message.extension.push(FieldDescriptorProto.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* repeated google.protobuf.DescriptorProto nested_type */ 3: - message.nestedType.push(DescriptorProto.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* repeated google.protobuf.EnumDescriptorProto enum_type */ 4: - message.enumType.push(EnumDescriptorProto.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* repeated google.protobuf.DescriptorProto.ExtensionRange extension_range */ 5: - message.extensionRange.push(DescriptorProto_ExtensionRange.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* repeated google.protobuf.OneofDescriptorProto oneof_decl */ 8: - message.oneofDecl.push(OneofDescriptorProto.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* optional google.protobuf.MessageOptions options */ 7: - message.options = MessageOptions.internalBinaryRead(reader, reader.uint32(), options, message.options); - break; - case /* repeated google.protobuf.DescriptorProto.ReservedRange reserved_range */ 9: - message.reservedRange.push(DescriptorProto_ReservedRange.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* repeated string reserved_name */ 10: - message.reservedName.push(reader.string()); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional string name = 1; */ - if (message.name !== undefined) - writer.tag(1, WireType.LengthDelimited).string(message.name); - /* repeated google.protobuf.FieldDescriptorProto field = 2; */ - for (let i = 0; i < message.field.length; i++) - FieldDescriptorProto.internalBinaryWrite(message.field[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.FieldDescriptorProto extension = 6; */ - for (let i = 0; i < message.extension.length; i++) - FieldDescriptorProto.internalBinaryWrite(message.extension[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.DescriptorProto nested_type = 3; */ - for (let i = 0; i < message.nestedType.length; i++) - DescriptorProto.internalBinaryWrite(message.nestedType[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.EnumDescriptorProto enum_type = 4; */ - for (let i = 0; i < message.enumType.length; i++) - EnumDescriptorProto.internalBinaryWrite(message.enumType[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.DescriptorProto.ExtensionRange extension_range = 5; */ - for (let i = 0; i < message.extensionRange.length; i++) - DescriptorProto_ExtensionRange.internalBinaryWrite(message.extensionRange[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.OneofDescriptorProto oneof_decl = 8; */ - for (let i = 0; i < message.oneofDecl.length; i++) - OneofDescriptorProto.internalBinaryWrite(message.oneofDecl[i], writer.tag(8, WireType.LengthDelimited).fork(), options).join(); - /* optional google.protobuf.MessageOptions options = 7; */ - if (message.options) - MessageOptions.internalBinaryWrite(message.options, writer.tag(7, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.DescriptorProto.ReservedRange reserved_range = 9; */ - for (let i = 0; i < message.reservedRange.length; i++) - DescriptorProto_ReservedRange.internalBinaryWrite(message.reservedRange[i], writer.tag(9, WireType.LengthDelimited).fork(), options).join(); - /* repeated string reserved_name = 10; */ - for (let i = 0; i < message.reservedName.length; i++) - writer.tag(10, WireType.LengthDelimited).string(message.reservedName[i]); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.DescriptorProto - */ -export const DescriptorProto = new DescriptorProto$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class DescriptorProto_ExtensionRange$Type extends MessageType { - constructor() { - super("google.protobuf.DescriptorProto.ExtensionRange", [ - { no: 1, name: "start", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ }, - { no: 2, name: "end", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ }, - { no: 3, name: "options", kind: "message", T: () => ExtensionRangeOptions } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional int32 start */ 1: - message.start = reader.int32(); - break; - case /* optional int32 end */ 2: - message.end = reader.int32(); - break; - case /* optional google.protobuf.ExtensionRangeOptions options */ 3: - message.options = ExtensionRangeOptions.internalBinaryRead(reader, reader.uint32(), options, message.options); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional int32 start = 1; */ - if (message.start !== undefined) - writer.tag(1, WireType.Varint).int32(message.start); - /* optional int32 end = 2; */ - if (message.end !== undefined) - writer.tag(2, WireType.Varint).int32(message.end); - /* optional google.protobuf.ExtensionRangeOptions options = 3; */ - if (message.options) - ExtensionRangeOptions.internalBinaryWrite(message.options, writer.tag(3, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.DescriptorProto.ExtensionRange - */ -export const DescriptorProto_ExtensionRange = new DescriptorProto_ExtensionRange$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class DescriptorProto_ReservedRange$Type extends MessageType { - constructor() { - super("google.protobuf.DescriptorProto.ReservedRange", [ - { no: 1, name: "start", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ }, - { no: 2, name: "end", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional int32 start */ 1: - message.start = reader.int32(); - break; - case /* optional int32 end */ 2: - message.end = reader.int32(); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional int32 start = 1; */ - if (message.start !== undefined) - writer.tag(1, WireType.Varint).int32(message.start); - /* optional int32 end = 2; */ - if (message.end !== undefined) - writer.tag(2, WireType.Varint).int32(message.end); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.DescriptorProto.ReservedRange - */ -export const DescriptorProto_ReservedRange = new DescriptorProto_ReservedRange$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class ExtensionRangeOptions$Type extends MessageType { - constructor() { - super("google.protobuf.ExtensionRangeOptions", [ - { no: 999, name: "uninterpreted_option", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption }, - { no: 2, name: "declaration", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ExtensionRangeOptions_Declaration }, - { no: 50, name: "features", kind: "message", T: () => FeatureSet }, - { no: 3, name: "verification", kind: "enum", opt: true, T: () => ["google.protobuf.ExtensionRangeOptions.VerificationState", ExtensionRangeOptions_VerificationState] } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.uninterpretedOption = []; - message.declaration = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: - message.uninterpretedOption.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* repeated google.protobuf.ExtensionRangeOptions.Declaration declaration */ 2: - message.declaration.push(ExtensionRangeOptions_Declaration.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* optional google.protobuf.FeatureSet features */ 50: - message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); - break; - case /* optional google.protobuf.ExtensionRangeOptions.VerificationState verification */ 3: - message.verification = reader.int32(); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ - for (let i = 0; i < message.uninterpretedOption.length; i++) - UninterpretedOption.internalBinaryWrite(message.uninterpretedOption[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.ExtensionRangeOptions.Declaration declaration = 2; */ - for (let i = 0; i < message.declaration.length; i++) - ExtensionRangeOptions_Declaration.internalBinaryWrite(message.declaration[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join(); - /* optional google.protobuf.FeatureSet features = 50; */ - if (message.features) - FeatureSet.internalBinaryWrite(message.features, writer.tag(50, WireType.LengthDelimited).fork(), options).join(); - /* optional google.protobuf.ExtensionRangeOptions.VerificationState verification = 3; */ - if (message.verification !== undefined) - writer.tag(3, WireType.Varint).int32(message.verification); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.ExtensionRangeOptions - */ -export const ExtensionRangeOptions = new ExtensionRangeOptions$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class ExtensionRangeOptions_Declaration$Type extends MessageType { - constructor() { - super("google.protobuf.ExtensionRangeOptions.Declaration", [ - { no: 1, name: "number", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ }, - { no: 2, name: "full_name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 3, name: "type", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 5, name: "reserved", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 6, name: "repeated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional int32 number */ 1: - message.number = reader.int32(); - break; - case /* optional string full_name */ 2: - message.fullName = reader.string(); - break; - case /* optional string type */ 3: - message.type = reader.string(); - break; - case /* optional bool reserved */ 5: - message.reserved = reader.bool(); - break; - case /* optional bool repeated */ 6: - message.repeated = reader.bool(); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional int32 number = 1; */ - if (message.number !== undefined) - writer.tag(1, WireType.Varint).int32(message.number); - /* optional string full_name = 2; */ - if (message.fullName !== undefined) - writer.tag(2, WireType.LengthDelimited).string(message.fullName); - /* optional string type = 3; */ - if (message.type !== undefined) - writer.tag(3, WireType.LengthDelimited).string(message.type); - /* optional bool reserved = 5; */ - if (message.reserved !== undefined) - writer.tag(5, WireType.Varint).bool(message.reserved); - /* optional bool repeated = 6; */ - if (message.repeated !== undefined) - writer.tag(6, WireType.Varint).bool(message.repeated); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.ExtensionRangeOptions.Declaration - */ -export const ExtensionRangeOptions_Declaration = new ExtensionRangeOptions_Declaration$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class FieldDescriptorProto$Type extends MessageType { - constructor() { - super("google.protobuf.FieldDescriptorProto", [ - { no: 1, name: "name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 3, name: "number", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ }, - { no: 4, name: "label", kind: "enum", opt: true, T: () => ["google.protobuf.FieldDescriptorProto.Label", FieldDescriptorProto_Label, "LABEL_"] }, - { no: 5, name: "type", kind: "enum", opt: true, T: () => ["google.protobuf.FieldDescriptorProto.Type", FieldDescriptorProto_Type, "TYPE_"] }, - { no: 6, name: "type_name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 2, name: "extendee", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 7, name: "default_value", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 9, name: "oneof_index", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ }, - { no: 10, name: "json_name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 8, name: "options", kind: "message", T: () => FieldOptions }, - { no: 17, name: "proto3_optional", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional string name */ 1: - message.name = reader.string(); - break; - case /* optional int32 number */ 3: - message.number = reader.int32(); - break; - case /* optional google.protobuf.FieldDescriptorProto.Label label */ 4: - message.label = reader.int32(); - break; - case /* optional google.protobuf.FieldDescriptorProto.Type type */ 5: - message.type = reader.int32(); - break; - case /* optional string type_name */ 6: - message.typeName = reader.string(); - break; - case /* optional string extendee */ 2: - message.extendee = reader.string(); - break; - case /* optional string default_value */ 7: - message.defaultValue = reader.string(); - break; - case /* optional int32 oneof_index */ 9: - message.oneofIndex = reader.int32(); - break; - case /* optional string json_name */ 10: - message.jsonName = reader.string(); - break; - case /* optional google.protobuf.FieldOptions options */ 8: - message.options = FieldOptions.internalBinaryRead(reader, reader.uint32(), options, message.options); - break; - case /* optional bool proto3_optional */ 17: - message.proto3Optional = reader.bool(); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional string name = 1; */ - if (message.name !== undefined) - writer.tag(1, WireType.LengthDelimited).string(message.name); - /* optional int32 number = 3; */ - if (message.number !== undefined) - writer.tag(3, WireType.Varint).int32(message.number); - /* optional google.protobuf.FieldDescriptorProto.Label label = 4; */ - if (message.label !== undefined) - writer.tag(4, WireType.Varint).int32(message.label); - /* optional google.protobuf.FieldDescriptorProto.Type type = 5; */ - if (message.type !== undefined) - writer.tag(5, WireType.Varint).int32(message.type); - /* optional string type_name = 6; */ - if (message.typeName !== undefined) - writer.tag(6, WireType.LengthDelimited).string(message.typeName); - /* optional string extendee = 2; */ - if (message.extendee !== undefined) - writer.tag(2, WireType.LengthDelimited).string(message.extendee); - /* optional string default_value = 7; */ - if (message.defaultValue !== undefined) - writer.tag(7, WireType.LengthDelimited).string(message.defaultValue); - /* optional int32 oneof_index = 9; */ - if (message.oneofIndex !== undefined) - writer.tag(9, WireType.Varint).int32(message.oneofIndex); - /* optional string json_name = 10; */ - if (message.jsonName !== undefined) - writer.tag(10, WireType.LengthDelimited).string(message.jsonName); - /* optional google.protobuf.FieldOptions options = 8; */ - if (message.options) - FieldOptions.internalBinaryWrite(message.options, writer.tag(8, WireType.LengthDelimited).fork(), options).join(); - /* optional bool proto3_optional = 17; */ - if (message.proto3Optional !== undefined) - writer.tag(17, WireType.Varint).bool(message.proto3Optional); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.FieldDescriptorProto - */ -export const FieldDescriptorProto = new FieldDescriptorProto$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class OneofDescriptorProto$Type extends MessageType { - constructor() { - super("google.protobuf.OneofDescriptorProto", [ - { no: 1, name: "name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 2, name: "options", kind: "message", T: () => OneofOptions } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional string name */ 1: - message.name = reader.string(); - break; - case /* optional google.protobuf.OneofOptions options */ 2: - message.options = OneofOptions.internalBinaryRead(reader, reader.uint32(), options, message.options); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional string name = 1; */ - if (message.name !== undefined) - writer.tag(1, WireType.LengthDelimited).string(message.name); - /* optional google.protobuf.OneofOptions options = 2; */ - if (message.options) - OneofOptions.internalBinaryWrite(message.options, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.OneofDescriptorProto - */ -export const OneofDescriptorProto = new OneofDescriptorProto$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class EnumDescriptorProto$Type extends MessageType { - constructor() { - super("google.protobuf.EnumDescriptorProto", [ - { no: 1, name: "name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 2, name: "value", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => EnumValueDescriptorProto }, - { no: 3, name: "options", kind: "message", T: () => EnumOptions }, - { no: 4, name: "reserved_range", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => EnumDescriptorProto_EnumReservedRange }, - { no: 5, name: "reserved_name", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.value = []; - message.reservedRange = []; - message.reservedName = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional string name */ 1: - message.name = reader.string(); - break; - case /* repeated google.protobuf.EnumValueDescriptorProto value */ 2: - message.value.push(EnumValueDescriptorProto.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* optional google.protobuf.EnumOptions options */ 3: - message.options = EnumOptions.internalBinaryRead(reader, reader.uint32(), options, message.options); - break; - case /* repeated google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range */ 4: - message.reservedRange.push(EnumDescriptorProto_EnumReservedRange.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* repeated string reserved_name */ 5: - message.reservedName.push(reader.string()); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional string name = 1; */ - if (message.name !== undefined) - writer.tag(1, WireType.LengthDelimited).string(message.name); - /* repeated google.protobuf.EnumValueDescriptorProto value = 2; */ - for (let i = 0; i < message.value.length; i++) - EnumValueDescriptorProto.internalBinaryWrite(message.value[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join(); - /* optional google.protobuf.EnumOptions options = 3; */ - if (message.options) - EnumOptions.internalBinaryWrite(message.options, writer.tag(3, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4; */ - for (let i = 0; i < message.reservedRange.length; i++) - EnumDescriptorProto_EnumReservedRange.internalBinaryWrite(message.reservedRange[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join(); - /* repeated string reserved_name = 5; */ - for (let i = 0; i < message.reservedName.length; i++) - writer.tag(5, WireType.LengthDelimited).string(message.reservedName[i]); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.EnumDescriptorProto - */ -export const EnumDescriptorProto = new EnumDescriptorProto$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class EnumDescriptorProto_EnumReservedRange$Type extends MessageType { - constructor() { - super("google.protobuf.EnumDescriptorProto.EnumReservedRange", [ - { no: 1, name: "start", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ }, - { no: 2, name: "end", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional int32 start */ 1: - message.start = reader.int32(); - break; - case /* optional int32 end */ 2: - message.end = reader.int32(); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional int32 start = 1; */ - if (message.start !== undefined) - writer.tag(1, WireType.Varint).int32(message.start); - /* optional int32 end = 2; */ - if (message.end !== undefined) - writer.tag(2, WireType.Varint).int32(message.end); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.EnumDescriptorProto.EnumReservedRange - */ -export const EnumDescriptorProto_EnumReservedRange = new EnumDescriptorProto_EnumReservedRange$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class EnumValueDescriptorProto$Type extends MessageType { - constructor() { - super("google.protobuf.EnumValueDescriptorProto", [ - { no: 1, name: "name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 2, name: "number", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ }, - { no: 3, name: "options", kind: "message", T: () => EnumValueOptions } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional string name */ 1: - message.name = reader.string(); - break; - case /* optional int32 number */ 2: - message.number = reader.int32(); - break; - case /* optional google.protobuf.EnumValueOptions options */ 3: - message.options = EnumValueOptions.internalBinaryRead(reader, reader.uint32(), options, message.options); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional string name = 1; */ - if (message.name !== undefined) - writer.tag(1, WireType.LengthDelimited).string(message.name); - /* optional int32 number = 2; */ - if (message.number !== undefined) - writer.tag(2, WireType.Varint).int32(message.number); - /* optional google.protobuf.EnumValueOptions options = 3; */ - if (message.options) - EnumValueOptions.internalBinaryWrite(message.options, writer.tag(3, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.EnumValueDescriptorProto - */ -export const EnumValueDescriptorProto = new EnumValueDescriptorProto$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class ServiceDescriptorProto$Type extends MessageType { - constructor() { - super("google.protobuf.ServiceDescriptorProto", [ - { no: 1, name: "name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 2, name: "method", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => MethodDescriptorProto }, - { no: 3, name: "options", kind: "message", T: () => ServiceOptions } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.method = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional string name */ 1: - message.name = reader.string(); - break; - case /* repeated google.protobuf.MethodDescriptorProto method */ 2: - message.method.push(MethodDescriptorProto.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* optional google.protobuf.ServiceOptions options */ 3: - message.options = ServiceOptions.internalBinaryRead(reader, reader.uint32(), options, message.options); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional string name = 1; */ - if (message.name !== undefined) - writer.tag(1, WireType.LengthDelimited).string(message.name); - /* repeated google.protobuf.MethodDescriptorProto method = 2; */ - for (let i = 0; i < message.method.length; i++) - MethodDescriptorProto.internalBinaryWrite(message.method[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join(); - /* optional google.protobuf.ServiceOptions options = 3; */ - if (message.options) - ServiceOptions.internalBinaryWrite(message.options, writer.tag(3, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.ServiceDescriptorProto - */ -export const ServiceDescriptorProto = new ServiceDescriptorProto$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class MethodDescriptorProto$Type extends MessageType { - constructor() { - super("google.protobuf.MethodDescriptorProto", [ - { no: 1, name: "name", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 2, name: "input_type", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 3, name: "output_type", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 4, name: "options", kind: "message", T: () => MethodOptions }, - { no: 5, name: "client_streaming", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 6, name: "server_streaming", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional string name */ 1: - message.name = reader.string(); - break; - case /* optional string input_type */ 2: - message.inputType = reader.string(); - break; - case /* optional string output_type */ 3: - message.outputType = reader.string(); - break; - case /* optional google.protobuf.MethodOptions options */ 4: - message.options = MethodOptions.internalBinaryRead(reader, reader.uint32(), options, message.options); - break; - case /* optional bool client_streaming */ 5: - message.clientStreaming = reader.bool(); - break; - case /* optional bool server_streaming */ 6: - message.serverStreaming = reader.bool(); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional string name = 1; */ - if (message.name !== undefined) - writer.tag(1, WireType.LengthDelimited).string(message.name); - /* optional string input_type = 2; */ - if (message.inputType !== undefined) - writer.tag(2, WireType.LengthDelimited).string(message.inputType); - /* optional string output_type = 3; */ - if (message.outputType !== undefined) - writer.tag(3, WireType.LengthDelimited).string(message.outputType); - /* optional google.protobuf.MethodOptions options = 4; */ - if (message.options) - MethodOptions.internalBinaryWrite(message.options, writer.tag(4, WireType.LengthDelimited).fork(), options).join(); - /* optional bool client_streaming = 5; */ - if (message.clientStreaming !== undefined) - writer.tag(5, WireType.Varint).bool(message.clientStreaming); - /* optional bool server_streaming = 6; */ - if (message.serverStreaming !== undefined) - writer.tag(6, WireType.Varint).bool(message.serverStreaming); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.MethodDescriptorProto - */ -export const MethodDescriptorProto = new MethodDescriptorProto$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class FileOptions$Type extends MessageType { - constructor() { - super("google.protobuf.FileOptions", [ - { no: 1, name: "java_package", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 8, name: "java_outer_classname", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 10, name: "java_multiple_files", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 20, name: "java_generate_equals_and_hash", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 27, name: "java_string_check_utf8", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 9, name: "optimize_for", kind: "enum", opt: true, T: () => ["google.protobuf.FileOptions.OptimizeMode", FileOptions_OptimizeMode] }, - { no: 11, name: "go_package", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 16, name: "cc_generic_services", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 17, name: "java_generic_services", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 18, name: "py_generic_services", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 23, name: "deprecated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 31, name: "cc_enable_arenas", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 36, name: "objc_class_prefix", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 37, name: "csharp_namespace", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 39, name: "swift_prefix", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 40, name: "php_class_prefix", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 41, name: "php_namespace", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 44, name: "php_metadata_namespace", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 45, name: "ruby_package", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 50, name: "features", kind: "message", T: () => FeatureSet }, - { no: 999, name: "uninterpreted_option", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.uninterpretedOption = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional string java_package */ 1: - message.javaPackage = reader.string(); - break; - case /* optional string java_outer_classname */ 8: - message.javaOuterClassname = reader.string(); - break; - case /* optional bool java_multiple_files */ 10: - message.javaMultipleFiles = reader.bool(); - break; - case /* optional bool java_generate_equals_and_hash = 20 [deprecated = true];*/ 20: - message.javaGenerateEqualsAndHash = reader.bool(); - break; - case /* optional bool java_string_check_utf8 */ 27: - message.javaStringCheckUtf8 = reader.bool(); - break; - case /* optional google.protobuf.FileOptions.OptimizeMode optimize_for */ 9: - message.optimizeFor = reader.int32(); - break; - case /* optional string go_package */ 11: - message.goPackage = reader.string(); - break; - case /* optional bool cc_generic_services */ 16: - message.ccGenericServices = reader.bool(); - break; - case /* optional bool java_generic_services */ 17: - message.javaGenericServices = reader.bool(); - break; - case /* optional bool py_generic_services */ 18: - message.pyGenericServices = reader.bool(); - break; - case /* optional bool deprecated */ 23: - message.deprecated = reader.bool(); - break; - case /* optional bool cc_enable_arenas */ 31: - message.ccEnableArenas = reader.bool(); - break; - case /* optional string objc_class_prefix */ 36: - message.objcClassPrefix = reader.string(); - break; - case /* optional string csharp_namespace */ 37: - message.csharpNamespace = reader.string(); - break; - case /* optional string swift_prefix */ 39: - message.swiftPrefix = reader.string(); - break; - case /* optional string php_class_prefix */ 40: - message.phpClassPrefix = reader.string(); - break; - case /* optional string php_namespace */ 41: - message.phpNamespace = reader.string(); - break; - case /* optional string php_metadata_namespace */ 44: - message.phpMetadataNamespace = reader.string(); - break; - case /* optional string ruby_package */ 45: - message.rubyPackage = reader.string(); - break; - case /* optional google.protobuf.FeatureSet features */ 50: - message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); - break; - case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: - message.uninterpretedOption.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional string java_package = 1; */ - if (message.javaPackage !== undefined) - writer.tag(1, WireType.LengthDelimited).string(message.javaPackage); - /* optional string java_outer_classname = 8; */ - if (message.javaOuterClassname !== undefined) - writer.tag(8, WireType.LengthDelimited).string(message.javaOuterClassname); - /* optional bool java_multiple_files = 10; */ - if (message.javaMultipleFiles !== undefined) - writer.tag(10, WireType.Varint).bool(message.javaMultipleFiles); - /* optional bool java_generate_equals_and_hash = 20 [deprecated = true]; */ - if (message.javaGenerateEqualsAndHash !== undefined) - writer.tag(20, WireType.Varint).bool(message.javaGenerateEqualsAndHash); - /* optional bool java_string_check_utf8 = 27; */ - if (message.javaStringCheckUtf8 !== undefined) - writer.tag(27, WireType.Varint).bool(message.javaStringCheckUtf8); - /* optional google.protobuf.FileOptions.OptimizeMode optimize_for = 9; */ - if (message.optimizeFor !== undefined) - writer.tag(9, WireType.Varint).int32(message.optimizeFor); - /* optional string go_package = 11; */ - if (message.goPackage !== undefined) - writer.tag(11, WireType.LengthDelimited).string(message.goPackage); - /* optional bool cc_generic_services = 16; */ - if (message.ccGenericServices !== undefined) - writer.tag(16, WireType.Varint).bool(message.ccGenericServices); - /* optional bool java_generic_services = 17; */ - if (message.javaGenericServices !== undefined) - writer.tag(17, WireType.Varint).bool(message.javaGenericServices); - /* optional bool py_generic_services = 18; */ - if (message.pyGenericServices !== undefined) - writer.tag(18, WireType.Varint).bool(message.pyGenericServices); - /* optional bool deprecated = 23; */ - if (message.deprecated !== undefined) - writer.tag(23, WireType.Varint).bool(message.deprecated); - /* optional bool cc_enable_arenas = 31; */ - if (message.ccEnableArenas !== undefined) - writer.tag(31, WireType.Varint).bool(message.ccEnableArenas); - /* optional string objc_class_prefix = 36; */ - if (message.objcClassPrefix !== undefined) - writer.tag(36, WireType.LengthDelimited).string(message.objcClassPrefix); - /* optional string csharp_namespace = 37; */ - if (message.csharpNamespace !== undefined) - writer.tag(37, WireType.LengthDelimited).string(message.csharpNamespace); - /* optional string swift_prefix = 39; */ - if (message.swiftPrefix !== undefined) - writer.tag(39, WireType.LengthDelimited).string(message.swiftPrefix); - /* optional string php_class_prefix = 40; */ - if (message.phpClassPrefix !== undefined) - writer.tag(40, WireType.LengthDelimited).string(message.phpClassPrefix); - /* optional string php_namespace = 41; */ - if (message.phpNamespace !== undefined) - writer.tag(41, WireType.LengthDelimited).string(message.phpNamespace); - /* optional string php_metadata_namespace = 44; */ - if (message.phpMetadataNamespace !== undefined) - writer.tag(44, WireType.LengthDelimited).string(message.phpMetadataNamespace); - /* optional string ruby_package = 45; */ - if (message.rubyPackage !== undefined) - writer.tag(45, WireType.LengthDelimited).string(message.rubyPackage); - /* optional google.protobuf.FeatureSet features = 50; */ - if (message.features) - FeatureSet.internalBinaryWrite(message.features, writer.tag(50, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ - for (let i = 0; i < message.uninterpretedOption.length; i++) - UninterpretedOption.internalBinaryWrite(message.uninterpretedOption[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.FileOptions - */ -export const FileOptions = new FileOptions$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class MessageOptions$Type extends MessageType { - constructor() { - super("google.protobuf.MessageOptions", [ - { no: 1, name: "message_set_wire_format", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 2, name: "no_standard_descriptor_accessor", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 3, name: "deprecated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 7, name: "map_entry", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 11, name: "deprecated_legacy_json_field_conflicts", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 12, name: "features", kind: "message", T: () => FeatureSet }, - { no: 999, name: "uninterpreted_option", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.uninterpretedOption = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional bool message_set_wire_format */ 1: - message.messageSetWireFormat = reader.bool(); - break; - case /* optional bool no_standard_descriptor_accessor */ 2: - message.noStandardDescriptorAccessor = reader.bool(); - break; - case /* optional bool deprecated */ 3: - message.deprecated = reader.bool(); - break; - case /* optional bool map_entry */ 7: - message.mapEntry = reader.bool(); - break; - case /* optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true];*/ 11: - message.deprecatedLegacyJsonFieldConflicts = reader.bool(); - break; - case /* optional google.protobuf.FeatureSet features */ 12: - message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); - break; - case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: - message.uninterpretedOption.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional bool message_set_wire_format = 1; */ - if (message.messageSetWireFormat !== undefined) - writer.tag(1, WireType.Varint).bool(message.messageSetWireFormat); - /* optional bool no_standard_descriptor_accessor = 2; */ - if (message.noStandardDescriptorAccessor !== undefined) - writer.tag(2, WireType.Varint).bool(message.noStandardDescriptorAccessor); - /* optional bool deprecated = 3; */ - if (message.deprecated !== undefined) - writer.tag(3, WireType.Varint).bool(message.deprecated); - /* optional bool map_entry = 7; */ - if (message.mapEntry !== undefined) - writer.tag(7, WireType.Varint).bool(message.mapEntry); - /* optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true]; */ - if (message.deprecatedLegacyJsonFieldConflicts !== undefined) - writer.tag(11, WireType.Varint).bool(message.deprecatedLegacyJsonFieldConflicts); - /* optional google.protobuf.FeatureSet features = 12; */ - if (message.features) - FeatureSet.internalBinaryWrite(message.features, writer.tag(12, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ - for (let i = 0; i < message.uninterpretedOption.length; i++) - UninterpretedOption.internalBinaryWrite(message.uninterpretedOption[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.MessageOptions - */ -export const MessageOptions = new MessageOptions$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class FieldOptions$Type extends MessageType { - constructor() { - super("google.protobuf.FieldOptions", [ - { no: 1, name: "ctype", kind: "enum", opt: true, T: () => ["google.protobuf.FieldOptions.CType", FieldOptions_CType] }, - { no: 2, name: "packed", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 6, name: "jstype", kind: "enum", opt: true, T: () => ["google.protobuf.FieldOptions.JSType", FieldOptions_JSType] }, - { no: 5, name: "lazy", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 15, name: "unverified_lazy", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 3, name: "deprecated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 10, name: "weak", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 16, name: "debug_redact", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 17, name: "retention", kind: "enum", opt: true, T: () => ["google.protobuf.FieldOptions.OptionRetention", FieldOptions_OptionRetention] }, - { no: 19, name: "targets", kind: "enum", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ["google.protobuf.FieldOptions.OptionTargetType", FieldOptions_OptionTargetType] }, - { no: 20, name: "edition_defaults", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FieldOptions_EditionDefault }, - { no: 21, name: "features", kind: "message", T: () => FeatureSet }, - { no: 22, name: "feature_support", kind: "message", T: () => FieldOptions_FeatureSupport }, - { no: 999, name: "uninterpreted_option", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.targets = []; - message.editionDefaults = []; - message.uninterpretedOption = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional google.protobuf.FieldOptions.CType ctype */ 1: - message.ctype = reader.int32(); - break; - case /* optional bool packed */ 2: - message.packed = reader.bool(); - break; - case /* optional google.protobuf.FieldOptions.JSType jstype */ 6: - message.jstype = reader.int32(); - break; - case /* optional bool lazy */ 5: - message.lazy = reader.bool(); - break; - case /* optional bool unverified_lazy */ 15: - message.unverifiedLazy = reader.bool(); - break; - case /* optional bool deprecated */ 3: - message.deprecated = reader.bool(); - break; - case /* optional bool weak */ 10: - message.weak = reader.bool(); - break; - case /* optional bool debug_redact */ 16: - message.debugRedact = reader.bool(); - break; - case /* optional google.protobuf.FieldOptions.OptionRetention retention */ 17: - message.retention = reader.int32(); - break; - case /* repeated google.protobuf.FieldOptions.OptionTargetType targets */ 19: - if (wireType === WireType.LengthDelimited) - for (let e = reader.int32() + reader.pos; reader.pos < e;) - message.targets.push(reader.int32()); - else - message.targets.push(reader.int32()); - break; - case /* repeated google.protobuf.FieldOptions.EditionDefault edition_defaults */ 20: - message.editionDefaults.push(FieldOptions_EditionDefault.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* optional google.protobuf.FeatureSet features */ 21: - message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); - break; - case /* optional google.protobuf.FieldOptions.FeatureSupport feature_support */ 22: - message.featureSupport = FieldOptions_FeatureSupport.internalBinaryRead(reader, reader.uint32(), options, message.featureSupport); - break; - case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: - message.uninterpretedOption.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional google.protobuf.FieldOptions.CType ctype = 1; */ - if (message.ctype !== undefined) - writer.tag(1, WireType.Varint).int32(message.ctype); - /* optional bool packed = 2; */ - if (message.packed !== undefined) - writer.tag(2, WireType.Varint).bool(message.packed); - /* optional google.protobuf.FieldOptions.JSType jstype = 6; */ - if (message.jstype !== undefined) - writer.tag(6, WireType.Varint).int32(message.jstype); - /* optional bool lazy = 5; */ - if (message.lazy !== undefined) - writer.tag(5, WireType.Varint).bool(message.lazy); - /* optional bool unverified_lazy = 15; */ - if (message.unverifiedLazy !== undefined) - writer.tag(15, WireType.Varint).bool(message.unverifiedLazy); - /* optional bool deprecated = 3; */ - if (message.deprecated !== undefined) - writer.tag(3, WireType.Varint).bool(message.deprecated); - /* optional bool weak = 10; */ - if (message.weak !== undefined) - writer.tag(10, WireType.Varint).bool(message.weak); - /* optional bool debug_redact = 16; */ - if (message.debugRedact !== undefined) - writer.tag(16, WireType.Varint).bool(message.debugRedact); - /* optional google.protobuf.FieldOptions.OptionRetention retention = 17; */ - if (message.retention !== undefined) - writer.tag(17, WireType.Varint).int32(message.retention); - /* repeated google.protobuf.FieldOptions.OptionTargetType targets = 19; */ - for (let i = 0; i < message.targets.length; i++) - writer.tag(19, WireType.Varint).int32(message.targets[i]); - /* repeated google.protobuf.FieldOptions.EditionDefault edition_defaults = 20; */ - for (let i = 0; i < message.editionDefaults.length; i++) - FieldOptions_EditionDefault.internalBinaryWrite(message.editionDefaults[i], writer.tag(20, WireType.LengthDelimited).fork(), options).join(); - /* optional google.protobuf.FeatureSet features = 21; */ - if (message.features) - FeatureSet.internalBinaryWrite(message.features, writer.tag(21, WireType.LengthDelimited).fork(), options).join(); - /* optional google.protobuf.FieldOptions.FeatureSupport feature_support = 22; */ - if (message.featureSupport) - FieldOptions_FeatureSupport.internalBinaryWrite(message.featureSupport, writer.tag(22, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ - for (let i = 0; i < message.uninterpretedOption.length; i++) - UninterpretedOption.internalBinaryWrite(message.uninterpretedOption[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.FieldOptions - */ -export const FieldOptions = new FieldOptions$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class FieldOptions_EditionDefault$Type extends MessageType { - constructor() { - super("google.protobuf.FieldOptions.EditionDefault", [ - { no: 3, name: "edition", kind: "enum", opt: true, T: () => ["google.protobuf.Edition", Edition] }, - { no: 2, name: "value", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional google.protobuf.Edition edition */ 3: - message.edition = reader.int32(); - break; - case /* optional string value */ 2: - message.value = reader.string(); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional google.protobuf.Edition edition = 3; */ - if (message.edition !== undefined) - writer.tag(3, WireType.Varint).int32(message.edition); - /* optional string value = 2; */ - if (message.value !== undefined) - writer.tag(2, WireType.LengthDelimited).string(message.value); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.FieldOptions.EditionDefault - */ -export const FieldOptions_EditionDefault = new FieldOptions_EditionDefault$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class FieldOptions_FeatureSupport$Type extends MessageType { - constructor() { - super("google.protobuf.FieldOptions.FeatureSupport", [ - { no: 1, name: "edition_introduced", kind: "enum", opt: true, T: () => ["google.protobuf.Edition", Edition] }, - { no: 2, name: "edition_deprecated", kind: "enum", opt: true, T: () => ["google.protobuf.Edition", Edition] }, - { no: 3, name: "deprecation_warning", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 4, name: "edition_removed", kind: "enum", opt: true, T: () => ["google.protobuf.Edition", Edition] } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional google.protobuf.Edition edition_introduced */ 1: - message.editionIntroduced = reader.int32(); - break; - case /* optional google.protobuf.Edition edition_deprecated */ 2: - message.editionDeprecated = reader.int32(); - break; - case /* optional string deprecation_warning */ 3: - message.deprecationWarning = reader.string(); - break; - case /* optional google.protobuf.Edition edition_removed */ 4: - message.editionRemoved = reader.int32(); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional google.protobuf.Edition edition_introduced = 1; */ - if (message.editionIntroduced !== undefined) - writer.tag(1, WireType.Varint).int32(message.editionIntroduced); - /* optional google.protobuf.Edition edition_deprecated = 2; */ - if (message.editionDeprecated !== undefined) - writer.tag(2, WireType.Varint).int32(message.editionDeprecated); - /* optional string deprecation_warning = 3; */ - if (message.deprecationWarning !== undefined) - writer.tag(3, WireType.LengthDelimited).string(message.deprecationWarning); - /* optional google.protobuf.Edition edition_removed = 4; */ - if (message.editionRemoved !== undefined) - writer.tag(4, WireType.Varint).int32(message.editionRemoved); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.FieldOptions.FeatureSupport - */ -export const FieldOptions_FeatureSupport = new FieldOptions_FeatureSupport$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class OneofOptions$Type extends MessageType { - constructor() { - super("google.protobuf.OneofOptions", [ - { no: 1, name: "features", kind: "message", T: () => FeatureSet }, - { no: 999, name: "uninterpreted_option", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.uninterpretedOption = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional google.protobuf.FeatureSet features */ 1: - message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); - break; - case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: - message.uninterpretedOption.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional google.protobuf.FeatureSet features = 1; */ - if (message.features) - FeatureSet.internalBinaryWrite(message.features, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ - for (let i = 0; i < message.uninterpretedOption.length; i++) - UninterpretedOption.internalBinaryWrite(message.uninterpretedOption[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.OneofOptions - */ -export const OneofOptions = new OneofOptions$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class EnumOptions$Type extends MessageType { - constructor() { - super("google.protobuf.EnumOptions", [ - { no: 2, name: "allow_alias", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 3, name: "deprecated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 6, name: "deprecated_legacy_json_field_conflicts", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 7, name: "features", kind: "message", T: () => FeatureSet }, - { no: 999, name: "uninterpreted_option", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.uninterpretedOption = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional bool allow_alias */ 2: - message.allowAlias = reader.bool(); - break; - case /* optional bool deprecated */ 3: - message.deprecated = reader.bool(); - break; - case /* optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true];*/ 6: - message.deprecatedLegacyJsonFieldConflicts = reader.bool(); - break; - case /* optional google.protobuf.FeatureSet features */ 7: - message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); - break; - case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: - message.uninterpretedOption.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional bool allow_alias = 2; */ - if (message.allowAlias !== undefined) - writer.tag(2, WireType.Varint).bool(message.allowAlias); - /* optional bool deprecated = 3; */ - if (message.deprecated !== undefined) - writer.tag(3, WireType.Varint).bool(message.deprecated); - /* optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true]; */ - if (message.deprecatedLegacyJsonFieldConflicts !== undefined) - writer.tag(6, WireType.Varint).bool(message.deprecatedLegacyJsonFieldConflicts); - /* optional google.protobuf.FeatureSet features = 7; */ - if (message.features) - FeatureSet.internalBinaryWrite(message.features, writer.tag(7, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ - for (let i = 0; i < message.uninterpretedOption.length; i++) - UninterpretedOption.internalBinaryWrite(message.uninterpretedOption[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.EnumOptions - */ -export const EnumOptions = new EnumOptions$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class EnumValueOptions$Type extends MessageType { - constructor() { - super("google.protobuf.EnumValueOptions", [ - { no: 1, name: "deprecated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 2, name: "features", kind: "message", T: () => FeatureSet }, - { no: 3, name: "debug_redact", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 4, name: "feature_support", kind: "message", T: () => FieldOptions_FeatureSupport }, - { no: 999, name: "uninterpreted_option", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.uninterpretedOption = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional bool deprecated */ 1: - message.deprecated = reader.bool(); - break; - case /* optional google.protobuf.FeatureSet features */ 2: - message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); - break; - case /* optional bool debug_redact */ 3: - message.debugRedact = reader.bool(); - break; - case /* optional google.protobuf.FieldOptions.FeatureSupport feature_support */ 4: - message.featureSupport = FieldOptions_FeatureSupport.internalBinaryRead(reader, reader.uint32(), options, message.featureSupport); - break; - case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: - message.uninterpretedOption.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional bool deprecated = 1; */ - if (message.deprecated !== undefined) - writer.tag(1, WireType.Varint).bool(message.deprecated); - /* optional google.protobuf.FeatureSet features = 2; */ - if (message.features) - FeatureSet.internalBinaryWrite(message.features, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); - /* optional bool debug_redact = 3; */ - if (message.debugRedact !== undefined) - writer.tag(3, WireType.Varint).bool(message.debugRedact); - /* optional google.protobuf.FieldOptions.FeatureSupport feature_support = 4; */ - if (message.featureSupport) - FieldOptions_FeatureSupport.internalBinaryWrite(message.featureSupport, writer.tag(4, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ - for (let i = 0; i < message.uninterpretedOption.length; i++) - UninterpretedOption.internalBinaryWrite(message.uninterpretedOption[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.EnumValueOptions - */ -export const EnumValueOptions = new EnumValueOptions$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class ServiceOptions$Type extends MessageType { - constructor() { - super("google.protobuf.ServiceOptions", [ - { no: 34, name: "features", kind: "message", T: () => FeatureSet }, - { no: 33, name: "deprecated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 999, name: "uninterpreted_option", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.uninterpretedOption = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional google.protobuf.FeatureSet features */ 34: - message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); - break; - case /* optional bool deprecated */ 33: - message.deprecated = reader.bool(); - break; - case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: - message.uninterpretedOption.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional google.protobuf.FeatureSet features = 34; */ - if (message.features) - FeatureSet.internalBinaryWrite(message.features, writer.tag(34, WireType.LengthDelimited).fork(), options).join(); - /* optional bool deprecated = 33; */ - if (message.deprecated !== undefined) - writer.tag(33, WireType.Varint).bool(message.deprecated); - /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ - for (let i = 0; i < message.uninterpretedOption.length; i++) - UninterpretedOption.internalBinaryWrite(message.uninterpretedOption[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.ServiceOptions - */ -export const ServiceOptions = new ServiceOptions$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class MethodOptions$Type extends MessageType { - constructor() { - super("google.protobuf.MethodOptions", [ - { no: 33, name: "deprecated", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }, - { no: 34, name: "idempotency_level", kind: "enum", opt: true, T: () => ["google.protobuf.MethodOptions.IdempotencyLevel", MethodOptions_IdempotencyLevel] }, - { no: 35, name: "features", kind: "message", T: () => FeatureSet }, - { no: 999, name: "uninterpreted_option", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.uninterpretedOption = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional bool deprecated */ 33: - message.deprecated = reader.bool(); - break; - case /* optional google.protobuf.MethodOptions.IdempotencyLevel idempotency_level */ 34: - message.idempotencyLevel = reader.int32(); - break; - case /* optional google.protobuf.FeatureSet features */ 35: - message.features = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.features); - break; - case /* repeated google.protobuf.UninterpretedOption uninterpreted_option */ 999: - message.uninterpretedOption.push(UninterpretedOption.internalBinaryRead(reader, reader.uint32(), options)); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional bool deprecated = 33; */ - if (message.deprecated !== undefined) - writer.tag(33, WireType.Varint).bool(message.deprecated); - /* optional google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34; */ - if (message.idempotencyLevel !== undefined) - writer.tag(34, WireType.Varint).int32(message.idempotencyLevel); - /* optional google.protobuf.FeatureSet features = 35; */ - if (message.features) - FeatureSet.internalBinaryWrite(message.features, writer.tag(35, WireType.LengthDelimited).fork(), options).join(); - /* repeated google.protobuf.UninterpretedOption uninterpreted_option = 999; */ - for (let i = 0; i < message.uninterpretedOption.length; i++) - UninterpretedOption.internalBinaryWrite(message.uninterpretedOption[i], writer.tag(999, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.MethodOptions - */ -export const MethodOptions = new MethodOptions$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class UninterpretedOption$Type extends MessageType { - constructor() { - super("google.protobuf.UninterpretedOption", [ - { no: 2, name: "name", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => UninterpretedOption_NamePart }, - { no: 3, name: "identifier_value", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 4, name: "positive_int_value", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/ }, - { no: 5, name: "negative_int_value", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/ }, - { no: 6, name: "double_value", kind: "scalar", opt: true, T: 1 /*ScalarType.DOUBLE*/ }, - { no: 7, name: "string_value", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ }, - { no: 8, name: "aggregate_value", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.name = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* repeated google.protobuf.UninterpretedOption.NamePart name */ 2: - message.name.push(UninterpretedOption_NamePart.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* optional string identifier_value */ 3: - message.identifierValue = reader.string(); - break; - case /* optional uint64 positive_int_value */ 4: - message.positiveIntValue = reader.uint64().toString(); - break; - case /* optional int64 negative_int_value */ 5: - message.negativeIntValue = reader.int64().toString(); - break; - case /* optional double double_value */ 6: - message.doubleValue = reader.double(); - break; - case /* optional bytes string_value */ 7: - message.stringValue = reader.bytes(); - break; - case /* optional string aggregate_value */ 8: - message.aggregateValue = reader.string(); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* repeated google.protobuf.UninterpretedOption.NamePart name = 2; */ - for (let i = 0; i < message.name.length; i++) - UninterpretedOption_NamePart.internalBinaryWrite(message.name[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join(); - /* optional string identifier_value = 3; */ - if (message.identifierValue !== undefined) - writer.tag(3, WireType.LengthDelimited).string(message.identifierValue); - /* optional uint64 positive_int_value = 4; */ - if (message.positiveIntValue !== undefined) - writer.tag(4, WireType.Varint).uint64(message.positiveIntValue); - /* optional int64 negative_int_value = 5; */ - if (message.negativeIntValue !== undefined) - writer.tag(5, WireType.Varint).int64(message.negativeIntValue); - /* optional double double_value = 6; */ - if (message.doubleValue !== undefined) - writer.tag(6, WireType.Bit64).double(message.doubleValue); - /* optional bytes string_value = 7; */ - if (message.stringValue !== undefined) - writer.tag(7, WireType.LengthDelimited).bytes(message.stringValue); - /* optional string aggregate_value = 8; */ - if (message.aggregateValue !== undefined) - writer.tag(8, WireType.LengthDelimited).string(message.aggregateValue); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.UninterpretedOption - */ -export const UninterpretedOption = new UninterpretedOption$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class UninterpretedOption_NamePart$Type extends MessageType { - constructor() { - super("google.protobuf.UninterpretedOption.NamePart", [ - { no: 1, name: "name_part", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, - { no: 2, name: "is_extension", kind: "scalar", T: 8 /*ScalarType.BOOL*/ } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.namePart = ""; - message.isExtension = false; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* string name_part */ 1: - message.namePart = reader.string(); - break; - case /* bool is_extension */ 2: - message.isExtension = reader.bool(); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* string name_part = 1; */ - if (message.namePart !== "") - writer.tag(1, WireType.LengthDelimited).string(message.namePart); - /* bool is_extension = 2; */ - if (message.isExtension !== false) - writer.tag(2, WireType.Varint).bool(message.isExtension); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.UninterpretedOption.NamePart - */ -export const UninterpretedOption_NamePart = new UninterpretedOption_NamePart$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class FeatureSet$Type extends MessageType { - constructor() { - super("google.protobuf.FeatureSet", [ - { no: 1, name: "field_presence", kind: "enum", opt: true, T: () => ["google.protobuf.FeatureSet.FieldPresence", FeatureSet_FieldPresence] }, - { no: 2, name: "enum_type", kind: "enum", opt: true, T: () => ["google.protobuf.FeatureSet.EnumType", FeatureSet_EnumType] }, - { no: 3, name: "repeated_field_encoding", kind: "enum", opt: true, T: () => ["google.protobuf.FeatureSet.RepeatedFieldEncoding", FeatureSet_RepeatedFieldEncoding] }, - { no: 4, name: "utf8_validation", kind: "enum", opt: true, T: () => ["google.protobuf.FeatureSet.Utf8Validation", FeatureSet_Utf8Validation] }, - { no: 5, name: "message_encoding", kind: "enum", opt: true, T: () => ["google.protobuf.FeatureSet.MessageEncoding", FeatureSet_MessageEncoding] }, - { no: 6, name: "json_format", kind: "enum", opt: true, T: () => ["google.protobuf.FeatureSet.JsonFormat", FeatureSet_JsonFormat] } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional google.protobuf.FeatureSet.FieldPresence field_presence */ 1: - message.fieldPresence = reader.int32(); - break; - case /* optional google.protobuf.FeatureSet.EnumType enum_type */ 2: - message.enumType = reader.int32(); - break; - case /* optional google.protobuf.FeatureSet.RepeatedFieldEncoding repeated_field_encoding */ 3: - message.repeatedFieldEncoding = reader.int32(); - break; - case /* optional google.protobuf.FeatureSet.Utf8Validation utf8_validation */ 4: - message.utf8Validation = reader.int32(); - break; - case /* optional google.protobuf.FeatureSet.MessageEncoding message_encoding */ 5: - message.messageEncoding = reader.int32(); - break; - case /* optional google.protobuf.FeatureSet.JsonFormat json_format */ 6: - message.jsonFormat = reader.int32(); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional google.protobuf.FeatureSet.FieldPresence field_presence = 1; */ - if (message.fieldPresence !== undefined) - writer.tag(1, WireType.Varint).int32(message.fieldPresence); - /* optional google.protobuf.FeatureSet.EnumType enum_type = 2; */ - if (message.enumType !== undefined) - writer.tag(2, WireType.Varint).int32(message.enumType); - /* optional google.protobuf.FeatureSet.RepeatedFieldEncoding repeated_field_encoding = 3; */ - if (message.repeatedFieldEncoding !== undefined) - writer.tag(3, WireType.Varint).int32(message.repeatedFieldEncoding); - /* optional google.protobuf.FeatureSet.Utf8Validation utf8_validation = 4; */ - if (message.utf8Validation !== undefined) - writer.tag(4, WireType.Varint).int32(message.utf8Validation); - /* optional google.protobuf.FeatureSet.MessageEncoding message_encoding = 5; */ - if (message.messageEncoding !== undefined) - writer.tag(5, WireType.Varint).int32(message.messageEncoding); - /* optional google.protobuf.FeatureSet.JsonFormat json_format = 6; */ - if (message.jsonFormat !== undefined) - writer.tag(6, WireType.Varint).int32(message.jsonFormat); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.FeatureSet - */ -export const FeatureSet = new FeatureSet$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class FeatureSetDefaults$Type extends MessageType { - constructor() { - super("google.protobuf.FeatureSetDefaults", [ - { no: 1, name: "defaults", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FeatureSetDefaults_FeatureSetEditionDefault }, - { no: 4, name: "minimum_edition", kind: "enum", opt: true, T: () => ["google.protobuf.Edition", Edition] }, - { no: 5, name: "maximum_edition", kind: "enum", opt: true, T: () => ["google.protobuf.Edition", Edition] } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.defaults = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* repeated google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults */ 1: - message.defaults.push(FeatureSetDefaults_FeatureSetEditionDefault.internalBinaryRead(reader, reader.uint32(), options)); - break; - case /* optional google.protobuf.Edition minimum_edition */ 4: - message.minimumEdition = reader.int32(); - break; - case /* optional google.protobuf.Edition maximum_edition */ 5: - message.maximumEdition = reader.int32(); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* repeated google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults = 1; */ - for (let i = 0; i < message.defaults.length; i++) - FeatureSetDefaults_FeatureSetEditionDefault.internalBinaryWrite(message.defaults[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join(); - /* optional google.protobuf.Edition minimum_edition = 4; */ - if (message.minimumEdition !== undefined) - writer.tag(4, WireType.Varint).int32(message.minimumEdition); - /* optional google.protobuf.Edition maximum_edition = 5; */ - if (message.maximumEdition !== undefined) - writer.tag(5, WireType.Varint).int32(message.maximumEdition); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.FeatureSetDefaults - */ -export const FeatureSetDefaults = new FeatureSetDefaults$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class FeatureSetDefaults_FeatureSetEditionDefault$Type extends MessageType { - constructor() { - super("google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault", [ - { no: 3, name: "edition", kind: "enum", opt: true, T: () => ["google.protobuf.Edition", Edition] }, - { no: 4, name: "overridable_features", kind: "message", T: () => FeatureSet }, - { no: 5, name: "fixed_features", kind: "message", T: () => FeatureSet } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* optional google.protobuf.Edition edition */ 3: - message.edition = reader.int32(); - break; - case /* optional google.protobuf.FeatureSet overridable_features */ 4: - message.overridableFeatures = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.overridableFeatures); - break; - case /* optional google.protobuf.FeatureSet fixed_features */ 5: - message.fixedFeatures = FeatureSet.internalBinaryRead(reader, reader.uint32(), options, message.fixedFeatures); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* optional google.protobuf.Edition edition = 3; */ - if (message.edition !== undefined) - writer.tag(3, WireType.Varint).int32(message.edition); - /* optional google.protobuf.FeatureSet overridable_features = 4; */ - if (message.overridableFeatures) - FeatureSet.internalBinaryWrite(message.overridableFeatures, writer.tag(4, WireType.LengthDelimited).fork(), options).join(); - /* optional google.protobuf.FeatureSet fixed_features = 5; */ - if (message.fixedFeatures) - FeatureSet.internalBinaryWrite(message.fixedFeatures, writer.tag(5, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault - */ -export const FeatureSetDefaults_FeatureSetEditionDefault = new FeatureSetDefaults_FeatureSetEditionDefault$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class SourceCodeInfo$Type extends MessageType { - constructor() { - super("google.protobuf.SourceCodeInfo", [ - { no: 1, name: "location", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => SourceCodeInfo_Location } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.location = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* repeated google.protobuf.SourceCodeInfo.Location location */ 1: - message.location.push(SourceCodeInfo_Location.internalBinaryRead(reader, reader.uint32(), options)); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* repeated google.protobuf.SourceCodeInfo.Location location = 1; */ - for (let i = 0; i < message.location.length; i++) - SourceCodeInfo_Location.internalBinaryWrite(message.location[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.SourceCodeInfo - */ -export const SourceCodeInfo = new SourceCodeInfo$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class SourceCodeInfo_Location$Type extends MessageType { - constructor() { - super("google.protobuf.SourceCodeInfo.Location", [ - { no: 1, name: "path", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 5 /*ScalarType.INT32*/ }, - { no: 2, name: "span", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 5 /*ScalarType.INT32*/ }, - { no: 3, name: "leading_comments", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 4, name: "trailing_comments", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 6, name: "leading_detached_comments", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.path = []; - message.span = []; - message.leadingDetachedComments = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* repeated int32 path = 1 [packed = true];*/ 1: - if (wireType === WireType.LengthDelimited) - for (let e = reader.int32() + reader.pos; reader.pos < e;) - message.path.push(reader.int32()); - else - message.path.push(reader.int32()); - break; - case /* repeated int32 span = 2 [packed = true];*/ 2: - if (wireType === WireType.LengthDelimited) - for (let e = reader.int32() + reader.pos; reader.pos < e;) - message.span.push(reader.int32()); - else - message.span.push(reader.int32()); - break; - case /* optional string leading_comments */ 3: - message.leadingComments = reader.string(); - break; - case /* optional string trailing_comments */ 4: - message.trailingComments = reader.string(); - break; - case /* repeated string leading_detached_comments */ 6: - message.leadingDetachedComments.push(reader.string()); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* repeated int32 path = 1 [packed = true]; */ - if (message.path.length) { - writer.tag(1, WireType.LengthDelimited).fork(); - for (let i = 0; i < message.path.length; i++) - writer.int32(message.path[i]); - writer.join(); - } - /* repeated int32 span = 2 [packed = true]; */ - if (message.span.length) { - writer.tag(2, WireType.LengthDelimited).fork(); - for (let i = 0; i < message.span.length; i++) - writer.int32(message.span[i]); - writer.join(); - } - /* optional string leading_comments = 3; */ - if (message.leadingComments !== undefined) - writer.tag(3, WireType.LengthDelimited).string(message.leadingComments); - /* optional string trailing_comments = 4; */ - if (message.trailingComments !== undefined) - writer.tag(4, WireType.LengthDelimited).string(message.trailingComments); - /* repeated string leading_detached_comments = 6; */ - for (let i = 0; i < message.leadingDetachedComments.length; i++) - writer.tag(6, WireType.LengthDelimited).string(message.leadingDetachedComments[i]); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.SourceCodeInfo.Location - */ -export const SourceCodeInfo_Location = new SourceCodeInfo_Location$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class GeneratedCodeInfo$Type extends MessageType { - constructor() { - super("google.protobuf.GeneratedCodeInfo", [ - { no: 1, name: "annotation", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GeneratedCodeInfo_Annotation } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.annotation = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* repeated google.protobuf.GeneratedCodeInfo.Annotation annotation */ 1: - message.annotation.push(GeneratedCodeInfo_Annotation.internalBinaryRead(reader, reader.uint32(), options)); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* repeated google.protobuf.GeneratedCodeInfo.Annotation annotation = 1; */ - for (let i = 0; i < message.annotation.length; i++) - GeneratedCodeInfo_Annotation.internalBinaryWrite(message.annotation[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join(); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.GeneratedCodeInfo - */ -export const GeneratedCodeInfo = new GeneratedCodeInfo$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class GeneratedCodeInfo_Annotation$Type extends MessageType { - constructor() { - super("google.protobuf.GeneratedCodeInfo.Annotation", [ - { no: 1, name: "path", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 5 /*ScalarType.INT32*/ }, - { no: 2, name: "source_file", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }, - { no: 3, name: "begin", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ }, - { no: 4, name: "end", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ }, - { no: 5, name: "semantic", kind: "enum", opt: true, T: () => ["google.protobuf.GeneratedCodeInfo.Annotation.Semantic", GeneratedCodeInfo_Annotation_Semantic] } - ]); - } - create(value) { - const message = globalThis.Object.create((this.messagePrototype)); - message.path = []; - if (value !== undefined) - reflectionMergePartial(this, message, value); - return message; - } - internalBinaryRead(reader, length, options, target) { - let message = target ?? this.create(), end = reader.pos + length; - while (reader.pos < end) { - let [fieldNo, wireType] = reader.tag(); - switch (fieldNo) { - case /* repeated int32 path = 1 [packed = true];*/ 1: - if (wireType === WireType.LengthDelimited) - for (let e = reader.int32() + reader.pos; reader.pos < e;) - message.path.push(reader.int32()); - else - message.path.push(reader.int32()); - break; - case /* optional string source_file */ 2: - message.sourceFile = reader.string(); - break; - case /* optional int32 begin */ 3: - message.begin = reader.int32(); - break; - case /* optional int32 end */ 4: - message.end = reader.int32(); - break; - case /* optional google.protobuf.GeneratedCodeInfo.Annotation.Semantic semantic */ 5: - message.semantic = reader.int32(); - break; - default: - let u = options.readUnknownField; - if (u === "throw") - throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); - let d = reader.skip(wireType); - if (u !== false) - (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); - } - } - return message; - } - internalBinaryWrite(message, writer, options) { - /* repeated int32 path = 1 [packed = true]; */ - if (message.path.length) { - writer.tag(1, WireType.LengthDelimited).fork(); - for (let i = 0; i < message.path.length; i++) - writer.int32(message.path[i]); - writer.join(); - } - /* optional string source_file = 2; */ - if (message.sourceFile !== undefined) - writer.tag(2, WireType.LengthDelimited).string(message.sourceFile); - /* optional int32 begin = 3; */ - if (message.begin !== undefined) - writer.tag(3, WireType.Varint).int32(message.begin); - /* optional int32 end = 4; */ - if (message.end !== undefined) - writer.tag(4, WireType.Varint).int32(message.end); - /* optional google.protobuf.GeneratedCodeInfo.Annotation.Semantic semantic = 5; */ - if (message.semantic !== undefined) - writer.tag(5, WireType.Varint).int32(message.semantic); - let u = options.writeUnknownFields; - if (u !== false) - (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); - return writer; - } -} -/** - * @generated MessageType for protobuf message google.protobuf.GeneratedCodeInfo.Annotation - */ -export const GeneratedCodeInfo_Annotation = new GeneratedCodeInfo_Annotation$Type(); diff --git a/pkg/api/gen/proto/ts/runme/config/v1alpha1/config_pb.d.ts b/pkg/api/gen/proto/ts/runme/config/v1alpha1/config_pb.d.ts deleted file mode 100644 index 4ab848a49..000000000 --- a/pkg/api/gen/proto/ts/runme/config/v1alpha1/config_pb.d.ts +++ /dev/null @@ -1,303 +0,0 @@ -/* eslint-disable */ -// @generated by protobuf-ts 2.9.4 with parameter output_javascript,optimize_code_size,long_type_string,add_pb_suffix,ts_nocheck,eslint_disable -// @generated from protobuf file "runme/config/v1alpha1/config.proto" (package "runme.config.v1alpha1", syntax proto3) -// tslint:disable -// @ts-nocheck -import { MessageType } from "@protobuf-ts/runtime"; -import { BoolValue } from "../../../google/protobuf/wrappers_pb"; -/** - * Config describes the configuration of the runme tools, including CLI, server, and clients like VS Code extension. - * - * @generated from protobuf message runme.config.v1alpha1.Config - */ -export interface Config { - /** - * @generated from protobuf field: runme.config.v1alpha1.Config.Project project = 1; - */ - project?: Config_Project; - /** - * @generated from protobuf field: runme.config.v1alpha1.Config.Runtime runtime = 2; - */ - runtime?: Config_Runtime; - /** - * @generated from protobuf field: runme.config.v1alpha1.Config.Server server = 3; - */ - server?: Config_Server; - /** - * @generated from protobuf field: runme.config.v1alpha1.Config.Log log = 4; - */ - log?: Config_Log; -} -/** - * @generated from protobuf message runme.config.v1alpha1.Config.Project - */ -export interface Config_Project { - /** - * root is the root directory of the project. - * - * @generated from protobuf field: string root = 1; - */ - root: string; - /** - * filename is the filename to look for in the project. - * It effectively narrows down to search code blocks - * within a single file. - * - * If root is empty, it should be the absolute path. - * Otherwise, it should be a relative path to the root. - * - * @generated from protobuf field: string filename = 2; - */ - filename: string; - /** - * find_repo_upward indicates whether to find the nearest Git repository upward. - * This is useful to, for example, recognize .gitignore files. - * - * @generated from protobuf field: google.protobuf.BoolValue find_repo_upward = 3; - */ - findRepoUpward?: BoolValue; - /** - * ignore_paths is a list of paths to ignore relative to dir. - * - * @generated from protobuf field: repeated string ignore_paths = 4 [json_name = "ignore"]; - */ - ignorePaths: string[]; - /** - * disable_gitignore indicates whether to disable the .gitignore file. - * - * @generated from protobuf field: google.protobuf.BoolValue disable_gitignore = 5; - */ - disableGitignore?: BoolValue; - /** - * env is the environment variables configuration. - * - * @generated from protobuf field: runme.config.v1alpha1.Config.Env env = 6; - */ - env?: Config_Env; - /** - * filters is a list of filters to apply. - * They can be applied to documents or - * individual code blocks. - * - * @generated from protobuf field: repeated runme.config.v1alpha1.Config.Filter filters = 7; - */ - filters: Config_Filter[]; -} -/** - * @generated from protobuf message runme.config.v1alpha1.Config.Env - */ -export interface Config_Env { - /** - * use_system_env indicates whether to use the system environment variables. - * - * @generated from protobuf field: google.protobuf.BoolValue use_system_env = 1; - */ - useSystemEnv?: BoolValue; - /** - * sources is a list of files with env. - * - * @generated from protobuf field: repeated string sources = 2; - */ - sources: string[]; -} -/** - * @generated from protobuf message runme.config.v1alpha1.Config.Filter - */ -export interface Config_Filter { - /** - * type is the type of the filter. - * - * @generated from protobuf field: runme.config.v1alpha1.Config.FilterType type = 1; - */ - type: Config_FilterType; - /** - * condition is the filter program to execute for each document or block, - * depending on the filter type. - * - * The condition should be a valid Expr expression and it should return a boolean value. - * You can read more about the Expr syntax on https://expr-lang.org/. - * - * @generated from protobuf field: string condition = 2; - */ - condition: string; -} -/** - * @generated from protobuf message runme.config.v1alpha1.Config.Runtime - */ -export interface Config_Runtime { - /** - * @generated from protobuf field: optional runme.config.v1alpha1.Config.Docker docker = 1; - */ - docker?: Config_Docker; -} -/** - * @generated from protobuf message runme.config.v1alpha1.Config.Docker - */ -export interface Config_Docker { - /** - * @generated from protobuf field: google.protobuf.BoolValue enabled = 1; - */ - enabled?: BoolValue; - /** - * @generated from protobuf field: string image = 2; - */ - image: string; - /** - * @generated from protobuf field: runme.config.v1alpha1.Config.Docker.Build build = 3; - */ - build?: Config_Docker_Build; -} -/** - * @generated from protobuf message runme.config.v1alpha1.Config.Docker.Build - */ -export interface Config_Docker_Build { - /** - * @generated from protobuf field: string context = 1; - */ - context: string; - /** - * @generated from protobuf field: string dockerfile = 2; - */ - dockerfile: string; -} -/** - * @generated from protobuf message runme.config.v1alpha1.Config.Server - */ -export interface Config_Server { - /** - * @generated from protobuf field: string address = 1; - */ - address: string; - /** - * @generated from protobuf field: runme.config.v1alpha1.Config.Server.TLS tls = 2; - */ - tls?: Config_Server_TLS; -} -/** - * @generated from protobuf message runme.config.v1alpha1.Config.Server.TLS - */ -export interface Config_Server_TLS { - /** - * @generated from protobuf field: google.protobuf.BoolValue enabled = 1; - */ - enabled?: BoolValue; - /** - * @generated from protobuf field: string cert_file = 2; - */ - certFile: string; - /** - * @generated from protobuf field: string key_file = 3; - */ - keyFile: string; -} -/** - * @generated from protobuf message runme.config.v1alpha1.Config.Log - */ -export interface Config_Log { - /** - * enabled indicates whether to enable logging. - * - * @generated from protobuf field: google.protobuf.BoolValue enabled = 1; - */ - enabled?: BoolValue; - /** - * path is the path to the log output file. - * - * @generated from protobuf field: string path = 2; - */ - path: string; - /** - * verbose is the verbosity level of the log. - * - * @generated from protobuf field: google.protobuf.BoolValue verbose = 3; - */ - verbose?: BoolValue; -} -/** - * @generated from protobuf enum runme.config.v1alpha1.Config.FilterType - */ -export declare enum Config_FilterType { - /** - * @generated from protobuf enum value: FILTER_TYPE_UNSPECIFIED = 0; - */ - UNSPECIFIED = 0, - /** - * @generated from protobuf enum value: FILTER_TYPE_BLOCK = 1; - */ - BLOCK = 1, - /** - * @generated from protobuf enum value: FILTER_TYPE_DOCUMENT = 2; - */ - DOCUMENT = 2 -} -declare class Config$Type extends MessageType { - constructor(); -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config - */ -export declare const Config: Config$Type; -declare class Config_Project$Type extends MessageType { - constructor(); -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Project - */ -export declare const Config_Project: Config_Project$Type; -declare class Config_Env$Type extends MessageType { - constructor(); -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Env - */ -export declare const Config_Env: Config_Env$Type; -declare class Config_Filter$Type extends MessageType { - constructor(); -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Filter - */ -export declare const Config_Filter: Config_Filter$Type; -declare class Config_Runtime$Type extends MessageType { - constructor(); -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Runtime - */ -export declare const Config_Runtime: Config_Runtime$Type; -declare class Config_Docker$Type extends MessageType { - constructor(); -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Docker - */ -export declare const Config_Docker: Config_Docker$Type; -declare class Config_Docker_Build$Type extends MessageType { - constructor(); -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Docker.Build - */ -export declare const Config_Docker_Build: Config_Docker_Build$Type; -declare class Config_Server$Type extends MessageType { - constructor(); -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Server - */ -export declare const Config_Server: Config_Server$Type; -declare class Config_Server_TLS$Type extends MessageType { - constructor(); -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Server.TLS - */ -export declare const Config_Server_TLS: Config_Server_TLS$Type; -declare class Config_Log$Type extends MessageType { - constructor(); -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Log - */ -export declare const Config_Log: Config_Log$Type; -export {}; diff --git a/pkg/api/gen/proto/ts/runme/config/v1alpha1/config_pb.js b/pkg/api/gen/proto/ts/runme/config/v1alpha1/config_pb.js deleted file mode 100644 index fcf6cebbd..000000000 --- a/pkg/api/gen/proto/ts/runme/config/v1alpha1/config_pb.js +++ /dev/null @@ -1,169 +0,0 @@ -/* eslint-disable */ -// @generated by protobuf-ts 2.9.4 with parameter output_javascript,optimize_code_size,long_type_string,add_pb_suffix,ts_nocheck,eslint_disable -// @generated from protobuf file "runme/config/v1alpha1/config.proto" (package "runme.config.v1alpha1", syntax proto3) -// tslint:disable -// @ts-nocheck -/* eslint-disable */ -// @generated by protobuf-ts 2.9.4 with parameter output_javascript,optimize_code_size,long_type_string,add_pb_suffix,ts_nocheck,eslint_disable -// @generated from protobuf file "runme/config/v1alpha1/config.proto" (package "runme.config.v1alpha1", syntax proto3) -// tslint:disable -// @ts-nocheck -import { MessageType } from "@protobuf-ts/runtime"; -import { BoolValue } from "../../../google/protobuf/wrappers_pb"; -/** - * @generated from protobuf enum runme.config.v1alpha1.Config.FilterType - */ -export var Config_FilterType; -(function (Config_FilterType) { - /** - * @generated from protobuf enum value: FILTER_TYPE_UNSPECIFIED = 0; - */ - Config_FilterType[Config_FilterType["UNSPECIFIED"] = 0] = "UNSPECIFIED"; - /** - * @generated from protobuf enum value: FILTER_TYPE_BLOCK = 1; - */ - Config_FilterType[Config_FilterType["BLOCK"] = 1] = "BLOCK"; - /** - * @generated from protobuf enum value: FILTER_TYPE_DOCUMENT = 2; - */ - Config_FilterType[Config_FilterType["DOCUMENT"] = 2] = "DOCUMENT"; -})(Config_FilterType || (Config_FilterType = {})); -// @generated message type with reflection information, may provide speed optimized methods -class Config$Type extends MessageType { - constructor() { - super("runme.config.v1alpha1.Config", [ - { no: 1, name: "project", kind: "message", T: () => Config_Project }, - { no: 2, name: "runtime", kind: "message", T: () => Config_Runtime }, - { no: 3, name: "server", kind: "message", T: () => Config_Server }, - { no: 4, name: "log", kind: "message", T: () => Config_Log } - ]); - } -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config - */ -export const Config = new Config$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class Config_Project$Type extends MessageType { - constructor() { - super("runme.config.v1alpha1.Config.Project", [ - { no: 1, name: "root", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, - { no: 2, name: "filename", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, - { no: 3, name: "find_repo_upward", kind: "message", T: () => BoolValue }, - { no: 4, name: "ignore_paths", kind: "scalar", jsonName: "ignore", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }, - { no: 5, name: "disable_gitignore", kind: "message", T: () => BoolValue }, - { no: 6, name: "env", kind: "message", T: () => Config_Env }, - { no: 7, name: "filters", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Config_Filter } - ]); - } -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Project - */ -export const Config_Project = new Config_Project$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class Config_Env$Type extends MessageType { - constructor() { - super("runme.config.v1alpha1.Config.Env", [ - { no: 1, name: "use_system_env", kind: "message", T: () => BoolValue }, - { no: 2, name: "sources", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ } - ]); - } -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Env - */ -export const Config_Env = new Config_Env$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class Config_Filter$Type extends MessageType { - constructor() { - super("runme.config.v1alpha1.Config.Filter", [ - { no: 1, name: "type", kind: "enum", T: () => ["runme.config.v1alpha1.Config.FilterType", Config_FilterType, "FILTER_TYPE_"], options: { "buf.validate.field": { enum: { definedOnly: true } } } }, - { no: 2, name: "condition", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "buf.validate.field": { string: { minLen: "1", maxLen: "1024" } } } } - ]); - } -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Filter - */ -export const Config_Filter = new Config_Filter$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class Config_Runtime$Type extends MessageType { - constructor() { - super("runme.config.v1alpha1.Config.Runtime", [ - { no: 1, name: "docker", kind: "message", T: () => Config_Docker } - ]); - } -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Runtime - */ -export const Config_Runtime = new Config_Runtime$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class Config_Docker$Type extends MessageType { - constructor() { - super("runme.config.v1alpha1.Config.Docker", [ - { no: 1, name: "enabled", kind: "message", T: () => BoolValue }, - { no: 2, name: "image", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, - { no: 3, name: "build", kind: "message", T: () => Config_Docker_Build } - ]); - } -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Docker - */ -export const Config_Docker = new Config_Docker$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class Config_Docker_Build$Type extends MessageType { - constructor() { - super("runme.config.v1alpha1.Config.Docker.Build", [ - { no: 1, name: "context", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, - { no: 2, name: "dockerfile", kind: "scalar", T: 9 /*ScalarType.STRING*/ } - ]); - } -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Docker.Build - */ -export const Config_Docker_Build = new Config_Docker_Build$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class Config_Server$Type extends MessageType { - constructor() { - super("runme.config.v1alpha1.Config.Server", [ - { no: 1, name: "address", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, - { no: 2, name: "tls", kind: "message", T: () => Config_Server_TLS } - ]); - } -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Server - */ -export const Config_Server = new Config_Server$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class Config_Server_TLS$Type extends MessageType { - constructor() { - super("runme.config.v1alpha1.Config.Server.TLS", [ - { no: 1, name: "enabled", kind: "message", T: () => BoolValue }, - { no: 2, name: "cert_file", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, - { no: 3, name: "key_file", kind: "scalar", T: 9 /*ScalarType.STRING*/ } - ]); - } -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Server.TLS - */ -export const Config_Server_TLS = new Config_Server_TLS$Type(); -// @generated message type with reflection information, may provide speed optimized methods -class Config_Log$Type extends MessageType { - constructor() { - super("runme.config.v1alpha1.Config.Log", [ - { no: 1, name: "enabled", kind: "message", T: () => BoolValue }, - { no: 2, name: "path", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, - { no: 3, name: "verbose", kind: "message", T: () => BoolValue } - ]); - } -} -/** - * @generated MessageType for protobuf message runme.config.v1alpha1.Config.Log - */ -export const Config_Log = new Config_Log$Type(); diff --git a/pkg/api/gen/proto/ts/runme/parser/v1/parser_pb.d.ts b/pkg/api/gen/proto/ts/runme/parser/v1/parser_pb.d.ts index 379a30293..bf719b2a6 100644 --- a/pkg/api/gen/proto/ts/runme/parser/v1/parser_pb.d.ts +++ b/pkg/api/gen/proto/ts/runme/parser/v1/parser_pb.d.ts @@ -226,6 +226,8 @@ export interface Frontmatter { */ runme?: FrontmatterRunme; /** + * Deprecated category in favor of Tag + * * @generated from protobuf field: string category = 5; */ category: string; diff --git a/pkg/api/proto/runme/config/v1alpha1/config.proto b/pkg/api/proto/runme/config/v1alpha1/config.proto deleted file mode 100644 index 6316577c3..000000000 --- a/pkg/api/proto/runme/config/v1alpha1/config.proto +++ /dev/null @@ -1,119 +0,0 @@ -syntax = "proto3"; - -package runme.config.v1alpha1; - -import "buf/validate/validate.proto"; -import "google/protobuf/wrappers.proto"; - -option go_package = "github.com/stateful/runme/pkg/api/gen/proto/go/runme/config/v1alpha1;configv1alpha1"; - -// Config describes the configuration of the runme tools, including CLI, server, and clients like VS Code extension. -message Config { - Project project = 1; - - Runtime runtime = 2; - - Server server = 3; - - Log log = 4; - - message Project { - // root is the root directory of the project. - string root = 1; - - // filename is the filename to look for in the project. - // It effectively narrows down to search code blocks - // within a single file. - // - // If root is empty, it should be the absolute path. - // Otherwise, it should be a relative path to the root. - string filename = 2; - - // find_repo_upward indicates whether to find the nearest Git repository upward. - // This is useful to, for example, recognize .gitignore files. - google.protobuf.BoolValue find_repo_upward = 3; - - // ignore_paths is a list of paths to ignore relative to dir. - repeated string ignore_paths = 4 [json_name = "ignore"]; - - // disable_gitignore indicates whether to disable the .gitignore file. - google.protobuf.BoolValue disable_gitignore = 5; - - // env is the environment variables configuration. - Env env = 6; - - // filters is a list of filters to apply. - // They can be applied to documents or - // individual code blocks. - repeated Filter filters = 7; - } - - message Env { - // use_system_env indicates whether to use the system environment variables. - google.protobuf.BoolValue use_system_env = 1; - - // sources is a list of files with env. - repeated string sources = 2; - } - - message Filter { - // type is the type of the filter. - FilterType type = 1 [(buf.validate.field).enum.defined_only = true]; - - // condition is the filter program to execute for each document or block, - // depending on the filter type. - // - // The condition should be a valid Expr expression and it should return a boolean value. - // You can read more about the Expr syntax on https://expr-lang.org/. - string condition = 2 [ - (buf.validate.field).string.min_len = 1, - (buf.validate.field).string.max_len = 1024 - ]; - } - - enum FilterType { - FILTER_TYPE_UNSPECIFIED = 0; - FILTER_TYPE_BLOCK = 1; - FILTER_TYPE_DOCUMENT = 2; - } - - message Runtime { - optional Docker docker = 1; - } - - message Docker { - google.protobuf.BoolValue enabled = 1; - - string image = 2; - - Build build = 3; - - message Build { - string context = 1; - string dockerfile = 2; - } - } - - message Server { - string address = 1; - - TLS tls = 2; - - message TLS { - google.protobuf.BoolValue enabled = 1; - string cert_file = 2; - string key_file = 3; - } - } - - message Log { - // enabled indicates whether to enable logging. - google.protobuf.BoolValue enabled = 1; - - // path is the path to the log output file. - string path = 2; - - // verbose is the verbosity level of the log. - google.protobuf.BoolValue verbose = 3; - } -}