diff --git a/Makefile b/Makefile index 83def328..55f1b3c9 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,5 @@ NAME="github.com/raystack/stencil" VERSION=$(shell git describe --always --tags 2>/dev/null) -PROTON_COMMIT := "a6c7056fa80128145d00d5ee72f216c28578ec43" .PHONY: all build test clean dist vet proto install ui @@ -18,13 +17,12 @@ coverage: ui ## Print code coverage vet: ## Run the go vet tool go vet ./... -lint: ## Run golang-ci lint +lint: ## Run golang-ci lint golangci-lint run proto: ## Generate the protobuf files @echo " > generating protobuf from raystack/proton" - @echo " > [info] make sure correct version of dependencies are installed using 'make install'" - @buf generate https://github.com/raystack/proton/archive/${PROTON_COMMIT}.zip#strip_components=1 --template buf.gen.yaml --path raystack/stencil + @buf generate @echo " > protobuf compilation finished" clean: ## Clean the build artifacts @@ -35,4 +33,4 @@ ui: @cd ui && $(MAKE) dep && $(MAKE) dist help: ## Display this help message - @cat $(MAKEFILE_LIST) | grep -e "^[a-zA-Z_\-]*: *.*## *" | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' \ No newline at end of file + @cat $(MAKEFILE_LIST) | grep -e "^[a-zA-Z_\-]*: *.*## *" | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' diff --git a/buf.gen.yaml b/buf.gen.yaml index 98ec91f0..9094076d 100644 --- a/buf.gen.yaml +++ b/buf.gen.yaml @@ -1,17 +1,21 @@ -version: v1 +version: v2 +inputs: + - git_repo: https://github.com/raystack/proton.git + ref: 8ef3e30859491f877a791fe0f9039370235c99b2 + paths: + - raystack/stencil +managed: + enabled: true + override: + - file_option: go_package + path: raystack/stencil/v1beta1/stencil.proto + value: github.com/raystack/stencil/gen/raystack/stencil/v1beta1;stencilv1beta1 plugins: - - name: go - out: ./proto - opt: paths=source_relative - - name: go-grpc - out: ./proto - opt: paths=source_relative - - remote: buf.build/raystack/plugins/validate - out: "proto" - opt: "paths=source_relative,lang=go" - - name: grpc-gateway - out: ./proto - opt: paths=source_relative - - name: openapiv2 - out: ./proto - opt: "allow_merge=true" + - remote: buf.build/protocolbuffers/go:v1.36.11 + out: gen + opt: + - paths=source_relative + - remote: buf.build/connectrpc/go:v1.18.1 + out: gen + opt: + - paths=source_relative diff --git a/cmd/check.go b/cmd/check.go index ea196b0c..5a9f1467 100644 --- a/cmd/check.go +++ b/cmd/check.go @@ -2,20 +2,18 @@ package cmd import ( "context" - "errors" "fmt" "os" + "connectrpc.com/connect" "github.com/MakeNowJust/heredoc" "github.com/raystack/salt/cli/printer" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + stencilv1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" "github.com/spf13/cobra" - "google.golang.org/grpc/status" ) func checkSchemaCmd(cdk *CDK) *cobra.Command { var comp, file, namespaceID string - var req stencilv1beta1.CheckCompatibilityRequest cmd := &cobra.Command{ Use: "check ", @@ -36,23 +34,23 @@ func checkSchemaCmd(cdk *CDK) *cobra.Command { return err } - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() schemaID := args[0] - req.Data = fileData - req.NamespaceId = namespaceID - req.SchemaId = schemaID - req.Compatibility = stencilv1beta1.Schema_Compatibility(stencilv1beta1.Schema_Compatibility_value[comp]) + req := &stencilv1beta1.CheckCompatibilityRequest{ + Data: fileData, + NamespaceId: namespaceID, + SchemaId: schemaID, + Compatibility: stencilv1beta1.Schema_Compatibility(stencilv1beta1.Schema_Compatibility_value[comp]), + } - _, err = client.CheckCompatibility(context.Background(), &req) + _, err = client.CheckCompatibility(context.Background(), connect.NewRequest(req)) if err != nil { - errStatus := status.Convert(err) - return errors.New(errStatus.Message()) + return err } spinner.Stop() diff --git a/cmd/client.go b/cmd/client.go index 40ef4096..b51ea730 100644 --- a/cmd/client.go +++ b/cmd/client.go @@ -1,55 +1,34 @@ package cmd import ( - "context" - "time" + "net/http" "github.com/raystack/salt/config" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + stencilv1beta1connect "github.com/raystack/stencil/gen/raystack/stencil/v1beta1/stencilv1beta1connect" "github.com/spf13/cobra" - "google.golang.org/grpc" - "google.golang.org/grpc/credentials/insecure" ) type ClientConfig struct { Host string `yaml:"host" cmdx:"host"` } -func createConnection(ctx context.Context, host string) (*grpc.ClientConn, error) { - opts := []grpc.DialOption{ - grpc.WithTransportCredentials(insecure.NewCredentials()), - grpc.WithBlock(), - } - - return grpc.DialContext(ctx, host, opts...) -} - -func createClient(cmd *cobra.Command, cdk *CDK) (stencilv1beta1.StencilServiceClient, func(), error) { +func createClient(cmd *cobra.Command, cdk *CDK) (stencilv1beta1connect.StencilServiceClient, error) { c, err := loadClientConfig(cmd, cdk.Config) if err != nil { - return nil, nil, err + return nil, err } host := c.Host if host == "" { - return nil, nil, ErrClientConfigHostNotFound - } - - dialTimeoutCtx, dialCancel := context.WithTimeout(cmd.Context(), time.Second*2) - conn, err := createConnection(dialTimeoutCtx, host) - if err != nil { - dialCancel() - return nil, nil, err - } - - cancel := func() { - dialCancel() - conn.Close() + return nil, ErrClientConfigHostNotFound } - client := stencilv1beta1.NewStencilServiceClient(conn) - return client, cancel, nil + client := stencilv1beta1connect.NewStencilServiceClient( + http.DefaultClient, + host, + ) + return client, nil } func loadClientConfig(cmd *cobra.Command, cmdxConfig *config.Loader) (*ClientConfig, error) { diff --git a/cmd/create.go b/cmd/create.go index b2abf646..0c19d0bb 100644 --- a/cmd/create.go +++ b/cmd/create.go @@ -2,62 +2,60 @@ package cmd import ( "context" - "errors" "fmt" "os" + "connectrpc.com/connect" "github.com/MakeNowJust/heredoc" "github.com/raystack/salt/cli/printer" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + stencilv1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" "github.com/spf13/cobra" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" ) func createSchemaCmd(cdk *CDK) *cobra.Command { var format, comp, file, namespaceID string - var req stencilv1beta1.CreateSchemaRequest cmd := &cobra.Command{ Use: "create", Short: "Create a schema", Args: cobra.ExactArgs(1), Example: heredoc.Doc(` - $ stencil schema create booking -n raystack –F booking.json - $ stencil schema create booking -n raystack -f FORMAT_JSON –c COMPATIBILITY_BACKWARD –F ./booking.json + $ stencil schema create booking -n raystack -F booking.json + $ stencil schema create booking -n raystack -f FORMAT_JSON -c COMPATIBILITY_BACKWARD -F ./booking.json `), RunE: func(cmd *cobra.Command, args []string) error { fileData, err := os.ReadFile(file) if err != nil { return err } - req.Data = fileData spinner := printer.Spin("") defer spinner.Stop() - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() schemaID := args[0] - req.NamespaceId = namespaceID - req.SchemaId = schemaID - req.Format = stencilv1beta1.Schema_Format(stencilv1beta1.Schema_Format_value[format]) - req.Compatibility = stencilv1beta1.Schema_Compatibility(stencilv1beta1.Schema_Compatibility_value[comp]) + req := &stencilv1beta1.CreateSchemaRequest{ + NamespaceId: namespaceID, + SchemaId: schemaID, + Data: fileData, + Format: stencilv1beta1.Schema_Format(stencilv1beta1.Schema_Format_value[format]), + Compatibility: stencilv1beta1.Schema_Compatibility(stencilv1beta1.Schema_Compatibility_value[comp]), + } - res, err := client.CreateSchema(context.Background(), &req) + res, err := client.CreateSchema(context.Background(), connect.NewRequest(req)) if err != nil { - errStatus := status.Convert(err) - if codes.AlreadyExists == errStatus.Code() { + connectErr, ok := err.(*connect.Error) + if ok && connectErr.Code() == connect.CodeAlreadyExists { fmt.Printf("\n%s Schema with id '%s' already exist.\n", printer.Icon("failure"), args[0]) return nil } - return errors.New(errStatus.Message()) + return err } - id := res.GetId() + id := res.Msg.GetId() spinner.Stop() fmt.Printf("\n%s Created schema with id %s.\n", printer.Green(printer.Icon("success")), printer.Cyan(id)) diff --git a/cmd/delete.go b/cmd/delete.go index 6a4c3f3f..84dc007c 100644 --- a/cmd/delete.go +++ b/cmd/delete.go @@ -4,16 +4,15 @@ import ( "context" "fmt" + "connectrpc.com/connect" "github.com/MakeNowJust/heredoc" "github.com/raystack/salt/cli/printer" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + stencilv1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" "github.com/spf13/cobra" ) func deleteSchemaCmd(cdk *CDK) *cobra.Command { var namespaceID string - var req stencilv1beta1.DeleteSchemaRequest - var reqVer stencilv1beta1.DeleteVersionRequest var version int32 cmd := &cobra.Command{ @@ -27,28 +26,27 @@ func deleteSchemaCmd(cdk *CDK) *cobra.Command { spinner := printer.Spin("") defer spinner.Stop() - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() schemaID := args[0] if version == 0 { - req.NamespaceId = namespaceID - req.SchemaId = schemaID - - _, err = client.DeleteSchema(context.Background(), &req) + _, err = client.DeleteSchema(context.Background(), connect.NewRequest(&stencilv1beta1.DeleteSchemaRequest{ + NamespaceId: namespaceID, + SchemaId: schemaID, + })) if err != nil { return err } } else { - reqVer.NamespaceId = namespaceID - reqVer.SchemaId = schemaID - reqVer.VersionId = version - - _, err = client.DeleteVersion(context.Background(), &reqVer) + _, err = client.DeleteVersion(context.Background(), connect.NewRequest(&stencilv1beta1.DeleteVersionRequest{ + NamespaceId: namespaceID, + SchemaId: schemaID, + VersionId: version, + })) if err != nil { return err } diff --git a/cmd/diff.go b/cmd/diff.go index bdd11d2e..b82e4417 100644 --- a/cmd/diff.go +++ b/cmd/diff.go @@ -5,9 +5,11 @@ import ( "encoding/json" "fmt" + "connectrpc.com/connect" "github.com/MakeNowJust/heredoc" "github.com/raystack/salt/cli/printer" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + stencilv1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" + stencilv1beta1connect "github.com/raystack/stencil/gen/raystack/stencil/v1beta1/stencilv1beta1connect" "github.com/spf13/cobra" "github.com/yudai/gojsondiff" "github.com/yudai/gojsondiff/formatter" @@ -24,23 +26,23 @@ func diffSchemaCmd(cdk *CDK) *cobra.Command { var earlierVersion int32 var laterVersion int32 - var schemaFetcher = func(req *stencilv1beta1.GetSchemaRequest, client stencilv1beta1.StencilServiceClient) ([]byte, error) { - res, err := client.GetSchema(context.Background(), req) + var schemaFetcher = func(req *stencilv1beta1.GetSchemaRequest, client stencilv1beta1connect.StencilServiceClient) ([]byte, error) { + res, err := client.GetSchema(context.Background(), connect.NewRequest(req)) if err != nil { return nil, err } - return res.Data, nil + return res.Msg.GetData(), nil } - var protoSchemaFetcher = func(req *stencilv1beta1.GetSchemaRequest, client stencilv1beta1.StencilServiceClient) ([]byte, error) { + var protoSchemaFetcher = func(req *stencilv1beta1.GetSchemaRequest, client stencilv1beta1connect.StencilServiceClient) ([]byte, error) { if fullname == "" { return nil, fmt.Errorf("fullname flag is mandator for FORMAT_PROTO") } - res, err := client.GetSchema(context.Background(), req) + res, err := client.GetSchema(context.Background(), connect.NewRequest(req)) if err != nil { return nil, err } fds := &descriptorpb.FileDescriptorSet{} - if err := proto.Unmarshal(res.Data, fds); err != nil { + if err := proto.Unmarshal(res.Msg.GetData(), fds); err != nil { return nil, fmt.Errorf("descriptor set file is not valid. %w", err) } files, err := protodesc.NewFiles(fds) @@ -75,10 +77,6 @@ func diffSchemaCmd(cdk *CDK) *cobra.Command { schemaID := args[0] - metaReq := stencilv1beta1.GetSchemaMetadataRequest{ - NamespaceId: namespace, - SchemaId: schemaID, - } eReq := &stencilv1beta1.GetSchemaRequest{ NamespaceId: namespace, SchemaId: schemaID, @@ -90,17 +88,20 @@ func diffSchemaCmd(cdk *CDK) *cobra.Command { VersionId: laterVersion, } - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() - meta, err := client.GetSchemaMetadata(context.Background(), &metaReq) + metaRes, err := client.GetSchemaMetadata(context.Background(), connect.NewRequest(&stencilv1beta1.GetSchemaMetadataRequest{ + NamespaceId: namespace, + SchemaId: schemaID, + })) if err != nil { return err } + meta := metaRes.Msg var getSchema = schemaFetcher if meta.Format == *stencilv1beta1.Schema_FORMAT_PROTOBUF.Enum() { getSchema = protoSchemaFetcher diff --git a/cmd/download.go b/cmd/download.go index b442e13d..a45b55ce 100644 --- a/cmd/download.go +++ b/cmd/download.go @@ -24,11 +24,10 @@ func downloadSchemaCmd(cdk *CDK) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { spinner := printer.Spin("") defer spinner.Stop() - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() data, _, err = fetchSchemaAndMeta(client, version, namespaceID, args[0]) if err != nil { diff --git a/cmd/edit.go b/cmd/edit.go index e31081d2..69ac7fde 100644 --- a/cmd/edit.go +++ b/cmd/edit.go @@ -4,15 +4,15 @@ import ( "context" "fmt" + "connectrpc.com/connect" "github.com/MakeNowJust/heredoc" "github.com/raystack/salt/cli/printer" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + stencilv1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" "github.com/spf13/cobra" ) func editSchemaCmd(cdk *CDK) *cobra.Command { var comp, namespaceID string - var req stencilv1beta1.UpdateSchemaMetadataRequest cmd := &cobra.Command{ Use: "edit", @@ -25,19 +25,20 @@ func editSchemaCmd(cdk *CDK) *cobra.Command { spinner := printer.Spin("") defer spinner.Stop() - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() schemaID := args[0] - req.NamespaceId = namespaceID - req.SchemaId = schemaID - req.Compatibility = stencilv1beta1.Schema_Compatibility(stencilv1beta1.Schema_Compatibility_value[comp]) + req := &stencilv1beta1.UpdateSchemaMetadataRequest{ + NamespaceId: namespaceID, + SchemaId: schemaID, + Compatibility: stencilv1beta1.Schema_Compatibility(stencilv1beta1.Schema_Compatibility_value[comp]), + } - _, err = client.UpdateSchemaMetadata(context.Background(), &req) + _, err = client.UpdateSchemaMetadata(context.Background(), connect.NewRequest(req)) if err != nil { return err } diff --git a/cmd/graph.go b/cmd/graph.go index 0755b2a7..f8c73bbe 100644 --- a/cmd/graph.go +++ b/cmd/graph.go @@ -6,7 +6,7 @@ import ( "github.com/MakeNowJust/heredoc" "github.com/raystack/stencil/pkg/graph" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + stencilv1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" "github.com/spf13/cobra" "google.golang.org/protobuf/proto" "google.golang.org/protobuf/types/descriptorpb" @@ -25,11 +25,10 @@ func graphSchemaCmd(cdk *CDK) *cobra.Command { $ stencil schema graph booking -n raystack -v 1 -o ./vis.dot `), RunE: func(cmd *cobra.Command, args []string) error { - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() schemaID := args[0] diff --git a/cmd/info.go b/cmd/info.go index 3bb4ccd3..8ef9bfc2 100644 --- a/cmd/info.go +++ b/cmd/info.go @@ -6,12 +6,11 @@ import ( "os" "strconv" + "connectrpc.com/connect" "github.com/MakeNowJust/heredoc" "github.com/raystack/salt/cli/printer" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + stencilv1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" "github.com/spf13/cobra" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" ) func infoSchemaCmd(cdk *CDK) *cobra.Command { @@ -28,27 +27,27 @@ func infoSchemaCmd(cdk *CDK) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { spinner := printer.Spin("") defer spinner.Stop() - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() - req := stencilv1beta1.GetSchemaMetadataRequest{ + req := &stencilv1beta1.GetSchemaMetadataRequest{ NamespaceId: namespace, SchemaId: args[0], } - info, err := client.GetSchemaMetadata(cmd.Context(), &req) + res, err := client.GetSchemaMetadata(cmd.Context(), connect.NewRequest(req)) spinner.Stop() if err != nil { - errStatus, _ := status.FromError(err) - if codes.NotFound == errStatus.Code() { + connectErr, ok := err.(*connect.Error) + if ok && connectErr.Code() == connect.CodeNotFound { fmt.Printf("%s Schema with id '%s' not found.\n", printer.Red(printer.Icon("failure")), args[0]) return nil } return err } + info := res.Msg fmt.Printf("\n%s\n", printer.Blue(args[0])) fmt.Printf("\n%s\n\n", printer.Grey("No description provided")) fmt.Printf("%s \t %s \n", printer.Grey("Namespace:"), namespace) @@ -67,7 +66,6 @@ func infoSchemaCmd(cdk *CDK) *cobra.Command { func versionSchemaCmd(cdk *CDK) *cobra.Command { var namespaceID string - var req stencilv1beta1.ListVersionsRequest cmd := &cobra.Command{ Use: "version", @@ -80,22 +78,21 @@ func versionSchemaCmd(cdk *CDK) *cobra.Command { spinner := printer.Spin("") defer spinner.Stop() - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() schemaID := args[0] - req.NamespaceId = namespaceID - req.SchemaId = schemaID - - res, err := client.ListVersions(context.Background(), &req) + res, err := client.ListVersions(context.Background(), connect.NewRequest(&stencilv1beta1.ListVersionsRequest{ + NamespaceId: namespaceID, + SchemaId: schemaID, + })) if err != nil { return err } - versions := res.GetVersions() + versions := res.Msg.GetVersions() spinner.Stop() if len(versions) == 0 { diff --git a/cmd/list.go b/cmd/list.go index ac65afc4..845c493f 100644 --- a/cmd/list.go +++ b/cmd/list.go @@ -5,15 +5,15 @@ import ( "fmt" "os" + "connectrpc.com/connect" "github.com/MakeNowJust/heredoc" "github.com/raystack/salt/cli/printer" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + stencilv1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" "github.com/spf13/cobra" ) func listSchemaCmd(cdk *CDK) *cobra.Command { var namespace string - var req stencilv1beta1.ListSchemasRequest cmd := &cobra.Command{ Use: "list", @@ -29,18 +29,16 @@ func listSchemaCmd(cdk *CDK) *cobra.Command { spinner := printer.Spin("") defer spinner.Stop() - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() - req.Id = namespace - res, err := client.ListSchemas(context.Background(), &req) + res, err := client.ListSchemas(context.Background(), connect.NewRequest(&stencilv1beta1.ListSchemasRequest{Id: namespace})) if err != nil { return err } - schemas := res.GetSchemas() + schemas := res.Msg.GetSchemas() // TODO(Ravi): List schemas should also handle namespace not found if len(schemas) == 0 { diff --git a/cmd/namespace.go b/cmd/namespace.go index 621128bb..edda0eda 100644 --- a/cmd/namespace.go +++ b/cmd/namespace.go @@ -5,14 +5,13 @@ import ( "fmt" "os" + "connectrpc.com/connect" "github.com/MakeNowJust/heredoc" "github.com/dustin/go-humanize" "github.com/raystack/salt/cli/printer" "github.com/raystack/salt/cli/prompter" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + stencilv1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" "github.com/spf13/cobra" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" ) func NamespaceCmd(cdk *CDK) *cobra.Command { @@ -42,8 +41,6 @@ func NamespaceCmd(cdk *CDK) *cobra.Command { } func listNamespaceCmd(cdk *CDK) *cobra.Command { - var req stencilv1beta1.ListNamespacesRequest - cmd := &cobra.Command{ Use: "list", Short: "List all namespaces", @@ -52,18 +49,17 @@ func listNamespaceCmd(cdk *CDK) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { spinner := printer.Spin("") defer spinner.Stop() - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() - res, err := client.ListNamespaces(context.Background(), &req) + res, err := client.ListNamespaces(context.Background(), connect.NewRequest(&stencilv1beta1.ListNamespacesRequest{})) if err != nil { return err } - namespaces := res.GetNamespaces() + namespaces := res.Msg.GetNamespaces() spinner.Stop() if len(namespaces) == 0 { @@ -99,14 +95,13 @@ func listNamespaceCmd(cdk *CDK) *cobra.Command { func createNamespaceCmd(cdk *CDK) *cobra.Command { var id, desc, format, comp string - var req stencilv1beta1.CreateNamespaceRequest cmd := &cobra.Command{ Use: "create", Short: "Create a namespace", Args: cobra.ExactArgs(0), Example: heredoc.Doc(` - $ stencil namespace create + $ stencil namespace create $ stencil namespace create -n=raystack -f=FORMAT_PROTOBUF -c=COMPATIBILITY_BACKWARD -d="Event schemas" `), RunE: func(cmd *cobra.Command, args []string) error { @@ -130,33 +125,37 @@ func createNamespaceCmd(cdk *CDK) *cobra.Command { comp = comps[formatAnswer] } - req.Id = id - req.Format = stencilv1beta1.Schema_Format(stencilv1beta1.Schema_Format_value[format]) - req.Compatibility = stencilv1beta1.Schema_Compatibility(stencilv1beta1.Schema_Compatibility_value[comp]) - req.Description = desc + req := &stencilv1beta1.CreateNamespaceRequest{ + Id: id, + Format: stencilv1beta1.Schema_Format(stencilv1beta1.Schema_Format_value[format]), + Compatibility: stencilv1beta1.Schema_Compatibility(stencilv1beta1.Schema_Compatibility_value[comp]), + Description: desc, + } spinner := printer.Spin("") defer spinner.Stop() - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() - res, err := client.CreateNamespace(context.Background(), &req) + res, err := client.CreateNamespace(context.Background(), connect.NewRequest(req)) spinner.Stop() if err != nil { - errStatus, _ := status.FromError(err) - if codes.AlreadyExists == errStatus.Code() { + connectErr := new(connect.Error) + if ok := err.(*connect.Error); ok != nil { + connectErr = ok + } + if connectErr.Code() == connect.CodeAlreadyExists { fmt.Printf("\n%s Namespace with id '%s' already exist.\n", printer.Icon("failure"), id) return nil } return err } - namespace := res.GetNamespace() + namespace := res.Msg.GetNamespace() fmt.Printf("\n%s Created namespace with id %s.\n", printer.Green(printer.Icon("success")), printer.Bold(printer.Blue(namespace.GetId()))) return nil }, @@ -173,7 +172,6 @@ func createNamespaceCmd(cdk *CDK) *cobra.Command { func editNamespaceCmd(cdk *CDK) *cobra.Command { var format, comp string var desc string - var req stencilv1beta1.UpdateNamespaceRequest cmd := &cobra.Command{ Use: "edit ", @@ -186,32 +184,33 @@ func editNamespaceCmd(cdk *CDK) *cobra.Command { spinner := printer.Spin("") defer spinner.Stop() - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() id := args[0] - req.Id = id - req.Format = stencilv1beta1.Schema_Format(stencilv1beta1.Schema_Format_value[format]) - req.Compatibility = stencilv1beta1.Schema_Compatibility(stencilv1beta1.Schema_Compatibility_value[comp]) - req.Description = desc + req := &stencilv1beta1.UpdateNamespaceRequest{ + Id: id, + Format: stencilv1beta1.Schema_Format(stencilv1beta1.Schema_Format_value[format]), + Compatibility: stencilv1beta1.Schema_Compatibility(stencilv1beta1.Schema_Compatibility_value[comp]), + Description: desc, + } - res, err := client.UpdateNamespace(context.Background(), &req) + res, err := client.UpdateNamespace(context.Background(), connect.NewRequest(req)) spinner.Stop() if err != nil { - errStatus, _ := status.FromError(err) - if codes.NotFound == errStatus.Code() { + connectErr, ok := err.(*connect.Error) + if ok && connectErr.Code() == connect.CodeNotFound { fmt.Printf("%s Namespace with id '%s' does not exist.\n", printer.Icon("failure"), id) return nil } return err } - namespace := res.Namespace + namespace := res.Msg.GetNamespace() fmt.Printf("%s Updated namespace with id %s.\n", printer.Green(printer.Icon("success")), printer.Bold(printer.Blue(namespace.GetId()))) return nil @@ -232,8 +231,6 @@ func editNamespaceCmd(cdk *CDK) *cobra.Command { } func viewNamespaceCmd(cdk *CDK) *cobra.Command { - var req stencilv1beta1.GetNamespaceRequest - cmd := &cobra.Command{ Use: "view ", Short: "View a namespace", @@ -245,28 +242,25 @@ func viewNamespaceCmd(cdk *CDK) *cobra.Command { spinner := printer.Spin("") defer spinner.Stop() - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() id := args[0] - req.Id = id - - res, err := client.GetNamespace(context.Background(), &req) + res, err := client.GetNamespace(context.Background(), connect.NewRequest(&stencilv1beta1.GetNamespaceRequest{Id: id})) spinner.Stop() if err != nil { - errStatus, _ := status.FromError(err) - if codes.NotFound == errStatus.Code() { + connectErr, ok := err.(*connect.Error) + if ok && connectErr.Code() == connect.CodeNotFound { fmt.Printf("%s Namespace with id %s does not exist.\n", printer.Icon("failure"), printer.Bold(printer.Blue(id))) return nil } return err } - namespace := res.GetNamespace() + namespace := res.Msg.GetNamespace() printNamespace(namespace) @@ -278,8 +272,6 @@ func viewNamespaceCmd(cdk *CDK) *cobra.Command { } func deleteNamespaceCmd(cdk *CDK) *cobra.Command { - var req stencilv1beta1.DeleteNamespaceRequest - cmd := &cobra.Command{ Use: "delete ", Short: "Delete a namespace", @@ -300,21 +292,18 @@ func deleteNamespaceCmd(cdk *CDK) *cobra.Command { spinner := printer.Spin("") defer spinner.Stop() - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() - - req.Id = id - _, err = client.DeleteNamespace(context.Background(), &req) + _, err = client.DeleteNamespace(context.Background(), connect.NewRequest(&stencilv1beta1.DeleteNamespaceRequest{Id: id})) spinner.Stop() if err != nil { - errStatus, _ := status.FromError(err) - if codes.NotFound == errStatus.Code() { + connectErr, ok := err.(*connect.Error) + if ok && connectErr.Code() == connect.CodeNotFound { fmt.Printf("\n%s Namespace with id '%s' does not exist.\n", printer.Icon("failure"), id) return nil } diff --git a/cmd/print.go b/cmd/print.go index aa11ff59..3fe84f97 100644 --- a/cmd/print.go +++ b/cmd/print.go @@ -10,7 +10,7 @@ import ( "github.com/jhump/protoreflect/desc/protoprint" "github.com/raystack/salt/cli/printer" "github.com/raystack/salt/cli/terminator" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + stencilv1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" "github.com/spf13/cobra" "google.golang.org/protobuf/proto" "google.golang.org/protobuf/types/descriptorpb" @@ -32,11 +32,10 @@ func printSchemaCmd(cdk *CDK) *cobra.Command { RunE: func(cmd *cobra.Command, args []string) error { spinner := printer.Spin("") defer spinner.Stop() - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() data, meta, err := fetchSchemaAndMeta(client, version, namespaceID, args[0]) if err != nil { diff --git a/cmd/schema.go b/cmd/schema.go index e81a2444..31763fd6 100644 --- a/cmd/schema.go +++ b/cmd/schema.go @@ -3,7 +3,9 @@ package cmd import ( "context" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + "connectrpc.com/connect" + stencilv1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" + stencilv1beta1connect "github.com/raystack/stencil/gen/raystack/stencil/v1beta1/stencilv1beta1connect" "github.com/spf13/cobra" ) @@ -34,41 +36,39 @@ func SchemaCmd(cdk *CDK) *cobra.Command { return cmd } -func fetchSchemaAndMeta(client stencilv1beta1.StencilServiceClient, version int32, namespaceID, schemaID string) ([]byte, *stencilv1beta1.GetSchemaMetadataResponse, error) { - var req stencilv1beta1.GetSchemaRequest - var reqLatest stencilv1beta1.GetLatestSchemaRequest +func fetchSchemaAndMeta(client stencilv1beta1connect.StencilServiceClient, version int32, namespaceID, schemaID string) ([]byte, *stencilv1beta1.GetSchemaMetadataResponse, error) { var data []byte ctx := context.Background() if version != 0 { - req.NamespaceId = namespaceID - req.SchemaId = schemaID - req.VersionId = version - res, err := client.GetSchema(ctx, &req) + res, err := client.GetSchema(ctx, connect.NewRequest(&stencilv1beta1.GetSchemaRequest{ + NamespaceId: namespaceID, + SchemaId: schemaID, + VersionId: version, + })) if err != nil { return nil, nil, err } - data = res.GetData() + data = res.Msg.GetData() } else { - reqLatest.NamespaceId = namespaceID - reqLatest.SchemaId = schemaID - res, err := client.GetLatestSchema(ctx, &reqLatest) + res, err := client.GetLatestSchema(ctx, connect.NewRequest(&stencilv1beta1.GetLatestSchemaRequest{ + NamespaceId: namespaceID, + SchemaId: schemaID, + })) if err != nil { return nil, nil, err } - data = res.GetData() + data = res.Msg.GetData() } - reqMeta := stencilv1beta1.GetSchemaMetadataRequest{ + metaRes, err := client.GetSchemaMetadata(context.Background(), connect.NewRequest(&stencilv1beta1.GetSchemaMetadataRequest{ NamespaceId: namespaceID, SchemaId: schemaID, - } - meta, err := client.GetSchemaMetadata(context.Background(), &reqMeta) - + })) if err != nil { return nil, nil, err } - return data, meta, nil + return data, metaRes.Msg, nil } diff --git a/cmd/search.go b/cmd/search.go index 673365cd..a462b9c6 100644 --- a/cmd/search.go +++ b/cmd/search.go @@ -7,9 +7,10 @@ import ( "strconv" "strings" + "connectrpc.com/connect" "github.com/MakeNowJust/heredoc" "github.com/raystack/salt/cli/printer" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + stencilv1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" "github.com/spf13/cobra" ) @@ -17,7 +18,6 @@ func SearchCmd(cdk *CDK) *cobra.Command { var namespaceID, schemaID string var versionID int32 var history bool - var req stencilv1beta1.SearchRequest cmd := &cobra.Command{ Use: "search ", @@ -41,22 +41,23 @@ func SearchCmd(cdk *CDK) *cobra.Command { s := printer.Spin("") defer s.Stop() - client, cancel, err := createClient(cmd, cdk) + client, err := createClient(cmd, cdk) if err != nil { return err } - defer cancel() query := args[0] - req.Query = query + req := &stencilv1beta1.SearchRequest{ + Query: query, + NamespaceId: namespaceID, + SchemaId: schemaID, + } if len(schemaID) > 0 && len(namespaceID) == 0 { s.Stop() fmt.Println("Namespace ID not specified for", schemaID) return nil } - req.NamespaceId = namespaceID - req.SchemaId = schemaID if versionID != 0 { req.Version = &stencilv1beta1.SearchRequest_VersionId{ @@ -68,12 +69,12 @@ func SearchCmd(cdk *CDK) *cobra.Command { } } - res, err := client.Search(context.Background(), &req) + res, err := client.Search(context.Background(), connect.NewRequest(req)) if err != nil { return err } - hits := res.GetHits() + hits := res.Msg.GetHits() report := [][]string{} s.Stop() diff --git a/config/config.go b/config/config.go index 157e56c4..d3f50b91 100644 --- a/config/config.go +++ b/config/config.go @@ -2,31 +2,24 @@ package config import "time" -// NewRelicConfig contains the New Relic go-agent configuration -type NewRelicConfig struct { - Enabled bool `default:"false"` - AppName string `default:"stencil"` - License string -} - // DBConfig contains DB connection details type DBConfig struct { ConnectionString string } -// GRPCConfig grpc options -type GRPCConfig struct { - MaxRecvMsgSizeInMB int `default:"10"` - MaxSendMsgSizeInMB int `default:"10"` +// CORSConfig contains CORS configuration +type CORSConfig struct { + AllowedOrigins []string `default:"[\"*\"]"` } // Config Server config type Config struct { Port string `default:"8080"` // Timeout represents graceful shutdown period. Defaults to 60 seconds. - Timeout time.Duration `default:"60s"` - CacheSizeInMB int64 `default:"100"` - GRPC GRPCConfig - NewRelic NewRelicConfig - DB DBConfig + Timeout time.Duration `default:"60s"` + CacheSizeInMB int64 `default:"100"` + MaxRecvMsgSize int `default:"10485760"` // 10 MB + MaxSendMsgSize int `default:"10485760"` // 10 MB + CORS CORSConfig + DB DBConfig } diff --git a/formats/avro/provider.go b/formats/avro/provider.go index e6fae6fd..bb943055 100644 --- a/formats/avro/provider.go +++ b/formats/avro/provider.go @@ -1,9 +1,7 @@ package avro import ( - "net/http" - - "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" + "connectrpc.com/connect" av "github.com/hamba/avro" "github.com/raystack/stencil/core/schema" ) @@ -12,7 +10,7 @@ import ( func ParseSchema(data []byte) (schema.ParsedSchema, error) { sc, err := av.Parse(string(data)) if err != nil { - return nil, &runtime.HTTPStatusError{HTTPStatus: http.StatusBadRequest, Err: err} + return nil, connect.NewError(connect.CodeInvalidArgument, err) } return &Schema{sc: sc, data: data}, nil } diff --git a/formats/avro/schema.go b/formats/avro/schema.go index ce479681..0130c2ac 100644 --- a/formats/avro/schema.go +++ b/formats/avro/schema.go @@ -3,8 +3,8 @@ package avro import ( "fmt" + "connectrpc.com/connect" "github.com/google/uuid" - "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" av "github.com/hamba/avro" "github.com/raystack/stencil/core/schema" "go.uber.org/multierr" @@ -35,7 +35,7 @@ func (s *Schema) verify(against schema.ParsedSchema) (*Schema, error) { if s.Format() == against.Format() && ok { return prev, nil } - return nil, &runtime.HTTPStatusError{HTTPStatus: 400, Err: fmt.Errorf("current and prev schema formats(%s, %s) are different", s.Format(), against.Format())} + return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("current and prev schema formats(%s, %s) are different", s.Format(), against.Format())) } // IsBackwardCompatible checks backward compatibility against given schema diff --git a/formats/json/provider.go b/formats/json/provider.go index bed0982a..28b461e0 100644 --- a/formats/json/provider.go +++ b/formats/json/provider.go @@ -2,9 +2,8 @@ package json import ( js "encoding/json" - "net/http" - "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" + "connectrpc.com/connect" "github.com/raystack/stencil/core/schema" "github.com/santhosh-tekuri/jsonschema/v5" ) @@ -15,10 +14,10 @@ func GetParsedSchema(data []byte) (schema.ParsedSchema, error) { sc, _ := compiler.Compile("https://json-schema.org/draft/2020-12/schema") var val interface{} if err := js.Unmarshal(data, &val); err != nil { - return nil, &runtime.HTTPStatusError{HTTPStatus: http.StatusBadRequest, Err: err} + return nil, connect.NewError(connect.CodeInvalidArgument, err) } if err := sc.Validate(val); err != nil { - return nil, &runtime.HTTPStatusError{HTTPStatus: http.StatusBadRequest, Err: err} + return nil, connect.NewError(connect.CodeInvalidArgument, err) } return &Schema{data: data}, nil } diff --git a/formats/protobuf/error.go b/formats/protobuf/error.go index 909c0050..1dbf3a46 100644 --- a/formats/protobuf/error.go +++ b/formats/protobuf/error.go @@ -4,8 +4,7 @@ import ( "fmt" "strings" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" + "connectrpc.com/connect" "google.golang.org/protobuf/reflect/protoreflect" ) @@ -39,6 +38,6 @@ func (c *compatibilityErr) Error() string { return strings.Join(msgs, ";") } -func (c *compatibilityErr) GRPCStatus() *status.Status { - return status.New(codes.InvalidArgument, c.Error()) +func (c *compatibilityErr) ConnectError() *connect.Error { + return connect.NewError(connect.CodeInvalidArgument, c) } diff --git a/gen/raystack/stencil/v1beta1/stencil.pb.go b/gen/raystack/stencil/v1beta1/stencil.pb.go new file mode 100644 index 00000000..4e436856 --- /dev/null +++ b/gen/raystack/stencil/v1beta1/stencil.pb.go @@ -0,0 +1,2482 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.11 +// protoc (unknown) +// source: raystack/stencil/v1beta1/stencil.proto + +package stencilv1beta1 + +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" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +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 Schema_Format int32 + +const ( + Schema_FORMAT_UNSPECIFIED Schema_Format = 0 + Schema_FORMAT_PROTOBUF Schema_Format = 1 + Schema_FORMAT_AVRO Schema_Format = 2 + Schema_FORMAT_JSON Schema_Format = 3 +) + +// Enum value maps for Schema_Format. +var ( + Schema_Format_name = map[int32]string{ + 0: "FORMAT_UNSPECIFIED", + 1: "FORMAT_PROTOBUF", + 2: "FORMAT_AVRO", + 3: "FORMAT_JSON", + } + Schema_Format_value = map[string]int32{ + "FORMAT_UNSPECIFIED": 0, + "FORMAT_PROTOBUF": 1, + "FORMAT_AVRO": 2, + "FORMAT_JSON": 3, + } +) + +func (x Schema_Format) Enum() *Schema_Format { + p := new(Schema_Format) + *p = x + return p +} + +func (x Schema_Format) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Schema_Format) Descriptor() protoreflect.EnumDescriptor { + return file_raystack_stencil_v1beta1_stencil_proto_enumTypes[0].Descriptor() +} + +func (Schema_Format) Type() protoreflect.EnumType { + return &file_raystack_stencil_v1beta1_stencil_proto_enumTypes[0] +} + +func (x Schema_Format) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Schema_Format.Descriptor instead. +func (Schema_Format) EnumDescriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{1, 0} +} + +type Schema_Compatibility int32 + +const ( + Schema_COMPATIBILITY_UNSPECIFIED Schema_Compatibility = 0 + Schema_COMPATIBILITY_BACKWARD Schema_Compatibility = 1 + Schema_COMPATIBILITY_BACKWARD_TRANSITIVE Schema_Compatibility = 2 + Schema_COMPATIBILITY_FORWARD Schema_Compatibility = 3 + Schema_COMPATIBILITY_FORWARD_TRANSITIVE Schema_Compatibility = 4 + Schema_COMPATIBILITY_FULL Schema_Compatibility = 5 + Schema_COMPATIBILITY_FULL_TRANSITIVE Schema_Compatibility = 6 +) + +// Enum value maps for Schema_Compatibility. +var ( + Schema_Compatibility_name = map[int32]string{ + 0: "COMPATIBILITY_UNSPECIFIED", + 1: "COMPATIBILITY_BACKWARD", + 2: "COMPATIBILITY_BACKWARD_TRANSITIVE", + 3: "COMPATIBILITY_FORWARD", + 4: "COMPATIBILITY_FORWARD_TRANSITIVE", + 5: "COMPATIBILITY_FULL", + 6: "COMPATIBILITY_FULL_TRANSITIVE", + } + Schema_Compatibility_value = map[string]int32{ + "COMPATIBILITY_UNSPECIFIED": 0, + "COMPATIBILITY_BACKWARD": 1, + "COMPATIBILITY_BACKWARD_TRANSITIVE": 2, + "COMPATIBILITY_FORWARD": 3, + "COMPATIBILITY_FORWARD_TRANSITIVE": 4, + "COMPATIBILITY_FULL": 5, + "COMPATIBILITY_FULL_TRANSITIVE": 6, + } +) + +func (x Schema_Compatibility) Enum() *Schema_Compatibility { + p := new(Schema_Compatibility) + *p = x + return p +} + +func (x Schema_Compatibility) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Schema_Compatibility) Descriptor() protoreflect.EnumDescriptor { + return file_raystack_stencil_v1beta1_stencil_proto_enumTypes[1].Descriptor() +} + +func (Schema_Compatibility) Type() protoreflect.EnumType { + return &file_raystack_stencil_v1beta1_stencil_proto_enumTypes[1] +} + +func (x Schema_Compatibility) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Schema_Compatibility.Descriptor instead. +func (Schema_Compatibility) EnumDescriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{1, 1} +} + +type Namespace struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Format Schema_Format `protobuf:"varint,2,opt,name=format,proto3,enum=raystack.stencil.v1beta1.Schema_Format" json:"format,omitempty"` + Compatibility Schema_Compatibility `protobuf:"varint,3,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` + Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` + CreatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` + UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Namespace) Reset() { + *x = Namespace{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Namespace) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Namespace) ProtoMessage() {} + +func (x *Namespace) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Namespace.ProtoReflect.Descriptor instead. +func (*Namespace) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{0} +} + +func (x *Namespace) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *Namespace) GetFormat() Schema_Format { + if x != nil { + return x.Format + } + return Schema_FORMAT_UNSPECIFIED +} + +func (x *Namespace) GetCompatibility() Schema_Compatibility { + if x != nil { + return x.Compatibility + } + return Schema_COMPATIBILITY_UNSPECIFIED +} + +func (x *Namespace) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +func (x *Namespace) GetCreatedAt() *timestamppb.Timestamp { + if x != nil { + return x.CreatedAt + } + return nil +} + +func (x *Namespace) GetUpdatedAt() *timestamppb.Timestamp { + if x != nil { + return x.UpdatedAt + } + return nil +} + +type Schema struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Format Schema_Format `protobuf:"varint,2,opt,name=format,proto3,enum=raystack.stencil.v1beta1.Schema_Format" json:"format,omitempty"` + Authority string `protobuf:"bytes,3,opt,name=authority,proto3" json:"authority,omitempty"` + Compatibility Schema_Compatibility `protobuf:"varint,4,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` + CreatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` + UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Schema) Reset() { + *x = Schema{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Schema) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Schema) ProtoMessage() {} + +func (x *Schema) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Schema.ProtoReflect.Descriptor instead. +func (*Schema) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{1} +} + +func (x *Schema) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Schema) GetFormat() Schema_Format { + if x != nil { + return x.Format + } + return Schema_FORMAT_UNSPECIFIED +} + +func (x *Schema) GetAuthority() string { + if x != nil { + return x.Authority + } + return "" +} + +func (x *Schema) GetCompatibility() Schema_Compatibility { + if x != nil { + return x.Compatibility + } + return Schema_COMPATIBILITY_UNSPECIFIED +} + +func (x *Schema) GetCreatedAt() *timestamppb.Timestamp { + if x != nil { + return x.CreatedAt + } + return nil +} + +func (x *Schema) GetUpdatedAt() *timestamppb.Timestamp { + if x != nil { + return x.UpdatedAt + } + return nil +} + +type ListNamespacesRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListNamespacesRequest) Reset() { + *x = ListNamespacesRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListNamespacesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListNamespacesRequest) ProtoMessage() {} + +func (x *ListNamespacesRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListNamespacesRequest.ProtoReflect.Descriptor instead. +func (*ListNamespacesRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{2} +} + +type ListNamespacesResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Namespaces []*Namespace `protobuf:"bytes,1,rep,name=namespaces,proto3" json:"namespaces,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListNamespacesResponse) Reset() { + *x = ListNamespacesResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListNamespacesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListNamespacesResponse) ProtoMessage() {} + +func (x *ListNamespacesResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListNamespacesResponse.ProtoReflect.Descriptor instead. +func (*ListNamespacesResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{3} +} + +func (x *ListNamespacesResponse) GetNamespaces() []*Namespace { + if x != nil { + return x.Namespaces + } + return nil +} + +type GetNamespaceRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetNamespaceRequest) Reset() { + *x = GetNamespaceRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetNamespaceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetNamespaceRequest) ProtoMessage() {} + +func (x *GetNamespaceRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetNamespaceRequest.ProtoReflect.Descriptor instead. +func (*GetNamespaceRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{4} +} + +func (x *GetNamespaceRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +type GetNamespaceResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Namespace *Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetNamespaceResponse) Reset() { + *x = GetNamespaceResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetNamespaceResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetNamespaceResponse) ProtoMessage() {} + +func (x *GetNamespaceResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetNamespaceResponse.ProtoReflect.Descriptor instead. +func (*GetNamespaceResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{5} +} + +func (x *GetNamespaceResponse) GetNamespace() *Namespace { + if x != nil { + return x.Namespace + } + return nil +} + +type CreateNamespaceRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Format Schema_Format `protobuf:"varint,2,opt,name=format,proto3,enum=raystack.stencil.v1beta1.Schema_Format" json:"format,omitempty"` + Compatibility Schema_Compatibility `protobuf:"varint,3,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` + Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CreateNamespaceRequest) Reset() { + *x = CreateNamespaceRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CreateNamespaceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateNamespaceRequest) ProtoMessage() {} + +func (x *CreateNamespaceRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateNamespaceRequest.ProtoReflect.Descriptor instead. +func (*CreateNamespaceRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{6} +} + +func (x *CreateNamespaceRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *CreateNamespaceRequest) GetFormat() Schema_Format { + if x != nil { + return x.Format + } + return Schema_FORMAT_UNSPECIFIED +} + +func (x *CreateNamespaceRequest) GetCompatibility() Schema_Compatibility { + if x != nil { + return x.Compatibility + } + return Schema_COMPATIBILITY_UNSPECIFIED +} + +func (x *CreateNamespaceRequest) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +type CreateNamespaceResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Namespace *Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CreateNamespaceResponse) Reset() { + *x = CreateNamespaceResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CreateNamespaceResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateNamespaceResponse) ProtoMessage() {} + +func (x *CreateNamespaceResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[7] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateNamespaceResponse.ProtoReflect.Descriptor instead. +func (*CreateNamespaceResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{7} +} + +func (x *CreateNamespaceResponse) GetNamespace() *Namespace { + if x != nil { + return x.Namespace + } + return nil +} + +type UpdateNamespaceRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Format Schema_Format `protobuf:"varint,2,opt,name=format,proto3,enum=raystack.stencil.v1beta1.Schema_Format" json:"format,omitempty"` + Compatibility Schema_Compatibility `protobuf:"varint,3,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` + Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UpdateNamespaceRequest) Reset() { + *x = UpdateNamespaceRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UpdateNamespaceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateNamespaceRequest) ProtoMessage() {} + +func (x *UpdateNamespaceRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[8] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateNamespaceRequest.ProtoReflect.Descriptor instead. +func (*UpdateNamespaceRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{8} +} + +func (x *UpdateNamespaceRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *UpdateNamespaceRequest) GetFormat() Schema_Format { + if x != nil { + return x.Format + } + return Schema_FORMAT_UNSPECIFIED +} + +func (x *UpdateNamespaceRequest) GetCompatibility() Schema_Compatibility { + if x != nil { + return x.Compatibility + } + return Schema_COMPATIBILITY_UNSPECIFIED +} + +func (x *UpdateNamespaceRequest) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +type UpdateNamespaceResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Namespace *Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UpdateNamespaceResponse) Reset() { + *x = UpdateNamespaceResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UpdateNamespaceResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateNamespaceResponse) ProtoMessage() {} + +func (x *UpdateNamespaceResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[9] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateNamespaceResponse.ProtoReflect.Descriptor instead. +func (*UpdateNamespaceResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{9} +} + +func (x *UpdateNamespaceResponse) GetNamespace() *Namespace { + if x != nil { + return x.Namespace + } + return nil +} + +type DeleteNamespaceRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeleteNamespaceRequest) Reset() { + *x = DeleteNamespaceRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteNamespaceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteNamespaceRequest) ProtoMessage() {} + +func (x *DeleteNamespaceRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[10] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteNamespaceRequest.ProtoReflect.Descriptor instead. +func (*DeleteNamespaceRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{10} +} + +func (x *DeleteNamespaceRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +type DeleteNamespaceResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeleteNamespaceResponse) Reset() { + *x = DeleteNamespaceResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteNamespaceResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteNamespaceResponse) ProtoMessage() {} + +func (x *DeleteNamespaceResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[11] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteNamespaceResponse.ProtoReflect.Descriptor instead. +func (*DeleteNamespaceResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{11} +} + +func (x *DeleteNamespaceResponse) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +type ListSchemasRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListSchemasRequest) Reset() { + *x = ListSchemasRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListSchemasRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListSchemasRequest) ProtoMessage() {} + +func (x *ListSchemasRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[12] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListSchemasRequest.ProtoReflect.Descriptor instead. +func (*ListSchemasRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{12} +} + +func (x *ListSchemasRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +type ListSchemasResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Schemas []*Schema `protobuf:"bytes,1,rep,name=schemas,proto3" json:"schemas,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListSchemasResponse) Reset() { + *x = ListSchemasResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListSchemasResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListSchemasResponse) ProtoMessage() {} + +func (x *ListSchemasResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[13] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListSchemasResponse.ProtoReflect.Descriptor instead. +func (*ListSchemasResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{13} +} + +func (x *ListSchemasResponse) GetSchemas() []*Schema { + if x != nil { + return x.Schemas + } + return nil +} + +type GetLatestSchemaRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetLatestSchemaRequest) Reset() { + *x = GetLatestSchemaRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetLatestSchemaRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetLatestSchemaRequest) ProtoMessage() {} + +func (x *GetLatestSchemaRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[14] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetLatestSchemaRequest.ProtoReflect.Descriptor instead. +func (*GetLatestSchemaRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{14} +} + +func (x *GetLatestSchemaRequest) GetNamespaceId() string { + if x != nil { + return x.NamespaceId + } + return "" +} + +func (x *GetLatestSchemaRequest) GetSchemaId() string { + if x != nil { + return x.SchemaId + } + return "" +} + +type GetLatestSchemaResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetLatestSchemaResponse) Reset() { + *x = GetLatestSchemaResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetLatestSchemaResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetLatestSchemaResponse) ProtoMessage() {} + +func (x *GetLatestSchemaResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[15] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetLatestSchemaResponse.ProtoReflect.Descriptor instead. +func (*GetLatestSchemaResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{15} +} + +func (x *GetLatestSchemaResponse) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +type CreateSchemaRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` + Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` + Format Schema_Format `protobuf:"varint,4,opt,name=format,proto3,enum=raystack.stencil.v1beta1.Schema_Format" json:"format,omitempty"` + Compatibility Schema_Compatibility `protobuf:"varint,5,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CreateSchemaRequest) Reset() { + *x = CreateSchemaRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CreateSchemaRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateSchemaRequest) ProtoMessage() {} + +func (x *CreateSchemaRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[16] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateSchemaRequest.ProtoReflect.Descriptor instead. +func (*CreateSchemaRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{16} +} + +func (x *CreateSchemaRequest) GetNamespaceId() string { + if x != nil { + return x.NamespaceId + } + return "" +} + +func (x *CreateSchemaRequest) GetSchemaId() string { + if x != nil { + return x.SchemaId + } + return "" +} + +func (x *CreateSchemaRequest) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *CreateSchemaRequest) GetFormat() Schema_Format { + if x != nil { + return x.Format + } + return Schema_FORMAT_UNSPECIFIED +} + +func (x *CreateSchemaRequest) GetCompatibility() Schema_Compatibility { + if x != nil { + return x.Compatibility + } + return Schema_COMPATIBILITY_UNSPECIFIED +} + +type CreateSchemaResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Version int32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"` + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` + Location string `protobuf:"bytes,3,opt,name=location,proto3" json:"location,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CreateSchemaResponse) Reset() { + *x = CreateSchemaResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CreateSchemaResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateSchemaResponse) ProtoMessage() {} + +func (x *CreateSchemaResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[17] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateSchemaResponse.ProtoReflect.Descriptor instead. +func (*CreateSchemaResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{17} +} + +func (x *CreateSchemaResponse) GetVersion() int32 { + if x != nil { + return x.Version + } + return 0 +} + +func (x *CreateSchemaResponse) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *CreateSchemaResponse) GetLocation() string { + if x != nil { + return x.Location + } + return "" +} + +type CheckCompatibilityRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` + Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` + Compatibility Schema_Compatibility `protobuf:"varint,4,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CheckCompatibilityRequest) Reset() { + *x = CheckCompatibilityRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CheckCompatibilityRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CheckCompatibilityRequest) ProtoMessage() {} + +func (x *CheckCompatibilityRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[18] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CheckCompatibilityRequest.ProtoReflect.Descriptor instead. +func (*CheckCompatibilityRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{18} +} + +func (x *CheckCompatibilityRequest) GetNamespaceId() string { + if x != nil { + return x.NamespaceId + } + return "" +} + +func (x *CheckCompatibilityRequest) GetSchemaId() string { + if x != nil { + return x.SchemaId + } + return "" +} + +func (x *CheckCompatibilityRequest) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *CheckCompatibilityRequest) GetCompatibility() Schema_Compatibility { + if x != nil { + return x.Compatibility + } + return Schema_COMPATIBILITY_UNSPECIFIED +} + +type CheckCompatibilityResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CheckCompatibilityResponse) Reset() { + *x = CheckCompatibilityResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CheckCompatibilityResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CheckCompatibilityResponse) ProtoMessage() {} + +func (x *CheckCompatibilityResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[19] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CheckCompatibilityResponse.ProtoReflect.Descriptor instead. +func (*CheckCompatibilityResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{19} +} + +type GetSchemaMetadataRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetSchemaMetadataRequest) Reset() { + *x = GetSchemaMetadataRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetSchemaMetadataRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSchemaMetadataRequest) ProtoMessage() {} + +func (x *GetSchemaMetadataRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[20] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSchemaMetadataRequest.ProtoReflect.Descriptor instead. +func (*GetSchemaMetadataRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{20} +} + +func (x *GetSchemaMetadataRequest) GetNamespaceId() string { + if x != nil { + return x.NamespaceId + } + return "" +} + +func (x *GetSchemaMetadataRequest) GetSchemaId() string { + if x != nil { + return x.SchemaId + } + return "" +} + +type GetSchemaMetadataResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Format Schema_Format `protobuf:"varint,1,opt,name=format,proto3,enum=raystack.stencil.v1beta1.Schema_Format" json:"format,omitempty"` + Compatibility Schema_Compatibility `protobuf:"varint,2,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` + Authority string `protobuf:"bytes,3,opt,name=authority,proto3" json:"authority,omitempty"` + Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` + CreatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` + UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetSchemaMetadataResponse) Reset() { + *x = GetSchemaMetadataResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetSchemaMetadataResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSchemaMetadataResponse) ProtoMessage() {} + +func (x *GetSchemaMetadataResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[21] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSchemaMetadataResponse.ProtoReflect.Descriptor instead. +func (*GetSchemaMetadataResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{21} +} + +func (x *GetSchemaMetadataResponse) GetFormat() Schema_Format { + if x != nil { + return x.Format + } + return Schema_FORMAT_UNSPECIFIED +} + +func (x *GetSchemaMetadataResponse) GetCompatibility() Schema_Compatibility { + if x != nil { + return x.Compatibility + } + return Schema_COMPATIBILITY_UNSPECIFIED +} + +func (x *GetSchemaMetadataResponse) GetAuthority() string { + if x != nil { + return x.Authority + } + return "" +} + +func (x *GetSchemaMetadataResponse) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *GetSchemaMetadataResponse) GetCreatedAt() *timestamppb.Timestamp { + if x != nil { + return x.CreatedAt + } + return nil +} + +func (x *GetSchemaMetadataResponse) GetUpdatedAt() *timestamppb.Timestamp { + if x != nil { + return x.UpdatedAt + } + return nil +} + +type UpdateSchemaMetadataRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` + Compatibility Schema_Compatibility `protobuf:"varint,3,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UpdateSchemaMetadataRequest) Reset() { + *x = UpdateSchemaMetadataRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UpdateSchemaMetadataRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateSchemaMetadataRequest) ProtoMessage() {} + +func (x *UpdateSchemaMetadataRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[22] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateSchemaMetadataRequest.ProtoReflect.Descriptor instead. +func (*UpdateSchemaMetadataRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{22} +} + +func (x *UpdateSchemaMetadataRequest) GetNamespaceId() string { + if x != nil { + return x.NamespaceId + } + return "" +} + +func (x *UpdateSchemaMetadataRequest) GetSchemaId() string { + if x != nil { + return x.SchemaId + } + return "" +} + +func (x *UpdateSchemaMetadataRequest) GetCompatibility() Schema_Compatibility { + if x != nil { + return x.Compatibility + } + return Schema_COMPATIBILITY_UNSPECIFIED +} + +type UpdateSchemaMetadataResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Format Schema_Format `protobuf:"varint,1,opt,name=format,proto3,enum=raystack.stencil.v1beta1.Schema_Format" json:"format,omitempty"` + Compatibility Schema_Compatibility `protobuf:"varint,2,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` + Authority string `protobuf:"bytes,3,opt,name=authority,proto3" json:"authority,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UpdateSchemaMetadataResponse) Reset() { + *x = UpdateSchemaMetadataResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UpdateSchemaMetadataResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateSchemaMetadataResponse) ProtoMessage() {} + +func (x *UpdateSchemaMetadataResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[23] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateSchemaMetadataResponse.ProtoReflect.Descriptor instead. +func (*UpdateSchemaMetadataResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{23} +} + +func (x *UpdateSchemaMetadataResponse) GetFormat() Schema_Format { + if x != nil { + return x.Format + } + return Schema_FORMAT_UNSPECIFIED +} + +func (x *UpdateSchemaMetadataResponse) GetCompatibility() Schema_Compatibility { + if x != nil { + return x.Compatibility + } + return Schema_COMPATIBILITY_UNSPECIFIED +} + +func (x *UpdateSchemaMetadataResponse) GetAuthority() string { + if x != nil { + return x.Authority + } + return "" +} + +type DeleteSchemaRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeleteSchemaRequest) Reset() { + *x = DeleteSchemaRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteSchemaRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteSchemaRequest) ProtoMessage() {} + +func (x *DeleteSchemaRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[24] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteSchemaRequest.ProtoReflect.Descriptor instead. +func (*DeleteSchemaRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{24} +} + +func (x *DeleteSchemaRequest) GetNamespaceId() string { + if x != nil { + return x.NamespaceId + } + return "" +} + +func (x *DeleteSchemaRequest) GetSchemaId() string { + if x != nil { + return x.SchemaId + } + return "" +} + +type DeleteSchemaResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeleteSchemaResponse) Reset() { + *x = DeleteSchemaResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteSchemaResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteSchemaResponse) ProtoMessage() {} + +func (x *DeleteSchemaResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[25] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteSchemaResponse.ProtoReflect.Descriptor instead. +func (*DeleteSchemaResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{25} +} + +func (x *DeleteSchemaResponse) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +type ListVersionsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListVersionsRequest) Reset() { + *x = ListVersionsRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListVersionsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListVersionsRequest) ProtoMessage() {} + +func (x *ListVersionsRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[26] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListVersionsRequest.ProtoReflect.Descriptor instead. +func (*ListVersionsRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{26} +} + +func (x *ListVersionsRequest) GetNamespaceId() string { + if x != nil { + return x.NamespaceId + } + return "" +} + +func (x *ListVersionsRequest) GetSchemaId() string { + if x != nil { + return x.SchemaId + } + return "" +} + +type ListVersionsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Versions []int32 `protobuf:"varint,1,rep,packed,name=versions,proto3" json:"versions,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListVersionsResponse) Reset() { + *x = ListVersionsResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListVersionsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListVersionsResponse) ProtoMessage() {} + +func (x *ListVersionsResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[27] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListVersionsResponse.ProtoReflect.Descriptor instead. +func (*ListVersionsResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{27} +} + +func (x *ListVersionsResponse) GetVersions() []int32 { + if x != nil { + return x.Versions + } + return nil +} + +type GetSchemaRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` + VersionId int32 `protobuf:"varint,3,opt,name=version_id,json=versionId,proto3" json:"version_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetSchemaRequest) Reset() { + *x = GetSchemaRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetSchemaRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSchemaRequest) ProtoMessage() {} + +func (x *GetSchemaRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[28] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSchemaRequest.ProtoReflect.Descriptor instead. +func (*GetSchemaRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{28} +} + +func (x *GetSchemaRequest) GetNamespaceId() string { + if x != nil { + return x.NamespaceId + } + return "" +} + +func (x *GetSchemaRequest) GetSchemaId() string { + if x != nil { + return x.SchemaId + } + return "" +} + +func (x *GetSchemaRequest) GetVersionId() int32 { + if x != nil { + return x.VersionId + } + return 0 +} + +type GetSchemaResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetSchemaResponse) Reset() { + *x = GetSchemaResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetSchemaResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSchemaResponse) ProtoMessage() {} + +func (x *GetSchemaResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[29] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSchemaResponse.ProtoReflect.Descriptor instead. +func (*GetSchemaResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{29} +} + +func (x *GetSchemaResponse) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +type DeleteVersionRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` + VersionId int32 `protobuf:"varint,3,opt,name=version_id,json=versionId,proto3" json:"version_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeleteVersionRequest) Reset() { + *x = DeleteVersionRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteVersionRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteVersionRequest) ProtoMessage() {} + +func (x *DeleteVersionRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[30] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteVersionRequest.ProtoReflect.Descriptor instead. +func (*DeleteVersionRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{30} +} + +func (x *DeleteVersionRequest) GetNamespaceId() string { + if x != nil { + return x.NamespaceId + } + return "" +} + +func (x *DeleteVersionRequest) GetSchemaId() string { + if x != nil { + return x.SchemaId + } + return "" +} + +func (x *DeleteVersionRequest) GetVersionId() int32 { + if x != nil { + return x.VersionId + } + return 0 +} + +type DeleteVersionResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeleteVersionResponse) Reset() { + *x = DeleteVersionResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteVersionResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteVersionResponse) ProtoMessage() {} + +func (x *DeleteVersionResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[31] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteVersionResponse.ProtoReflect.Descriptor instead. +func (*DeleteVersionResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{31} +} + +func (x *DeleteVersionResponse) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +type SearchRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` + Query string `protobuf:"bytes,3,opt,name=query,proto3" json:"query,omitempty"` + // Types that are valid to be assigned to Version: + // + // *SearchRequest_History + // *SearchRequest_VersionId + Version isSearchRequest_Version `protobuf_oneof:"version"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SearchRequest) Reset() { + *x = SearchRequest{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SearchRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SearchRequest) ProtoMessage() {} + +func (x *SearchRequest) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[32] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SearchRequest.ProtoReflect.Descriptor instead. +func (*SearchRequest) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{32} +} + +func (x *SearchRequest) GetNamespaceId() string { + if x != nil { + return x.NamespaceId + } + return "" +} + +func (x *SearchRequest) GetSchemaId() string { + if x != nil { + return x.SchemaId + } + return "" +} + +func (x *SearchRequest) GetQuery() string { + if x != nil { + return x.Query + } + return "" +} + +func (x *SearchRequest) GetVersion() isSearchRequest_Version { + if x != nil { + return x.Version + } + return nil +} + +func (x *SearchRequest) GetHistory() bool { + if x != nil { + if x, ok := x.Version.(*SearchRequest_History); ok { + return x.History + } + } + return false +} + +func (x *SearchRequest) GetVersionId() int32 { + if x != nil { + if x, ok := x.Version.(*SearchRequest_VersionId); ok { + return x.VersionId + } + } + return 0 +} + +type isSearchRequest_Version interface { + isSearchRequest_Version() +} + +type SearchRequest_History struct { + History bool `protobuf:"varint,4,opt,name=history,proto3,oneof"` +} + +type SearchRequest_VersionId struct { + VersionId int32 `protobuf:"varint,5,opt,name=version_id,json=versionId,proto3,oneof"` +} + +func (*SearchRequest_History) isSearchRequest_Version() {} + +func (*SearchRequest_VersionId) isSearchRequest_Version() {} + +type SearchResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Hits []*SearchHits `protobuf:"bytes,1,rep,name=hits,proto3" json:"hits,omitempty"` + Meta *SearchMeta `protobuf:"bytes,2,opt,name=meta,proto3" json:"meta,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SearchResponse) Reset() { + *x = SearchResponse{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[33] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SearchResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SearchResponse) ProtoMessage() {} + +func (x *SearchResponse) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[33] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SearchResponse.ProtoReflect.Descriptor instead. +func (*SearchResponse) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{33} +} + +func (x *SearchResponse) GetHits() []*SearchHits { + if x != nil { + return x.Hits + } + return nil +} + +func (x *SearchResponse) GetMeta() *SearchMeta { + if x != nil { + return x.Meta + } + return nil +} + +type SearchHits struct { + state protoimpl.MessageState `protogen:"open.v1"` + NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` + SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` + VersionId int32 `protobuf:"varint,3,opt,name=version_id,json=versionId,proto3" json:"version_id,omitempty"` + Fields []string `protobuf:"bytes,4,rep,name=fields,proto3" json:"fields,omitempty"` + Types []string `protobuf:"bytes,5,rep,name=types,proto3" json:"types,omitempty"` + Path string `protobuf:"bytes,6,opt,name=path,proto3" json:"path,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SearchHits) Reset() { + *x = SearchHits{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SearchHits) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SearchHits) ProtoMessage() {} + +func (x *SearchHits) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[34] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SearchHits.ProtoReflect.Descriptor instead. +func (*SearchHits) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{34} +} + +func (x *SearchHits) GetNamespaceId() string { + if x != nil { + return x.NamespaceId + } + return "" +} + +func (x *SearchHits) GetSchemaId() string { + if x != nil { + return x.SchemaId + } + return "" +} + +func (x *SearchHits) GetVersionId() int32 { + if x != nil { + return x.VersionId + } + return 0 +} + +func (x *SearchHits) GetFields() []string { + if x != nil { + return x.Fields + } + return nil +} + +func (x *SearchHits) GetTypes() []string { + if x != nil { + return x.Types + } + return nil +} + +func (x *SearchHits) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +type SearchMeta struct { + state protoimpl.MessageState `protogen:"open.v1"` + Total uint32 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SearchMeta) Reset() { + *x = SearchMeta{} + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[35] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SearchMeta) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SearchMeta) ProtoMessage() {} + +func (x *SearchMeta) ProtoReflect() protoreflect.Message { + mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[35] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SearchMeta.ProtoReflect.Descriptor instead. +func (*SearchMeta) Descriptor() ([]byte, []int) { + return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{35} +} + +func (x *SearchMeta) GetTotal() uint32 { + if x != nil { + return x.Total + } + return 0 +} + +var File_raystack_stencil_v1beta1_stencil_proto protoreflect.FileDescriptor + +const file_raystack_stencil_v1beta1_stencil_proto_rawDesc = "" + + "\n" + + "&raystack/stencil/v1beta1/stencil.proto\x12\x18raystack.stencil.v1beta1\x1a\x1bbuf/validate/validate.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xca\x02\n" + + "\tNamespace\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12?\n" + + "\x06format\x18\x02 \x01(\x0e2'.raystack.stencil.v1beta1.Schema.FormatR\x06format\x12T\n" + + "\rcompatibility\x18\x03 \x01(\x0e2..raystack.stencil.v1beta1.Schema.CompatibilityR\rcompatibility\x12 \n" + + "\vdescription\x18\x04 \x01(\tR\vdescription\x129\n" + + "\n" + + "created_at\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\tcreatedAt\x129\n" + + "\n" + + "updated_at\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\tupdatedAt\"\x90\x05\n" + + "\x06Schema\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12?\n" + + "\x06format\x18\x02 \x01(\x0e2'.raystack.stencil.v1beta1.Schema.FormatR\x06format\x12\x1c\n" + + "\tauthority\x18\x03 \x01(\tR\tauthority\x12T\n" + + "\rcompatibility\x18\x04 \x01(\x0e2..raystack.stencil.v1beta1.Schema.CompatibilityR\rcompatibility\x129\n" + + "\n" + + "created_at\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\tcreatedAt\x129\n" + + "\n" + + "updated_at\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\tupdatedAt\"W\n" + + "\x06Format\x12\x16\n" + + "\x12FORMAT_UNSPECIFIED\x10\x00\x12\x13\n" + + "\x0fFORMAT_PROTOBUF\x10\x01\x12\x0f\n" + + "\vFORMAT_AVRO\x10\x02\x12\x0f\n" + + "\vFORMAT_JSON\x10\x03\"\xed\x01\n" + + "\rCompatibility\x12\x1d\n" + + "\x19COMPATIBILITY_UNSPECIFIED\x10\x00\x12\x1a\n" + + "\x16COMPATIBILITY_BACKWARD\x10\x01\x12%\n" + + "!COMPATIBILITY_BACKWARD_TRANSITIVE\x10\x02\x12\x19\n" + + "\x15COMPATIBILITY_FORWARD\x10\x03\x12$\n" + + " COMPATIBILITY_FORWARD_TRANSITIVE\x10\x04\x12\x16\n" + + "\x12COMPATIBILITY_FULL\x10\x05\x12!\n" + + "\x1dCOMPATIBILITY_FULL_TRANSITIVE\x10\x06\"\x17\n" + + "\x15ListNamespacesRequest\"]\n" + + "\x16ListNamespacesResponse\x12C\n" + + "\n" + + "namespaces\x18\x01 \x03(\v2#.raystack.stencil.v1beta1.NamespaceR\n" + + "namespaces\"%\n" + + "\x13GetNamespaceRequest\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\"Y\n" + + "\x14GetNamespaceResponse\x12A\n" + + "\tnamespace\x18\x01 \x01(\v2#.raystack.stencil.v1beta1.NamespaceR\tnamespace\"\x82\x02\n" + + "\x16CreateNamespaceRequest\x12\x17\n" + + "\x02id\x18\x01 \x01(\tB\a\xbaH\x04r\x02\x10\x01R\x02id\x12K\n" + + "\x06format\x18\x02 \x01(\x0e2'.raystack.stencil.v1beta1.Schema.FormatB\n" + + "\xbaH\a\x82\x01\x04\x10\x01 \x00R\x06format\x12`\n" + + "\rcompatibility\x18\x03 \x01(\x0e2..raystack.stencil.v1beta1.Schema.CompatibilityB\n" + + "\xbaH\a\x82\x01\x04\x10\x01 \x00R\rcompatibility\x12 \n" + + "\vdescription\x18\x04 \x01(\tR\vdescription\"\\\n" + + "\x17CreateNamespaceResponse\x12A\n" + + "\tnamespace\x18\x01 \x01(\v2#.raystack.stencil.v1beta1.NamespaceR\tnamespace\"\xf9\x01\n" + + "\x16UpdateNamespaceRequest\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12K\n" + + "\x06format\x18\x02 \x01(\x0e2'.raystack.stencil.v1beta1.Schema.FormatB\n" + + "\xbaH\a\x82\x01\x04\x10\x01 \x00R\x06format\x12`\n" + + "\rcompatibility\x18\x03 \x01(\x0e2..raystack.stencil.v1beta1.Schema.CompatibilityB\n" + + "\xbaH\a\x82\x01\x04\x10\x01 \x00R\rcompatibility\x12 \n" + + "\vdescription\x18\x04 \x01(\tR\vdescription\"\\\n" + + "\x17UpdateNamespaceResponse\x12A\n" + + "\tnamespace\x18\x01 \x01(\v2#.raystack.stencil.v1beta1.NamespaceR\tnamespace\"(\n" + + "\x16DeleteNamespaceRequest\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\"3\n" + + "\x17DeleteNamespaceResponse\x12\x18\n" + + "\amessage\x18\x01 \x01(\tR\amessage\"$\n" + + "\x12ListSchemasRequest\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\"Q\n" + + "\x13ListSchemasResponse\x12:\n" + + "\aschemas\x18\x01 \x03(\v2 .raystack.stencil.v1beta1.SchemaR\aschemas\"X\n" + + "\x16GetLatestSchemaRequest\x12!\n" + + "\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12\x1b\n" + + "\tschema_id\x18\x02 \x01(\tR\bschemaId\"-\n" + + "\x17GetLatestSchemaResponse\x12\x12\n" + + "\x04data\x18\x03 \x01(\fR\x04data\"\x89\x02\n" + + "\x13CreateSchemaRequest\x12!\n" + + "\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12\x1b\n" + + "\tschema_id\x18\x02 \x01(\tR\bschemaId\x12\x1b\n" + + "\x04data\x18\x03 \x01(\fB\a\xbaH\x04z\x02\x10\x01R\x04data\x12?\n" + + "\x06format\x18\x04 \x01(\x0e2'.raystack.stencil.v1beta1.Schema.FormatR\x06format\x12T\n" + + "\rcompatibility\x18\x05 \x01(\x0e2..raystack.stencil.v1beta1.Schema.CompatibilityR\rcompatibility\"\\\n" + + "\x14CreateSchemaResponse\x12\x18\n" + + "\aversion\x18\x01 \x01(\x05R\aversion\x12\x0e\n" + + "\x02id\x18\x02 \x01(\tR\x02id\x12\x1a\n" + + "\blocation\x18\x03 \x01(\tR\blocation\"\xce\x01\n" + + "\x19CheckCompatibilityRequest\x12!\n" + + "\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12\x1b\n" + + "\tschema_id\x18\x02 \x01(\tR\bschemaId\x12\x1b\n" + + "\x04data\x18\x03 \x01(\fB\a\xbaH\x04z\x02\x10\x01R\x04data\x12T\n" + + "\rcompatibility\x18\x04 \x01(\x0e2..raystack.stencil.v1beta1.Schema.CompatibilityR\rcompatibility\"\x1c\n" + + "\x1aCheckCompatibilityResponse\"Z\n" + + "\x18GetSchemaMetadataRequest\x12!\n" + + "\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12\x1b\n" + + "\tschema_id\x18\x02 \x01(\tR\bschemaId\"\xda\x02\n" + + "\x19GetSchemaMetadataResponse\x12?\n" + + "\x06format\x18\x01 \x01(\x0e2'.raystack.stencil.v1beta1.Schema.FormatR\x06format\x12T\n" + + "\rcompatibility\x18\x02 \x01(\x0e2..raystack.stencil.v1beta1.Schema.CompatibilityR\rcompatibility\x12\x1c\n" + + "\tauthority\x18\x03 \x01(\tR\tauthority\x12\x12\n" + + "\x04name\x18\x04 \x01(\tR\x04name\x129\n" + + "\n" + + "created_at\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\tcreatedAt\x129\n" + + "\n" + + "updated_at\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\tupdatedAt\"\xb3\x01\n" + + "\x1bUpdateSchemaMetadataRequest\x12!\n" + + "\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12\x1b\n" + + "\tschema_id\x18\x02 \x01(\tR\bschemaId\x12T\n" + + "\rcompatibility\x18\x03 \x01(\x0e2..raystack.stencil.v1beta1.Schema.CompatibilityR\rcompatibility\"\xd3\x01\n" + + "\x1cUpdateSchemaMetadataResponse\x12?\n" + + "\x06format\x18\x01 \x01(\x0e2'.raystack.stencil.v1beta1.Schema.FormatR\x06format\x12T\n" + + "\rcompatibility\x18\x02 \x01(\x0e2..raystack.stencil.v1beta1.Schema.CompatibilityR\rcompatibility\x12\x1c\n" + + "\tauthority\x18\x03 \x01(\tR\tauthority\"U\n" + + "\x13DeleteSchemaRequest\x12!\n" + + "\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12\x1b\n" + + "\tschema_id\x18\x02 \x01(\tR\bschemaId\"0\n" + + "\x14DeleteSchemaResponse\x12\x18\n" + + "\amessage\x18\x01 \x01(\tR\amessage\"U\n" + + "\x13ListVersionsRequest\x12!\n" + + "\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12\x1b\n" + + "\tschema_id\x18\x02 \x01(\tR\bschemaId\"2\n" + + "\x14ListVersionsResponse\x12\x1a\n" + + "\bversions\x18\x01 \x03(\x05R\bversions\"q\n" + + "\x10GetSchemaRequest\x12!\n" + + "\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12\x1b\n" + + "\tschema_id\x18\x02 \x01(\tR\bschemaId\x12\x1d\n" + + "\n" + + "version_id\x18\x03 \x01(\x05R\tversionId\"'\n" + + "\x11GetSchemaResponse\x12\x12\n" + + "\x04data\x18\x01 \x01(\fR\x04data\"u\n" + + "\x14DeleteVersionRequest\x12!\n" + + "\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12\x1b\n" + + "\tschema_id\x18\x02 \x01(\tR\bschemaId\x12\x1d\n" + + "\n" + + "version_id\x18\x03 \x01(\x05R\tversionId\"1\n" + + "\x15DeleteVersionResponse\x12\x18\n" + + "\amessage\x18\x01 \x01(\tR\amessage\"\xb6\x01\n" + + "\rSearchRequest\x12!\n" + + "\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12\x1b\n" + + "\tschema_id\x18\x02 \x01(\tR\bschemaId\x12\x1d\n" + + "\x05query\x18\x03 \x01(\tB\a\xbaH\x04r\x02\x10\x01R\x05query\x12\x1a\n" + + "\ahistory\x18\x04 \x01(\bH\x00R\ahistory\x12\x1f\n" + + "\n" + + "version_id\x18\x05 \x01(\x05H\x00R\tversionIdB\t\n" + + "\aversion\"\x84\x01\n" + + "\x0eSearchResponse\x128\n" + + "\x04hits\x18\x01 \x03(\v2$.raystack.stencil.v1beta1.SearchHitsR\x04hits\x128\n" + + "\x04meta\x18\x02 \x01(\v2$.raystack.stencil.v1beta1.SearchMetaR\x04meta\"\xad\x01\n" + + "\n" + + "SearchHits\x12!\n" + + "\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12\x1b\n" + + "\tschema_id\x18\x02 \x01(\tR\bschemaId\x12\x1d\n" + + "\n" + + "version_id\x18\x03 \x01(\x05R\tversionId\x12\x16\n" + + "\x06fields\x18\x04 \x03(\tR\x06fields\x12\x14\n" + + "\x05types\x18\x05 \x03(\tR\x05types\x12\x12\n" + + "\x04path\x18\x06 \x01(\tR\x04path\"\"\n" + + "\n" + + "SearchMeta\x12\x14\n" + + "\x05total\x18\x01 \x01(\rR\x05total2\xea\x0e\n" + + "\x0eStencilService\x12u\n" + + "\x0eListNamespaces\x12/.raystack.stencil.v1beta1.ListNamespacesRequest\x1a0.raystack.stencil.v1beta1.ListNamespacesResponse\"\x00\x12o\n" + + "\fGetNamespace\x12-.raystack.stencil.v1beta1.GetNamespaceRequest\x1a..raystack.stencil.v1beta1.GetNamespaceResponse\"\x00\x12x\n" + + "\x0fCreateNamespace\x120.raystack.stencil.v1beta1.CreateNamespaceRequest\x1a1.raystack.stencil.v1beta1.CreateNamespaceResponse\"\x00\x12x\n" + + "\x0fUpdateNamespace\x120.raystack.stencil.v1beta1.UpdateNamespaceRequest\x1a1.raystack.stencil.v1beta1.UpdateNamespaceResponse\"\x00\x12x\n" + + "\x0fDeleteNamespace\x120.raystack.stencil.v1beta1.DeleteNamespaceRequest\x1a1.raystack.stencil.v1beta1.DeleteNamespaceResponse\"\x00\x12l\n" + + "\vListSchemas\x12,.raystack.stencil.v1beta1.ListSchemasRequest\x1a-.raystack.stencil.v1beta1.ListSchemasResponse\"\x00\x12o\n" + + "\fCreateSchema\x12-.raystack.stencil.v1beta1.CreateSchemaRequest\x1a..raystack.stencil.v1beta1.CreateSchemaResponse\"\x00\x12\x81\x01\n" + + "\x12CheckCompatibility\x123.raystack.stencil.v1beta1.CheckCompatibilityRequest\x1a4.raystack.stencil.v1beta1.CheckCompatibilityResponse\"\x00\x12~\n" + + "\x11GetSchemaMetadata\x122.raystack.stencil.v1beta1.GetSchemaMetadataRequest\x1a3.raystack.stencil.v1beta1.GetSchemaMetadataResponse\"\x00\x12\x87\x01\n" + + "\x14UpdateSchemaMetadata\x125.raystack.stencil.v1beta1.UpdateSchemaMetadataRequest\x1a6.raystack.stencil.v1beta1.UpdateSchemaMetadataResponse\"\x00\x12x\n" + + "\x0fGetLatestSchema\x120.raystack.stencil.v1beta1.GetLatestSchemaRequest\x1a1.raystack.stencil.v1beta1.GetLatestSchemaResponse\"\x00\x12o\n" + + "\fDeleteSchema\x12-.raystack.stencil.v1beta1.DeleteSchemaRequest\x1a..raystack.stencil.v1beta1.DeleteSchemaResponse\"\x00\x12f\n" + + "\tGetSchema\x12*.raystack.stencil.v1beta1.GetSchemaRequest\x1a+.raystack.stencil.v1beta1.GetSchemaResponse\"\x00\x12o\n" + + "\fListVersions\x12-.raystack.stencil.v1beta1.ListVersionsRequest\x1a..raystack.stencil.v1beta1.ListVersionsResponse\"\x00\x12r\n" + + "\rDeleteVersion\x12..raystack.stencil.v1beta1.DeleteVersionRequest\x1a/.raystack.stencil.v1beta1.DeleteVersionResponse\"\x00\x12]\n" + + "\x06Search\x12'.raystack.stencil.v1beta1.SearchRequest\x1a(.raystack.stencil.v1beta1.SearchResponse\"\x00B\xf7\x01\n" + + "\x1ccom.raystack.stencil.v1beta1B\fStencilProtoP\x01ZGgithub.com/raystack/stencil/gen/raystack/stencil/v1beta1;stencilv1beta1\xa2\x02\x03RSX\xaa\x02\x18Raystack.Stencil.V1beta1\xca\x02\x18Raystack\\Stencil\\V1beta1\xe2\x02$Raystack\\Stencil\\V1beta1\\GPBMetadata\xea\x02\x1aRaystack::Stencil::V1beta1b\x06proto3" + +var ( + file_raystack_stencil_v1beta1_stencil_proto_rawDescOnce sync.Once + file_raystack_stencil_v1beta1_stencil_proto_rawDescData []byte +) + +func file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP() []byte { + file_raystack_stencil_v1beta1_stencil_proto_rawDescOnce.Do(func() { + file_raystack_stencil_v1beta1_stencil_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_raystack_stencil_v1beta1_stencil_proto_rawDesc), len(file_raystack_stencil_v1beta1_stencil_proto_rawDesc))) + }) + return file_raystack_stencil_v1beta1_stencil_proto_rawDescData +} + +var file_raystack_stencil_v1beta1_stencil_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_raystack_stencil_v1beta1_stencil_proto_msgTypes = make([]protoimpl.MessageInfo, 36) +var file_raystack_stencil_v1beta1_stencil_proto_goTypes = []any{ + (Schema_Format)(0), // 0: raystack.stencil.v1beta1.Schema.Format + (Schema_Compatibility)(0), // 1: raystack.stencil.v1beta1.Schema.Compatibility + (*Namespace)(nil), // 2: raystack.stencil.v1beta1.Namespace + (*Schema)(nil), // 3: raystack.stencil.v1beta1.Schema + (*ListNamespacesRequest)(nil), // 4: raystack.stencil.v1beta1.ListNamespacesRequest + (*ListNamespacesResponse)(nil), // 5: raystack.stencil.v1beta1.ListNamespacesResponse + (*GetNamespaceRequest)(nil), // 6: raystack.stencil.v1beta1.GetNamespaceRequest + (*GetNamespaceResponse)(nil), // 7: raystack.stencil.v1beta1.GetNamespaceResponse + (*CreateNamespaceRequest)(nil), // 8: raystack.stencil.v1beta1.CreateNamespaceRequest + (*CreateNamespaceResponse)(nil), // 9: raystack.stencil.v1beta1.CreateNamespaceResponse + (*UpdateNamespaceRequest)(nil), // 10: raystack.stencil.v1beta1.UpdateNamespaceRequest + (*UpdateNamespaceResponse)(nil), // 11: raystack.stencil.v1beta1.UpdateNamespaceResponse + (*DeleteNamespaceRequest)(nil), // 12: raystack.stencil.v1beta1.DeleteNamespaceRequest + (*DeleteNamespaceResponse)(nil), // 13: raystack.stencil.v1beta1.DeleteNamespaceResponse + (*ListSchemasRequest)(nil), // 14: raystack.stencil.v1beta1.ListSchemasRequest + (*ListSchemasResponse)(nil), // 15: raystack.stencil.v1beta1.ListSchemasResponse + (*GetLatestSchemaRequest)(nil), // 16: raystack.stencil.v1beta1.GetLatestSchemaRequest + (*GetLatestSchemaResponse)(nil), // 17: raystack.stencil.v1beta1.GetLatestSchemaResponse + (*CreateSchemaRequest)(nil), // 18: raystack.stencil.v1beta1.CreateSchemaRequest + (*CreateSchemaResponse)(nil), // 19: raystack.stencil.v1beta1.CreateSchemaResponse + (*CheckCompatibilityRequest)(nil), // 20: raystack.stencil.v1beta1.CheckCompatibilityRequest + (*CheckCompatibilityResponse)(nil), // 21: raystack.stencil.v1beta1.CheckCompatibilityResponse + (*GetSchemaMetadataRequest)(nil), // 22: raystack.stencil.v1beta1.GetSchemaMetadataRequest + (*GetSchemaMetadataResponse)(nil), // 23: raystack.stencil.v1beta1.GetSchemaMetadataResponse + (*UpdateSchemaMetadataRequest)(nil), // 24: raystack.stencil.v1beta1.UpdateSchemaMetadataRequest + (*UpdateSchemaMetadataResponse)(nil), // 25: raystack.stencil.v1beta1.UpdateSchemaMetadataResponse + (*DeleteSchemaRequest)(nil), // 26: raystack.stencil.v1beta1.DeleteSchemaRequest + (*DeleteSchemaResponse)(nil), // 27: raystack.stencil.v1beta1.DeleteSchemaResponse + (*ListVersionsRequest)(nil), // 28: raystack.stencil.v1beta1.ListVersionsRequest + (*ListVersionsResponse)(nil), // 29: raystack.stencil.v1beta1.ListVersionsResponse + (*GetSchemaRequest)(nil), // 30: raystack.stencil.v1beta1.GetSchemaRequest + (*GetSchemaResponse)(nil), // 31: raystack.stencil.v1beta1.GetSchemaResponse + (*DeleteVersionRequest)(nil), // 32: raystack.stencil.v1beta1.DeleteVersionRequest + (*DeleteVersionResponse)(nil), // 33: raystack.stencil.v1beta1.DeleteVersionResponse + (*SearchRequest)(nil), // 34: raystack.stencil.v1beta1.SearchRequest + (*SearchResponse)(nil), // 35: raystack.stencil.v1beta1.SearchResponse + (*SearchHits)(nil), // 36: raystack.stencil.v1beta1.SearchHits + (*SearchMeta)(nil), // 37: raystack.stencil.v1beta1.SearchMeta + (*timestamppb.Timestamp)(nil), // 38: google.protobuf.Timestamp +} +var file_raystack_stencil_v1beta1_stencil_proto_depIdxs = []int32{ + 0, // 0: raystack.stencil.v1beta1.Namespace.format:type_name -> raystack.stencil.v1beta1.Schema.Format + 1, // 1: raystack.stencil.v1beta1.Namespace.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility + 38, // 2: raystack.stencil.v1beta1.Namespace.created_at:type_name -> google.protobuf.Timestamp + 38, // 3: raystack.stencil.v1beta1.Namespace.updated_at:type_name -> google.protobuf.Timestamp + 0, // 4: raystack.stencil.v1beta1.Schema.format:type_name -> raystack.stencil.v1beta1.Schema.Format + 1, // 5: raystack.stencil.v1beta1.Schema.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility + 38, // 6: raystack.stencil.v1beta1.Schema.created_at:type_name -> google.protobuf.Timestamp + 38, // 7: raystack.stencil.v1beta1.Schema.updated_at:type_name -> google.protobuf.Timestamp + 2, // 8: raystack.stencil.v1beta1.ListNamespacesResponse.namespaces:type_name -> raystack.stencil.v1beta1.Namespace + 2, // 9: raystack.stencil.v1beta1.GetNamespaceResponse.namespace:type_name -> raystack.stencil.v1beta1.Namespace + 0, // 10: raystack.stencil.v1beta1.CreateNamespaceRequest.format:type_name -> raystack.stencil.v1beta1.Schema.Format + 1, // 11: raystack.stencil.v1beta1.CreateNamespaceRequest.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility + 2, // 12: raystack.stencil.v1beta1.CreateNamespaceResponse.namespace:type_name -> raystack.stencil.v1beta1.Namespace + 0, // 13: raystack.stencil.v1beta1.UpdateNamespaceRequest.format:type_name -> raystack.stencil.v1beta1.Schema.Format + 1, // 14: raystack.stencil.v1beta1.UpdateNamespaceRequest.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility + 2, // 15: raystack.stencil.v1beta1.UpdateNamespaceResponse.namespace:type_name -> raystack.stencil.v1beta1.Namespace + 3, // 16: raystack.stencil.v1beta1.ListSchemasResponse.schemas:type_name -> raystack.stencil.v1beta1.Schema + 0, // 17: raystack.stencil.v1beta1.CreateSchemaRequest.format:type_name -> raystack.stencil.v1beta1.Schema.Format + 1, // 18: raystack.stencil.v1beta1.CreateSchemaRequest.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility + 1, // 19: raystack.stencil.v1beta1.CheckCompatibilityRequest.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility + 0, // 20: raystack.stencil.v1beta1.GetSchemaMetadataResponse.format:type_name -> raystack.stencil.v1beta1.Schema.Format + 1, // 21: raystack.stencil.v1beta1.GetSchemaMetadataResponse.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility + 38, // 22: raystack.stencil.v1beta1.GetSchemaMetadataResponse.created_at:type_name -> google.protobuf.Timestamp + 38, // 23: raystack.stencil.v1beta1.GetSchemaMetadataResponse.updated_at:type_name -> google.protobuf.Timestamp + 1, // 24: raystack.stencil.v1beta1.UpdateSchemaMetadataRequest.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility + 0, // 25: raystack.stencil.v1beta1.UpdateSchemaMetadataResponse.format:type_name -> raystack.stencil.v1beta1.Schema.Format + 1, // 26: raystack.stencil.v1beta1.UpdateSchemaMetadataResponse.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility + 36, // 27: raystack.stencil.v1beta1.SearchResponse.hits:type_name -> raystack.stencil.v1beta1.SearchHits + 37, // 28: raystack.stencil.v1beta1.SearchResponse.meta:type_name -> raystack.stencil.v1beta1.SearchMeta + 4, // 29: raystack.stencil.v1beta1.StencilService.ListNamespaces:input_type -> raystack.stencil.v1beta1.ListNamespacesRequest + 6, // 30: raystack.stencil.v1beta1.StencilService.GetNamespace:input_type -> raystack.stencil.v1beta1.GetNamespaceRequest + 8, // 31: raystack.stencil.v1beta1.StencilService.CreateNamespace:input_type -> raystack.stencil.v1beta1.CreateNamespaceRequest + 10, // 32: raystack.stencil.v1beta1.StencilService.UpdateNamespace:input_type -> raystack.stencil.v1beta1.UpdateNamespaceRequest + 12, // 33: raystack.stencil.v1beta1.StencilService.DeleteNamespace:input_type -> raystack.stencil.v1beta1.DeleteNamespaceRequest + 14, // 34: raystack.stencil.v1beta1.StencilService.ListSchemas:input_type -> raystack.stencil.v1beta1.ListSchemasRequest + 18, // 35: raystack.stencil.v1beta1.StencilService.CreateSchema:input_type -> raystack.stencil.v1beta1.CreateSchemaRequest + 20, // 36: raystack.stencil.v1beta1.StencilService.CheckCompatibility:input_type -> raystack.stencil.v1beta1.CheckCompatibilityRequest + 22, // 37: raystack.stencil.v1beta1.StencilService.GetSchemaMetadata:input_type -> raystack.stencil.v1beta1.GetSchemaMetadataRequest + 24, // 38: raystack.stencil.v1beta1.StencilService.UpdateSchemaMetadata:input_type -> raystack.stencil.v1beta1.UpdateSchemaMetadataRequest + 16, // 39: raystack.stencil.v1beta1.StencilService.GetLatestSchema:input_type -> raystack.stencil.v1beta1.GetLatestSchemaRequest + 26, // 40: raystack.stencil.v1beta1.StencilService.DeleteSchema:input_type -> raystack.stencil.v1beta1.DeleteSchemaRequest + 30, // 41: raystack.stencil.v1beta1.StencilService.GetSchema:input_type -> raystack.stencil.v1beta1.GetSchemaRequest + 28, // 42: raystack.stencil.v1beta1.StencilService.ListVersions:input_type -> raystack.stencil.v1beta1.ListVersionsRequest + 32, // 43: raystack.stencil.v1beta1.StencilService.DeleteVersion:input_type -> raystack.stencil.v1beta1.DeleteVersionRequest + 34, // 44: raystack.stencil.v1beta1.StencilService.Search:input_type -> raystack.stencil.v1beta1.SearchRequest + 5, // 45: raystack.stencil.v1beta1.StencilService.ListNamespaces:output_type -> raystack.stencil.v1beta1.ListNamespacesResponse + 7, // 46: raystack.stencil.v1beta1.StencilService.GetNamespace:output_type -> raystack.stencil.v1beta1.GetNamespaceResponse + 9, // 47: raystack.stencil.v1beta1.StencilService.CreateNamespace:output_type -> raystack.stencil.v1beta1.CreateNamespaceResponse + 11, // 48: raystack.stencil.v1beta1.StencilService.UpdateNamespace:output_type -> raystack.stencil.v1beta1.UpdateNamespaceResponse + 13, // 49: raystack.stencil.v1beta1.StencilService.DeleteNamespace:output_type -> raystack.stencil.v1beta1.DeleteNamespaceResponse + 15, // 50: raystack.stencil.v1beta1.StencilService.ListSchemas:output_type -> raystack.stencil.v1beta1.ListSchemasResponse + 19, // 51: raystack.stencil.v1beta1.StencilService.CreateSchema:output_type -> raystack.stencil.v1beta1.CreateSchemaResponse + 21, // 52: raystack.stencil.v1beta1.StencilService.CheckCompatibility:output_type -> raystack.stencil.v1beta1.CheckCompatibilityResponse + 23, // 53: raystack.stencil.v1beta1.StencilService.GetSchemaMetadata:output_type -> raystack.stencil.v1beta1.GetSchemaMetadataResponse + 25, // 54: raystack.stencil.v1beta1.StencilService.UpdateSchemaMetadata:output_type -> raystack.stencil.v1beta1.UpdateSchemaMetadataResponse + 17, // 55: raystack.stencil.v1beta1.StencilService.GetLatestSchema:output_type -> raystack.stencil.v1beta1.GetLatestSchemaResponse + 27, // 56: raystack.stencil.v1beta1.StencilService.DeleteSchema:output_type -> raystack.stencil.v1beta1.DeleteSchemaResponse + 31, // 57: raystack.stencil.v1beta1.StencilService.GetSchema:output_type -> raystack.stencil.v1beta1.GetSchemaResponse + 29, // 58: raystack.stencil.v1beta1.StencilService.ListVersions:output_type -> raystack.stencil.v1beta1.ListVersionsResponse + 33, // 59: raystack.stencil.v1beta1.StencilService.DeleteVersion:output_type -> raystack.stencil.v1beta1.DeleteVersionResponse + 35, // 60: raystack.stencil.v1beta1.StencilService.Search:output_type -> raystack.stencil.v1beta1.SearchResponse + 45, // [45:61] is the sub-list for method output_type + 29, // [29:45] is the sub-list for method input_type + 29, // [29:29] is the sub-list for extension type_name + 29, // [29:29] is the sub-list for extension extendee + 0, // [0:29] is the sub-list for field type_name +} + +func init() { file_raystack_stencil_v1beta1_stencil_proto_init() } +func file_raystack_stencil_v1beta1_stencil_proto_init() { + if File_raystack_stencil_v1beta1_stencil_proto != nil { + return + } + file_raystack_stencil_v1beta1_stencil_proto_msgTypes[32].OneofWrappers = []any{ + (*SearchRequest_History)(nil), + (*SearchRequest_VersionId)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_raystack_stencil_v1beta1_stencil_proto_rawDesc), len(file_raystack_stencil_v1beta1_stencil_proto_rawDesc)), + NumEnums: 2, + NumMessages: 36, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_raystack_stencil_v1beta1_stencil_proto_goTypes, + DependencyIndexes: file_raystack_stencil_v1beta1_stencil_proto_depIdxs, + EnumInfos: file_raystack_stencil_v1beta1_stencil_proto_enumTypes, + MessageInfos: file_raystack_stencil_v1beta1_stencil_proto_msgTypes, + }.Build() + File_raystack_stencil_v1beta1_stencil_proto = out.File + file_raystack_stencil_v1beta1_stencil_proto_goTypes = nil + file_raystack_stencil_v1beta1_stencil_proto_depIdxs = nil +} diff --git a/gen/raystack/stencil/v1beta1/stencilv1beta1connect/stencil.connect.go b/gen/raystack/stencil/v1beta1/stencilv1beta1connect/stencil.connect.go new file mode 100644 index 00000000..f9b52c26 --- /dev/null +++ b/gen/raystack/stencil/v1beta1/stencilv1beta1connect/stencil.connect.go @@ -0,0 +1,544 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: raystack/stencil/v1beta1/stencil.proto + +package stencilv1beta1connect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + v1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // StencilServiceName is the fully-qualified name of the StencilService service. + StencilServiceName = "raystack.stencil.v1beta1.StencilService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // StencilServiceListNamespacesProcedure is the fully-qualified name of the StencilService's + // ListNamespaces RPC. + StencilServiceListNamespacesProcedure = "/raystack.stencil.v1beta1.StencilService/ListNamespaces" + // StencilServiceGetNamespaceProcedure is the fully-qualified name of the StencilService's + // GetNamespace RPC. + StencilServiceGetNamespaceProcedure = "/raystack.stencil.v1beta1.StencilService/GetNamespace" + // StencilServiceCreateNamespaceProcedure is the fully-qualified name of the StencilService's + // CreateNamespace RPC. + StencilServiceCreateNamespaceProcedure = "/raystack.stencil.v1beta1.StencilService/CreateNamespace" + // StencilServiceUpdateNamespaceProcedure is the fully-qualified name of the StencilService's + // UpdateNamespace RPC. + StencilServiceUpdateNamespaceProcedure = "/raystack.stencil.v1beta1.StencilService/UpdateNamespace" + // StencilServiceDeleteNamespaceProcedure is the fully-qualified name of the StencilService's + // DeleteNamespace RPC. + StencilServiceDeleteNamespaceProcedure = "/raystack.stencil.v1beta1.StencilService/DeleteNamespace" + // StencilServiceListSchemasProcedure is the fully-qualified name of the StencilService's + // ListSchemas RPC. + StencilServiceListSchemasProcedure = "/raystack.stencil.v1beta1.StencilService/ListSchemas" + // StencilServiceCreateSchemaProcedure is the fully-qualified name of the StencilService's + // CreateSchema RPC. + StencilServiceCreateSchemaProcedure = "/raystack.stencil.v1beta1.StencilService/CreateSchema" + // StencilServiceCheckCompatibilityProcedure is the fully-qualified name of the StencilService's + // CheckCompatibility RPC. + StencilServiceCheckCompatibilityProcedure = "/raystack.stencil.v1beta1.StencilService/CheckCompatibility" + // StencilServiceGetSchemaMetadataProcedure is the fully-qualified name of the StencilService's + // GetSchemaMetadata RPC. + StencilServiceGetSchemaMetadataProcedure = "/raystack.stencil.v1beta1.StencilService/GetSchemaMetadata" + // StencilServiceUpdateSchemaMetadataProcedure is the fully-qualified name of the StencilService's + // UpdateSchemaMetadata RPC. + StencilServiceUpdateSchemaMetadataProcedure = "/raystack.stencil.v1beta1.StencilService/UpdateSchemaMetadata" + // StencilServiceGetLatestSchemaProcedure is the fully-qualified name of the StencilService's + // GetLatestSchema RPC. + StencilServiceGetLatestSchemaProcedure = "/raystack.stencil.v1beta1.StencilService/GetLatestSchema" + // StencilServiceDeleteSchemaProcedure is the fully-qualified name of the StencilService's + // DeleteSchema RPC. + StencilServiceDeleteSchemaProcedure = "/raystack.stencil.v1beta1.StencilService/DeleteSchema" + // StencilServiceGetSchemaProcedure is the fully-qualified name of the StencilService's GetSchema + // RPC. + StencilServiceGetSchemaProcedure = "/raystack.stencil.v1beta1.StencilService/GetSchema" + // StencilServiceListVersionsProcedure is the fully-qualified name of the StencilService's + // ListVersions RPC. + StencilServiceListVersionsProcedure = "/raystack.stencil.v1beta1.StencilService/ListVersions" + // StencilServiceDeleteVersionProcedure is the fully-qualified name of the StencilService's + // DeleteVersion RPC. + StencilServiceDeleteVersionProcedure = "/raystack.stencil.v1beta1.StencilService/DeleteVersion" + // StencilServiceSearchProcedure is the fully-qualified name of the StencilService's Search RPC. + StencilServiceSearchProcedure = "/raystack.stencil.v1beta1.StencilService/Search" +) + +// StencilServiceClient is a client for the raystack.stencil.v1beta1.StencilService service. +type StencilServiceClient interface { + ListNamespaces(context.Context, *connect.Request[v1beta1.ListNamespacesRequest]) (*connect.Response[v1beta1.ListNamespacesResponse], error) + GetNamespace(context.Context, *connect.Request[v1beta1.GetNamespaceRequest]) (*connect.Response[v1beta1.GetNamespaceResponse], error) + CreateNamespace(context.Context, *connect.Request[v1beta1.CreateNamespaceRequest]) (*connect.Response[v1beta1.CreateNamespaceResponse], error) + UpdateNamespace(context.Context, *connect.Request[v1beta1.UpdateNamespaceRequest]) (*connect.Response[v1beta1.UpdateNamespaceResponse], error) + DeleteNamespace(context.Context, *connect.Request[v1beta1.DeleteNamespaceRequest]) (*connect.Response[v1beta1.DeleteNamespaceResponse], error) + ListSchemas(context.Context, *connect.Request[v1beta1.ListSchemasRequest]) (*connect.Response[v1beta1.ListSchemasResponse], error) + CreateSchema(context.Context, *connect.Request[v1beta1.CreateSchemaRequest]) (*connect.Response[v1beta1.CreateSchemaResponse], error) + CheckCompatibility(context.Context, *connect.Request[v1beta1.CheckCompatibilityRequest]) (*connect.Response[v1beta1.CheckCompatibilityResponse], error) + GetSchemaMetadata(context.Context, *connect.Request[v1beta1.GetSchemaMetadataRequest]) (*connect.Response[v1beta1.GetSchemaMetadataResponse], error) + UpdateSchemaMetadata(context.Context, *connect.Request[v1beta1.UpdateSchemaMetadataRequest]) (*connect.Response[v1beta1.UpdateSchemaMetadataResponse], error) + GetLatestSchema(context.Context, *connect.Request[v1beta1.GetLatestSchemaRequest]) (*connect.Response[v1beta1.GetLatestSchemaResponse], error) + DeleteSchema(context.Context, *connect.Request[v1beta1.DeleteSchemaRequest]) (*connect.Response[v1beta1.DeleteSchemaResponse], error) + GetSchema(context.Context, *connect.Request[v1beta1.GetSchemaRequest]) (*connect.Response[v1beta1.GetSchemaResponse], error) + ListVersions(context.Context, *connect.Request[v1beta1.ListVersionsRequest]) (*connect.Response[v1beta1.ListVersionsResponse], error) + DeleteVersion(context.Context, *connect.Request[v1beta1.DeleteVersionRequest]) (*connect.Response[v1beta1.DeleteVersionResponse], error) + Search(context.Context, *connect.Request[v1beta1.SearchRequest]) (*connect.Response[v1beta1.SearchResponse], error) +} + +// NewStencilServiceClient constructs a client for the raystack.stencil.v1beta1.StencilService +// service. By default, it uses the Connect protocol with the binary Protobuf Codec, asks for +// gzipped responses, and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply +// the connect.WithGRPC() or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewStencilServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) StencilServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + stencilServiceMethods := v1beta1.File_raystack_stencil_v1beta1_stencil_proto.Services().ByName("StencilService").Methods() + return &stencilServiceClient{ + listNamespaces: connect.NewClient[v1beta1.ListNamespacesRequest, v1beta1.ListNamespacesResponse]( + httpClient, + baseURL+StencilServiceListNamespacesProcedure, + connect.WithSchema(stencilServiceMethods.ByName("ListNamespaces")), + connect.WithClientOptions(opts...), + ), + getNamespace: connect.NewClient[v1beta1.GetNamespaceRequest, v1beta1.GetNamespaceResponse]( + httpClient, + baseURL+StencilServiceGetNamespaceProcedure, + connect.WithSchema(stencilServiceMethods.ByName("GetNamespace")), + connect.WithClientOptions(opts...), + ), + createNamespace: connect.NewClient[v1beta1.CreateNamespaceRequest, v1beta1.CreateNamespaceResponse]( + httpClient, + baseURL+StencilServiceCreateNamespaceProcedure, + connect.WithSchema(stencilServiceMethods.ByName("CreateNamespace")), + connect.WithClientOptions(opts...), + ), + updateNamespace: connect.NewClient[v1beta1.UpdateNamespaceRequest, v1beta1.UpdateNamespaceResponse]( + httpClient, + baseURL+StencilServiceUpdateNamespaceProcedure, + connect.WithSchema(stencilServiceMethods.ByName("UpdateNamespace")), + connect.WithClientOptions(opts...), + ), + deleteNamespace: connect.NewClient[v1beta1.DeleteNamespaceRequest, v1beta1.DeleteNamespaceResponse]( + httpClient, + baseURL+StencilServiceDeleteNamespaceProcedure, + connect.WithSchema(stencilServiceMethods.ByName("DeleteNamespace")), + connect.WithClientOptions(opts...), + ), + listSchemas: connect.NewClient[v1beta1.ListSchemasRequest, v1beta1.ListSchemasResponse]( + httpClient, + baseURL+StencilServiceListSchemasProcedure, + connect.WithSchema(stencilServiceMethods.ByName("ListSchemas")), + connect.WithClientOptions(opts...), + ), + createSchema: connect.NewClient[v1beta1.CreateSchemaRequest, v1beta1.CreateSchemaResponse]( + httpClient, + baseURL+StencilServiceCreateSchemaProcedure, + connect.WithSchema(stencilServiceMethods.ByName("CreateSchema")), + connect.WithClientOptions(opts...), + ), + checkCompatibility: connect.NewClient[v1beta1.CheckCompatibilityRequest, v1beta1.CheckCompatibilityResponse]( + httpClient, + baseURL+StencilServiceCheckCompatibilityProcedure, + connect.WithSchema(stencilServiceMethods.ByName("CheckCompatibility")), + connect.WithClientOptions(opts...), + ), + getSchemaMetadata: connect.NewClient[v1beta1.GetSchemaMetadataRequest, v1beta1.GetSchemaMetadataResponse]( + httpClient, + baseURL+StencilServiceGetSchemaMetadataProcedure, + connect.WithSchema(stencilServiceMethods.ByName("GetSchemaMetadata")), + connect.WithClientOptions(opts...), + ), + updateSchemaMetadata: connect.NewClient[v1beta1.UpdateSchemaMetadataRequest, v1beta1.UpdateSchemaMetadataResponse]( + httpClient, + baseURL+StencilServiceUpdateSchemaMetadataProcedure, + connect.WithSchema(stencilServiceMethods.ByName("UpdateSchemaMetadata")), + connect.WithClientOptions(opts...), + ), + getLatestSchema: connect.NewClient[v1beta1.GetLatestSchemaRequest, v1beta1.GetLatestSchemaResponse]( + httpClient, + baseURL+StencilServiceGetLatestSchemaProcedure, + connect.WithSchema(stencilServiceMethods.ByName("GetLatestSchema")), + connect.WithClientOptions(opts...), + ), + deleteSchema: connect.NewClient[v1beta1.DeleteSchemaRequest, v1beta1.DeleteSchemaResponse]( + httpClient, + baseURL+StencilServiceDeleteSchemaProcedure, + connect.WithSchema(stencilServiceMethods.ByName("DeleteSchema")), + connect.WithClientOptions(opts...), + ), + getSchema: connect.NewClient[v1beta1.GetSchemaRequest, v1beta1.GetSchemaResponse]( + httpClient, + baseURL+StencilServiceGetSchemaProcedure, + connect.WithSchema(stencilServiceMethods.ByName("GetSchema")), + connect.WithClientOptions(opts...), + ), + listVersions: connect.NewClient[v1beta1.ListVersionsRequest, v1beta1.ListVersionsResponse]( + httpClient, + baseURL+StencilServiceListVersionsProcedure, + connect.WithSchema(stencilServiceMethods.ByName("ListVersions")), + connect.WithClientOptions(opts...), + ), + deleteVersion: connect.NewClient[v1beta1.DeleteVersionRequest, v1beta1.DeleteVersionResponse]( + httpClient, + baseURL+StencilServiceDeleteVersionProcedure, + connect.WithSchema(stencilServiceMethods.ByName("DeleteVersion")), + connect.WithClientOptions(opts...), + ), + search: connect.NewClient[v1beta1.SearchRequest, v1beta1.SearchResponse]( + httpClient, + baseURL+StencilServiceSearchProcedure, + connect.WithSchema(stencilServiceMethods.ByName("Search")), + connect.WithClientOptions(opts...), + ), + } +} + +// stencilServiceClient implements StencilServiceClient. +type stencilServiceClient struct { + listNamespaces *connect.Client[v1beta1.ListNamespacesRequest, v1beta1.ListNamespacesResponse] + getNamespace *connect.Client[v1beta1.GetNamespaceRequest, v1beta1.GetNamespaceResponse] + createNamespace *connect.Client[v1beta1.CreateNamespaceRequest, v1beta1.CreateNamespaceResponse] + updateNamespace *connect.Client[v1beta1.UpdateNamespaceRequest, v1beta1.UpdateNamespaceResponse] + deleteNamespace *connect.Client[v1beta1.DeleteNamespaceRequest, v1beta1.DeleteNamespaceResponse] + listSchemas *connect.Client[v1beta1.ListSchemasRequest, v1beta1.ListSchemasResponse] + createSchema *connect.Client[v1beta1.CreateSchemaRequest, v1beta1.CreateSchemaResponse] + checkCompatibility *connect.Client[v1beta1.CheckCompatibilityRequest, v1beta1.CheckCompatibilityResponse] + getSchemaMetadata *connect.Client[v1beta1.GetSchemaMetadataRequest, v1beta1.GetSchemaMetadataResponse] + updateSchemaMetadata *connect.Client[v1beta1.UpdateSchemaMetadataRequest, v1beta1.UpdateSchemaMetadataResponse] + getLatestSchema *connect.Client[v1beta1.GetLatestSchemaRequest, v1beta1.GetLatestSchemaResponse] + deleteSchema *connect.Client[v1beta1.DeleteSchemaRequest, v1beta1.DeleteSchemaResponse] + getSchema *connect.Client[v1beta1.GetSchemaRequest, v1beta1.GetSchemaResponse] + listVersions *connect.Client[v1beta1.ListVersionsRequest, v1beta1.ListVersionsResponse] + deleteVersion *connect.Client[v1beta1.DeleteVersionRequest, v1beta1.DeleteVersionResponse] + search *connect.Client[v1beta1.SearchRequest, v1beta1.SearchResponse] +} + +// ListNamespaces calls raystack.stencil.v1beta1.StencilService.ListNamespaces. +func (c *stencilServiceClient) ListNamespaces(ctx context.Context, req *connect.Request[v1beta1.ListNamespacesRequest]) (*connect.Response[v1beta1.ListNamespacesResponse], error) { + return c.listNamespaces.CallUnary(ctx, req) +} + +// GetNamespace calls raystack.stencil.v1beta1.StencilService.GetNamespace. +func (c *stencilServiceClient) GetNamespace(ctx context.Context, req *connect.Request[v1beta1.GetNamespaceRequest]) (*connect.Response[v1beta1.GetNamespaceResponse], error) { + return c.getNamespace.CallUnary(ctx, req) +} + +// CreateNamespace calls raystack.stencil.v1beta1.StencilService.CreateNamespace. +func (c *stencilServiceClient) CreateNamespace(ctx context.Context, req *connect.Request[v1beta1.CreateNamespaceRequest]) (*connect.Response[v1beta1.CreateNamespaceResponse], error) { + return c.createNamespace.CallUnary(ctx, req) +} + +// UpdateNamespace calls raystack.stencil.v1beta1.StencilService.UpdateNamespace. +func (c *stencilServiceClient) UpdateNamespace(ctx context.Context, req *connect.Request[v1beta1.UpdateNamespaceRequest]) (*connect.Response[v1beta1.UpdateNamespaceResponse], error) { + return c.updateNamespace.CallUnary(ctx, req) +} + +// DeleteNamespace calls raystack.stencil.v1beta1.StencilService.DeleteNamespace. +func (c *stencilServiceClient) DeleteNamespace(ctx context.Context, req *connect.Request[v1beta1.DeleteNamespaceRequest]) (*connect.Response[v1beta1.DeleteNamespaceResponse], error) { + return c.deleteNamespace.CallUnary(ctx, req) +} + +// ListSchemas calls raystack.stencil.v1beta1.StencilService.ListSchemas. +func (c *stencilServiceClient) ListSchemas(ctx context.Context, req *connect.Request[v1beta1.ListSchemasRequest]) (*connect.Response[v1beta1.ListSchemasResponse], error) { + return c.listSchemas.CallUnary(ctx, req) +} + +// CreateSchema calls raystack.stencil.v1beta1.StencilService.CreateSchema. +func (c *stencilServiceClient) CreateSchema(ctx context.Context, req *connect.Request[v1beta1.CreateSchemaRequest]) (*connect.Response[v1beta1.CreateSchemaResponse], error) { + return c.createSchema.CallUnary(ctx, req) +} + +// CheckCompatibility calls raystack.stencil.v1beta1.StencilService.CheckCompatibility. +func (c *stencilServiceClient) CheckCompatibility(ctx context.Context, req *connect.Request[v1beta1.CheckCompatibilityRequest]) (*connect.Response[v1beta1.CheckCompatibilityResponse], error) { + return c.checkCompatibility.CallUnary(ctx, req) +} + +// GetSchemaMetadata calls raystack.stencil.v1beta1.StencilService.GetSchemaMetadata. +func (c *stencilServiceClient) GetSchemaMetadata(ctx context.Context, req *connect.Request[v1beta1.GetSchemaMetadataRequest]) (*connect.Response[v1beta1.GetSchemaMetadataResponse], error) { + return c.getSchemaMetadata.CallUnary(ctx, req) +} + +// UpdateSchemaMetadata calls raystack.stencil.v1beta1.StencilService.UpdateSchemaMetadata. +func (c *stencilServiceClient) UpdateSchemaMetadata(ctx context.Context, req *connect.Request[v1beta1.UpdateSchemaMetadataRequest]) (*connect.Response[v1beta1.UpdateSchemaMetadataResponse], error) { + return c.updateSchemaMetadata.CallUnary(ctx, req) +} + +// GetLatestSchema calls raystack.stencil.v1beta1.StencilService.GetLatestSchema. +func (c *stencilServiceClient) GetLatestSchema(ctx context.Context, req *connect.Request[v1beta1.GetLatestSchemaRequest]) (*connect.Response[v1beta1.GetLatestSchemaResponse], error) { + return c.getLatestSchema.CallUnary(ctx, req) +} + +// DeleteSchema calls raystack.stencil.v1beta1.StencilService.DeleteSchema. +func (c *stencilServiceClient) DeleteSchema(ctx context.Context, req *connect.Request[v1beta1.DeleteSchemaRequest]) (*connect.Response[v1beta1.DeleteSchemaResponse], error) { + return c.deleteSchema.CallUnary(ctx, req) +} + +// GetSchema calls raystack.stencil.v1beta1.StencilService.GetSchema. +func (c *stencilServiceClient) GetSchema(ctx context.Context, req *connect.Request[v1beta1.GetSchemaRequest]) (*connect.Response[v1beta1.GetSchemaResponse], error) { + return c.getSchema.CallUnary(ctx, req) +} + +// ListVersions calls raystack.stencil.v1beta1.StencilService.ListVersions. +func (c *stencilServiceClient) ListVersions(ctx context.Context, req *connect.Request[v1beta1.ListVersionsRequest]) (*connect.Response[v1beta1.ListVersionsResponse], error) { + return c.listVersions.CallUnary(ctx, req) +} + +// DeleteVersion calls raystack.stencil.v1beta1.StencilService.DeleteVersion. +func (c *stencilServiceClient) DeleteVersion(ctx context.Context, req *connect.Request[v1beta1.DeleteVersionRequest]) (*connect.Response[v1beta1.DeleteVersionResponse], error) { + return c.deleteVersion.CallUnary(ctx, req) +} + +// Search calls raystack.stencil.v1beta1.StencilService.Search. +func (c *stencilServiceClient) Search(ctx context.Context, req *connect.Request[v1beta1.SearchRequest]) (*connect.Response[v1beta1.SearchResponse], error) { + return c.search.CallUnary(ctx, req) +} + +// StencilServiceHandler is an implementation of the raystack.stencil.v1beta1.StencilService +// service. +type StencilServiceHandler interface { + ListNamespaces(context.Context, *connect.Request[v1beta1.ListNamespacesRequest]) (*connect.Response[v1beta1.ListNamespacesResponse], error) + GetNamespace(context.Context, *connect.Request[v1beta1.GetNamespaceRequest]) (*connect.Response[v1beta1.GetNamespaceResponse], error) + CreateNamespace(context.Context, *connect.Request[v1beta1.CreateNamespaceRequest]) (*connect.Response[v1beta1.CreateNamespaceResponse], error) + UpdateNamespace(context.Context, *connect.Request[v1beta1.UpdateNamespaceRequest]) (*connect.Response[v1beta1.UpdateNamespaceResponse], error) + DeleteNamespace(context.Context, *connect.Request[v1beta1.DeleteNamespaceRequest]) (*connect.Response[v1beta1.DeleteNamespaceResponse], error) + ListSchemas(context.Context, *connect.Request[v1beta1.ListSchemasRequest]) (*connect.Response[v1beta1.ListSchemasResponse], error) + CreateSchema(context.Context, *connect.Request[v1beta1.CreateSchemaRequest]) (*connect.Response[v1beta1.CreateSchemaResponse], error) + CheckCompatibility(context.Context, *connect.Request[v1beta1.CheckCompatibilityRequest]) (*connect.Response[v1beta1.CheckCompatibilityResponse], error) + GetSchemaMetadata(context.Context, *connect.Request[v1beta1.GetSchemaMetadataRequest]) (*connect.Response[v1beta1.GetSchemaMetadataResponse], error) + UpdateSchemaMetadata(context.Context, *connect.Request[v1beta1.UpdateSchemaMetadataRequest]) (*connect.Response[v1beta1.UpdateSchemaMetadataResponse], error) + GetLatestSchema(context.Context, *connect.Request[v1beta1.GetLatestSchemaRequest]) (*connect.Response[v1beta1.GetLatestSchemaResponse], error) + DeleteSchema(context.Context, *connect.Request[v1beta1.DeleteSchemaRequest]) (*connect.Response[v1beta1.DeleteSchemaResponse], error) + GetSchema(context.Context, *connect.Request[v1beta1.GetSchemaRequest]) (*connect.Response[v1beta1.GetSchemaResponse], error) + ListVersions(context.Context, *connect.Request[v1beta1.ListVersionsRequest]) (*connect.Response[v1beta1.ListVersionsResponse], error) + DeleteVersion(context.Context, *connect.Request[v1beta1.DeleteVersionRequest]) (*connect.Response[v1beta1.DeleteVersionResponse], error) + Search(context.Context, *connect.Request[v1beta1.SearchRequest]) (*connect.Response[v1beta1.SearchResponse], error) +} + +// NewStencilServiceHandler builds an HTTP handler from the service implementation. It returns the +// path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewStencilServiceHandler(svc StencilServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + stencilServiceMethods := v1beta1.File_raystack_stencil_v1beta1_stencil_proto.Services().ByName("StencilService").Methods() + stencilServiceListNamespacesHandler := connect.NewUnaryHandler( + StencilServiceListNamespacesProcedure, + svc.ListNamespaces, + connect.WithSchema(stencilServiceMethods.ByName("ListNamespaces")), + connect.WithHandlerOptions(opts...), + ) + stencilServiceGetNamespaceHandler := connect.NewUnaryHandler( + StencilServiceGetNamespaceProcedure, + svc.GetNamespace, + connect.WithSchema(stencilServiceMethods.ByName("GetNamespace")), + connect.WithHandlerOptions(opts...), + ) + stencilServiceCreateNamespaceHandler := connect.NewUnaryHandler( + StencilServiceCreateNamespaceProcedure, + svc.CreateNamespace, + connect.WithSchema(stencilServiceMethods.ByName("CreateNamespace")), + connect.WithHandlerOptions(opts...), + ) + stencilServiceUpdateNamespaceHandler := connect.NewUnaryHandler( + StencilServiceUpdateNamespaceProcedure, + svc.UpdateNamespace, + connect.WithSchema(stencilServiceMethods.ByName("UpdateNamespace")), + connect.WithHandlerOptions(opts...), + ) + stencilServiceDeleteNamespaceHandler := connect.NewUnaryHandler( + StencilServiceDeleteNamespaceProcedure, + svc.DeleteNamespace, + connect.WithSchema(stencilServiceMethods.ByName("DeleteNamespace")), + connect.WithHandlerOptions(opts...), + ) + stencilServiceListSchemasHandler := connect.NewUnaryHandler( + StencilServiceListSchemasProcedure, + svc.ListSchemas, + connect.WithSchema(stencilServiceMethods.ByName("ListSchemas")), + connect.WithHandlerOptions(opts...), + ) + stencilServiceCreateSchemaHandler := connect.NewUnaryHandler( + StencilServiceCreateSchemaProcedure, + svc.CreateSchema, + connect.WithSchema(stencilServiceMethods.ByName("CreateSchema")), + connect.WithHandlerOptions(opts...), + ) + stencilServiceCheckCompatibilityHandler := connect.NewUnaryHandler( + StencilServiceCheckCompatibilityProcedure, + svc.CheckCompatibility, + connect.WithSchema(stencilServiceMethods.ByName("CheckCompatibility")), + connect.WithHandlerOptions(opts...), + ) + stencilServiceGetSchemaMetadataHandler := connect.NewUnaryHandler( + StencilServiceGetSchemaMetadataProcedure, + svc.GetSchemaMetadata, + connect.WithSchema(stencilServiceMethods.ByName("GetSchemaMetadata")), + connect.WithHandlerOptions(opts...), + ) + stencilServiceUpdateSchemaMetadataHandler := connect.NewUnaryHandler( + StencilServiceUpdateSchemaMetadataProcedure, + svc.UpdateSchemaMetadata, + connect.WithSchema(stencilServiceMethods.ByName("UpdateSchemaMetadata")), + connect.WithHandlerOptions(opts...), + ) + stencilServiceGetLatestSchemaHandler := connect.NewUnaryHandler( + StencilServiceGetLatestSchemaProcedure, + svc.GetLatestSchema, + connect.WithSchema(stencilServiceMethods.ByName("GetLatestSchema")), + connect.WithHandlerOptions(opts...), + ) + stencilServiceDeleteSchemaHandler := connect.NewUnaryHandler( + StencilServiceDeleteSchemaProcedure, + svc.DeleteSchema, + connect.WithSchema(stencilServiceMethods.ByName("DeleteSchema")), + connect.WithHandlerOptions(opts...), + ) + stencilServiceGetSchemaHandler := connect.NewUnaryHandler( + StencilServiceGetSchemaProcedure, + svc.GetSchema, + connect.WithSchema(stencilServiceMethods.ByName("GetSchema")), + connect.WithHandlerOptions(opts...), + ) + stencilServiceListVersionsHandler := connect.NewUnaryHandler( + StencilServiceListVersionsProcedure, + svc.ListVersions, + connect.WithSchema(stencilServiceMethods.ByName("ListVersions")), + connect.WithHandlerOptions(opts...), + ) + stencilServiceDeleteVersionHandler := connect.NewUnaryHandler( + StencilServiceDeleteVersionProcedure, + svc.DeleteVersion, + connect.WithSchema(stencilServiceMethods.ByName("DeleteVersion")), + connect.WithHandlerOptions(opts...), + ) + stencilServiceSearchHandler := connect.NewUnaryHandler( + StencilServiceSearchProcedure, + svc.Search, + connect.WithSchema(stencilServiceMethods.ByName("Search")), + connect.WithHandlerOptions(opts...), + ) + return "/raystack.stencil.v1beta1.StencilService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case StencilServiceListNamespacesProcedure: + stencilServiceListNamespacesHandler.ServeHTTP(w, r) + case StencilServiceGetNamespaceProcedure: + stencilServiceGetNamespaceHandler.ServeHTTP(w, r) + case StencilServiceCreateNamespaceProcedure: + stencilServiceCreateNamespaceHandler.ServeHTTP(w, r) + case StencilServiceUpdateNamespaceProcedure: + stencilServiceUpdateNamespaceHandler.ServeHTTP(w, r) + case StencilServiceDeleteNamespaceProcedure: + stencilServiceDeleteNamespaceHandler.ServeHTTP(w, r) + case StencilServiceListSchemasProcedure: + stencilServiceListSchemasHandler.ServeHTTP(w, r) + case StencilServiceCreateSchemaProcedure: + stencilServiceCreateSchemaHandler.ServeHTTP(w, r) + case StencilServiceCheckCompatibilityProcedure: + stencilServiceCheckCompatibilityHandler.ServeHTTP(w, r) + case StencilServiceGetSchemaMetadataProcedure: + stencilServiceGetSchemaMetadataHandler.ServeHTTP(w, r) + case StencilServiceUpdateSchemaMetadataProcedure: + stencilServiceUpdateSchemaMetadataHandler.ServeHTTP(w, r) + case StencilServiceGetLatestSchemaProcedure: + stencilServiceGetLatestSchemaHandler.ServeHTTP(w, r) + case StencilServiceDeleteSchemaProcedure: + stencilServiceDeleteSchemaHandler.ServeHTTP(w, r) + case StencilServiceGetSchemaProcedure: + stencilServiceGetSchemaHandler.ServeHTTP(w, r) + case StencilServiceListVersionsProcedure: + stencilServiceListVersionsHandler.ServeHTTP(w, r) + case StencilServiceDeleteVersionProcedure: + stencilServiceDeleteVersionHandler.ServeHTTP(w, r) + case StencilServiceSearchProcedure: + stencilServiceSearchHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedStencilServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedStencilServiceHandler struct{} + +func (UnimplementedStencilServiceHandler) ListNamespaces(context.Context, *connect.Request[v1beta1.ListNamespacesRequest]) (*connect.Response[v1beta1.ListNamespacesResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.ListNamespaces is not implemented")) +} + +func (UnimplementedStencilServiceHandler) GetNamespace(context.Context, *connect.Request[v1beta1.GetNamespaceRequest]) (*connect.Response[v1beta1.GetNamespaceResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.GetNamespace is not implemented")) +} + +func (UnimplementedStencilServiceHandler) CreateNamespace(context.Context, *connect.Request[v1beta1.CreateNamespaceRequest]) (*connect.Response[v1beta1.CreateNamespaceResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.CreateNamespace is not implemented")) +} + +func (UnimplementedStencilServiceHandler) UpdateNamespace(context.Context, *connect.Request[v1beta1.UpdateNamespaceRequest]) (*connect.Response[v1beta1.UpdateNamespaceResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.UpdateNamespace is not implemented")) +} + +func (UnimplementedStencilServiceHandler) DeleteNamespace(context.Context, *connect.Request[v1beta1.DeleteNamespaceRequest]) (*connect.Response[v1beta1.DeleteNamespaceResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.DeleteNamespace is not implemented")) +} + +func (UnimplementedStencilServiceHandler) ListSchemas(context.Context, *connect.Request[v1beta1.ListSchemasRequest]) (*connect.Response[v1beta1.ListSchemasResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.ListSchemas is not implemented")) +} + +func (UnimplementedStencilServiceHandler) CreateSchema(context.Context, *connect.Request[v1beta1.CreateSchemaRequest]) (*connect.Response[v1beta1.CreateSchemaResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.CreateSchema is not implemented")) +} + +func (UnimplementedStencilServiceHandler) CheckCompatibility(context.Context, *connect.Request[v1beta1.CheckCompatibilityRequest]) (*connect.Response[v1beta1.CheckCompatibilityResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.CheckCompatibility is not implemented")) +} + +func (UnimplementedStencilServiceHandler) GetSchemaMetadata(context.Context, *connect.Request[v1beta1.GetSchemaMetadataRequest]) (*connect.Response[v1beta1.GetSchemaMetadataResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.GetSchemaMetadata is not implemented")) +} + +func (UnimplementedStencilServiceHandler) UpdateSchemaMetadata(context.Context, *connect.Request[v1beta1.UpdateSchemaMetadataRequest]) (*connect.Response[v1beta1.UpdateSchemaMetadataResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.UpdateSchemaMetadata is not implemented")) +} + +func (UnimplementedStencilServiceHandler) GetLatestSchema(context.Context, *connect.Request[v1beta1.GetLatestSchemaRequest]) (*connect.Response[v1beta1.GetLatestSchemaResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.GetLatestSchema is not implemented")) +} + +func (UnimplementedStencilServiceHandler) DeleteSchema(context.Context, *connect.Request[v1beta1.DeleteSchemaRequest]) (*connect.Response[v1beta1.DeleteSchemaResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.DeleteSchema is not implemented")) +} + +func (UnimplementedStencilServiceHandler) GetSchema(context.Context, *connect.Request[v1beta1.GetSchemaRequest]) (*connect.Response[v1beta1.GetSchemaResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.GetSchema is not implemented")) +} + +func (UnimplementedStencilServiceHandler) ListVersions(context.Context, *connect.Request[v1beta1.ListVersionsRequest]) (*connect.Response[v1beta1.ListVersionsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.ListVersions is not implemented")) +} + +func (UnimplementedStencilServiceHandler) DeleteVersion(context.Context, *connect.Request[v1beta1.DeleteVersionRequest]) (*connect.Response[v1beta1.DeleteVersionResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.DeleteVersion is not implemented")) +} + +func (UnimplementedStencilServiceHandler) Search(context.Context, *connect.Request[v1beta1.SearchRequest]) (*connect.Response[v1beta1.SearchResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("raystack.stencil.v1beta1.StencilService.Search is not implemented")) +} diff --git a/go.mod b/go.mod index 6a336a34..0d733b67 100644 --- a/go.mod +++ b/go.mod @@ -1,10 +1,13 @@ module github.com/raystack/stencil -go 1.24 - -toolchain go1.24.0 +go 1.24.0 require ( + buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.36.11-20260415201107-50325440f8f2.1 + connectrpc.com/connect v1.19.2 + connectrpc.com/cors v0.1.0 + connectrpc.com/grpcreflect v1.3.0 + connectrpc.com/validate v0.6.0 github.com/MakeNowJust/heredoc v1.0.0 github.com/alecthomas/chroma v0.10.0 github.com/dgraph-io/ristretto v0.2.0 @@ -13,33 +16,30 @@ require ( github.com/georgysavva/scany v1.2.3 github.com/golang-migrate/migrate/v4 v4.18.2 github.com/google/uuid v1.6.0 - github.com/gorilla/mux v1.8.1 - github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 - github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3 github.com/hamba/avro v1.8.0 github.com/jackc/pgconn v1.14.3 github.com/jackc/pgx/v4 v4.18.3 github.com/jhump/protoreflect v1.17.0 - github.com/newrelic/go-agent/v3 v3.37.0 - github.com/newrelic/go-agent/v3/integrations/nrgrpc v1.4.5 github.com/pkg/errors v0.9.1 github.com/raystack/salt v0.6.2 + github.com/rs/cors v1.11.1 github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 github.com/spf13/cobra v1.9.1 - github.com/stretchr/testify v1.10.0 + github.com/stretchr/testify v1.11.1 github.com/yudai/gojsondiff v1.0.0 go.uber.org/multierr v1.11.0 go.uber.org/zap v1.27.0 golang.org/x/net v0.37.0 - google.golang.org/genproto/googleapis/api v0.0.0-20250313205543-e70fdf4c4cb4 - google.golang.org/grpc v1.71.0 - google.golang.org/protobuf v1.36.5 + google.golang.org/protobuf v1.36.11 ) require ( + buf.build/go/protovalidate v1.0.0 // indirect + cel.dev/expr v0.24.0 // indirect github.com/AlecAivazis/survey/v2 v2.3.7 // indirect github.com/NYTimes/gziphandler v1.1.1 // indirect github.com/alecthomas/chroma/v2 v2.15.0 // indirect + github.com/antlr4-go/antlr/v4 v4.13.1 // indirect github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect github.com/aymerick/douceur v0.2.0 // indirect github.com/briandowns/spinner v1.23.2 // indirect @@ -62,6 +62,7 @@ require ( github.com/go-playground/validator v9.31.0+incompatible // indirect github.com/go-viper/mapstructure/v2 v2.2.1 // indirect github.com/golang/protobuf v1.5.4 // indirect + github.com/google/cel-go v0.26.1 // indirect github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect github.com/gorilla/css v1.0.1 // indirect github.com/hashicorp/errwrap v1.1.0 // indirect @@ -92,12 +93,12 @@ require ( github.com/modern-go/reflect2 v1.0.2 // indirect github.com/muesli/reflow v0.3.0 // indirect github.com/muesli/termenv v0.16.0 // indirect - github.com/newrelic/csec-go-agent v1.6.0 // indirect github.com/nxadm/tail v1.4.11 // indirect github.com/olekukonko/tablewriter v0.0.5 // indirect github.com/pelletier/go-toml/v2 v2.2.3 // indirect github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/rivo/uniseg v0.4.7 // indirect + github.com/rogpeppe/go-internal v1.13.1 // indirect github.com/russross/blackfriday/v2 v2.1.0 // indirect github.com/sagikazarmark/locafero v0.8.0 // indirect github.com/schollz/progressbar/v3 v3.18.0 // indirect @@ -107,6 +108,7 @@ require ( github.com/spf13/cast v1.7.1 // indirect github.com/spf13/pflag v1.0.6 // indirect github.com/spf13/viper v1.20.0 // indirect + github.com/stoewer/go-strcase v1.3.1 // indirect github.com/stretchr/objx v0.5.2 // indirect github.com/subosito/gotenv v1.6.0 // indirect github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect @@ -114,13 +116,16 @@ require ( github.com/yudai/pp v2.0.1+incompatible // indirect github.com/yuin/goldmark v1.7.8 // indirect github.com/yuin/goldmark-emoji v1.0.5 // indirect + go.opentelemetry.io/otel/metric v1.34.0 // indirect + go.opentelemetry.io/otel/trace v1.34.0 // indirect go.uber.org/atomic v1.11.0 // indirect - golang.org/x/arch v0.15.0 // indirect golang.org/x/crypto v0.36.0 // indirect - golang.org/x/exp v0.0.0-20250305212735-054e65f0b394 // indirect + golang.org/x/exp v0.0.0-20250911091902-df9299821621 // indirect golang.org/x/sys v0.31.0 // indirect golang.org/x/term v0.30.0 // indirect - golang.org/x/text v0.23.0 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20250313205543-e70fdf4c4cb4 // indirect + golang.org/x/text v0.29.0 // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20250922171735-9219d122eba9 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20250922171735-9219d122eba9 // indirect + gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index fa63cf5c..c77afc1f 100644 --- a/go.sum +++ b/go.sum @@ -1,4 +1,17 @@ -cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.36.11-20260415201107-50325440f8f2.1 h1:s6hzCXtND/ICdGPTMGk7C+/BFlr2Jg5GyH0NKf4XGXg= +buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go v1.36.11-20260415201107-50325440f8f2.1/go.mod h1:tvtbpgaVXZX4g6Pn+AnzFycuRK3MOz5HJfEGeEllXYM= +buf.build/go/protovalidate v1.0.0 h1:IAG1etULddAy93fiBsFVhpj7es5zL53AfB/79CVGtyY= +buf.build/go/protovalidate v1.0.0/go.mod h1:KQmEUrcQuC99hAw+juzOEAmILScQiKBP1Oc36vvCLW8= +cel.dev/expr v0.24.0 h1:56OvJKSH3hDGL0ml5uSxZmz3/3Pq4tJ+fb1unVLAFcY= +cel.dev/expr v0.24.0/go.mod h1:hLPLo1W4QUmuYdA72RBX06QTs6MXw941piREPl3Yfiw= +connectrpc.com/connect v1.19.2 h1:McQ83FGdzL+t60peksi0gXC7MQ/iLKgLduAnThbM0mo= +connectrpc.com/connect v1.19.2/go.mod h1:tN20fjdGlewnSFeZxLKb0xwIZ6ozc3OQs2hTXy4du9w= +connectrpc.com/cors v0.1.0 h1:f3gTXJyDZPrDIZCQ567jxfD9PAIpopHiRDnJRt3QuOQ= +connectrpc.com/cors v0.1.0/go.mod h1:v8SJZCPfHtGH1zsm+Ttajpozd4cYIUryl4dFB6QEpfg= +connectrpc.com/grpcreflect v1.3.0 h1:Y4V+ACf8/vOb1XOc251Qun7jMB75gCUNw6llvB9csXc= +connectrpc.com/grpcreflect v1.3.0/go.mod h1:nfloOtCS8VUQOQ1+GTdFzVg2CJo4ZGaat8JIovCtDYs= +connectrpc.com/validate v0.6.0 h1:DcrgDKt2ZScrUs/d/mh9itD2yeEa0UbBBa+i0mwzx+4= +connectrpc.com/validate v0.6.0/go.mod h1:ihrpI+8gVbLH1fvVWJL1I3j0CfWnF8P/90LsmluRiZs= github.com/AlecAivazis/survey/v2 v2.3.7 h1:6I/u8FvytdGsgonrYsVn2t8t4QiRnh6QSTqkkhIiSjQ= github.com/AlecAivazis/survey/v2 v2.3.7/go.mod h1:xUTIdE4KCOIjsBAE1JYsUPoCqYdZ1reCfTwbto0Fduo= github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0= @@ -13,8 +26,6 @@ github.com/NYTimes/gziphandler v1.1.1 h1:ZUDjpQae29j0ryrS0u/B8HZfJBtBQHjqw2rQ2cq github.com/NYTimes/gziphandler v1.1.1/go.mod h1:n/CVRwUEOgIxrgPvAQhUUr9oeUtvrhMomdKFjzJNB0c= github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2 h1:+vx7roKuyA63nhn5WAunQHLTznkw5W8b1Xc0dNjp83s= github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2/go.mod h1:HBCaDeC1lPdgDeDbhX8XFpy1jqjK0IBG8W5K+xYqA0w= -github.com/adhocore/gronx v1.19.1 h1:S4c3uVp5jPjnk00De0lslyTenGJ4nA3Ydbkj1SbdPVc= -github.com/adhocore/gronx v1.19.1/go.mod h1:7oUY1WAU8rEJWmAxXR2DN0JaO4gi9khSgKjiRypqteg= github.com/alecthomas/assert/v2 v2.11.0 h1:2Q9r3ki8+JYXvGsDyBXwH3LcJ+WK5D0gc5E8vS6K3D0= github.com/alecthomas/assert/v2 v2.11.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k= github.com/alecthomas/chroma v0.10.0 h1:7XDcGkCQopCNKjZHfYrNLraA+M7e0fMiJ/Mfikbfjek= @@ -23,18 +34,18 @@ github.com/alecthomas/chroma/v2 v2.15.0 h1:LxXTQHFoYrstG2nnV9y2X5O94sOBzf0CIUpST github.com/alecthomas/chroma/v2 v2.15.0/go.mod h1:gUhVLrPDXPtp/f+L1jo9xepo9gL4eLwRuGAunSZMkio= github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc= github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4= +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/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWpi6yML8= github.com/aymanbagabas/go-udiff v0.2.0/go.mod h1:RE4Ex0qsGkTAJoQdQQCA0uG+nAzJO/pI/QwceO5fgrA= github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk= github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4= -github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= github.com/briandowns/spinner v1.23.2 h1:Zc6ecUnI+YzLmJniCfDNaMbW0Wid1d5+qcTq4L2FW8w= github.com/briandowns/spinner v1.23.2/go.mod h1:LaZeM4wm2Ywy6vO571mvhQNRcWfRUnXOs0RcKV0wYKM= github.com/bufbuild/protocompile v0.14.1 h1:iA73zAf/fyljNjQKwYzUHD6AD4R8KMasmwa/FBatYVw= github.com/bufbuild/protocompile v0.14.1/go.mod h1:ppVdAIhbr2H8asPk6k4pY7t9zB1OU5DoEw9xY/FUi1c= -github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc h1:4pZI35227imm7yK2bGPcfpFEmuY1gc2YSTShr4iJBfs= @@ -55,8 +66,6 @@ github.com/chengxilo/virtualterm v1.0.4 h1:Z6IpERbRVlfB8WkOmtbHiDbBANU7cimRIof7m github.com/chengxilo/virtualterm v1.0.4/go.mod h1:DyxxBZz/x1iqJjFxTFcr6/x+jSpqN0iwWCOK1q10rlY= github.com/cli/safeexec v1.0.1 h1:e/C79PbXF4yYTN/wauC4tviMxEV13BwljGj0N9j+N00= github.com/cli/safeexec v1.0.1/go.mod h1:Z/D4tTN8Vs5gXYHDCbaM1S/anmEDnJb1iW0+EJ5zx3Q= -github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= -github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= github.com/cockroachdb/apd v1.1.0 h1:3LFP3629v+1aKXU5Q37mxmRxX/pIu1nijXydLShEq5I= github.com/cockroachdb/apd v1.1.0/go.mod h1:8Sl8LxpKi29FqWXR16WEFZRNSz3SoPzUzeMeY4+DwBQ= github.com/cockroachdb/cockroach-go/v2 v2.2.0 h1:/5znzg5n373N/3ESjHF5SMLxiW4RKB05Ql//KWfeTFs= @@ -93,10 +102,6 @@ github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkp github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/emicklei/dot v1.8.0 h1:HnD60yAKFAevNeT+TPYr9pb8VB9bqdeSo0nzwIW6IOI= github.com/emicklei/dot v1.8.0/go.mod h1:DeV7GvQtIw4h2u73RKBkkFdvVAz0D9fzeJrgPW6gy/s= -github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= -github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= -github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= -github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM= github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= @@ -133,15 +138,11 @@ github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/golang-migrate/migrate/v4 v4.18.2 h1:2VSCMz7x7mjyTXx3m2zPokOY82LTRgxK1yQYKo6wWQ8= github.com/golang-migrate/migrate/v4 v4.18.2/go.mod h1:2CM6tJvn2kqPXwnXO/d3rAQYiyoIm180VsO8PRX6Rpk= -github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= -github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= -github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= +github.com/google/cel-go v0.26.1 h1:iPbVVEdkhTX++hpe3lzSk7D3G3QSYqLGoHOcEio+UXQ= +github.com/google/cel-go v0.26.1/go.mod h1:A9O8OU9rdvrK5MQyrqfIxo1a0u4g3sF8KB6PUIaryMM= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= @@ -152,14 +153,6 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8= github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0= -github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= -github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= -github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc= -github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 h1:UH//fgunKIs4JdUbpDl1VZCDaL56wXCB/5+wF6uHfaI= -github.com/grpc-ecosystem/go-grpc-middleware v1.4.0/go.mod h1:g5qyo/la0ALbONm6Vbp88Yd8NsDy6rZz+RcrMPxvld8= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3 h1:5ZPtiqj0JL5oKWmcsq4VMaAW5ukBEgSGXEN89zeH1Jo= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3/go.mod h1:ndYquD05frm2vACXE1nsccT4oJzjhw2arTS2cpUD1PI= github.com/hamba/avro v1.8.0 h1:eCVrLX7UYThA3R3yBZ+rpmafA5qTc3ZjpTz6gYJoVGU= github.com/hamba/avro v1.8.0/go.mod h1:NiGUcrLLT+CKfGu5REWQtD9OVPPYUGMVFiC+DE0lQfY= github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= @@ -249,15 +242,13 @@ github.com/jinzhu/now v1.1.1/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/ github.com/jmoiron/sqlx v1.3.1/go.mod h1:2BljVx/86SuTyjE+aPYlHCTNvZrnJXghYGpNiXLBMCQ= github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= -github.com/k2io/hookingo v1.0.6 h1:HBSKd1tNbW5BCj8VLNqemyBKjrQ8g0HkXcbC/DEHODE= -github.com/k2io/hookingo v1.0.6/go.mod h1:2L1jdNjdB3NkbzSVv9Q5fq7SJhRkWyAhe65XsAp5iXk= github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs= github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8= -github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= @@ -320,14 +311,6 @@ github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s= github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8= github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc= github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk= -github.com/newrelic/csec-go-agent v1.6.0 h1:OCShRZgiE+kg37jk+QXHw9e9EQ9BvLOeQTk+ovJhnrE= -github.com/newrelic/csec-go-agent v1.6.0/go.mod h1:LiLGm6a+q+hkmTnrxrYw1ToToirThOHydjrrLMtci5M= -github.com/newrelic/go-agent/v3 v3.37.0 h1:vAidwr7gUThxT+NvxDG3qUxgeuJbzxhYAEeiKtPn/ig= -github.com/newrelic/go-agent/v3 v3.37.0/go.mod h1:4QXvru0vVy/iu7mfkNHT7T2+9TC9zPGO8aUEdKqY138= -github.com/newrelic/go-agent/v3/integrations/nrgrpc v1.4.5 h1:wekCqkQLJbYHim2exa1K+Rqsl07J3e3NlnfrYc7pwV4= -github.com/newrelic/go-agent/v3/integrations/nrgrpc v1.4.5/go.mod h1:dDoaVvDchfHQjY9uZxARWym0hquX+80nCQHRNu0RN3c= -github.com/newrelic/go-agent/v3/integrations/nrsecurityagent v1.1.0 h1:gqkTDYUHWUyiG+u0PJQCRh98rcHLxP/w7GtIbJDVULY= -github.com/newrelic/go-agent/v3/integrations/nrsecurityagent v1.1.0/go.mod h1:3wugGvRmOVYov/08y+D8tB1uYIZds5bweVdr5vo4Gbs= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY= github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc= @@ -341,7 +324,6 @@ github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8 github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug= github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM= -github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M= github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= @@ -350,7 +332,6 @@ github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/raystack/salt v0.6.2 h1:GPUQ6j3h3cFd3k42Lds1xbG672yvhUjO9ut9oAJqW9M= github.com/raystack/salt v0.6.2/go.mod h1:Dwc5VlPevdY56XgYjWd+Ubkil7ohCM4526dkAuWnGN4= github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= @@ -358,8 +339,10 @@ github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJ github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= -github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= -github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= +github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII= +github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o= +github.com/rs/cors v1.11.1 h1:eU3gRzXLRK57F5rKMGMZURNdIG4EoAmX8k94r9wXWHA= +github.com/rs/cors v1.11.1/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU= github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ= github.com/rs/zerolog v1.13.0/go.mod h1:YbFCdg8HfsridGWAh22vktObvhZbQsZXe4/zB0OKkWU= github.com/rs/zerolog v1.15.0/go.mod h1:xYTKnLHcpfU2225ny5qZjxnj9NvkumZYjJHlAThCjNc= @@ -392,6 +375,8 @@ github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o= github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/spf13/viper v1.20.0 h1:zrxIyR3RQIOsarIrgL8+sAvALXul9jeEPa06Y0Ph6vY= github.com/spf13/viper v1.20.0/go.mod h1:P9Mdzt1zoHIG8m2eZQinpiBjo6kCmZSKBClNNqjJvu4= +github.com/stoewer/go-strcase v1.3.1 h1:iS0MdW+kVTxgMoE1LAZyMiYJFKlOzLooE4MxjirtkAs= +github.com/stoewer/go-strcase v1.3.1/go.mod h1:fAH5hQ5pehh+j3nZfvwdk2RgEgQjAoM8wodgtPmh1xo= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= @@ -409,8 +394,8 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= 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.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= -github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no= @@ -421,8 +406,6 @@ github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82 h1:BHyfKlQyqbsFN5p3Ifn github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82/go.mod h1:lgjkn3NuSvDfVJdfcVVdX+jpBxNmX4rDAzaS45IcYoM= github.com/yudai/pp v2.0.1+incompatible h1:Q4//iY4pNF6yPLZIigmvcl7k/bPgrcTPIFIcmawg5bI= github.com/yudai/pp v2.0.1+incompatible/go.mod h1:PuxR/8QJ7cyCkFp/aUDS+JY727OFEZkTdatxwunjIkc= -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.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= github.com/yuin/goldmark v1.7.1/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E= github.com/yuin/goldmark v1.7.8 h1:iERMLn0/QJeHFhxSt3p6PeN9mGnvIKSpG9YYorDMnic= @@ -438,37 +421,27 @@ go.opentelemetry.io/otel v1.34.0 h1:zRLXxLCgL1WyKsPVrgbSdMN4c0FMkDAskSTQP+0hdUY= go.opentelemetry.io/otel v1.34.0/go.mod h1:OWFPOQ+h4G8xpyjgqo4SxJYdDQ/qmRH+wivy7zzx9oI= go.opentelemetry.io/otel/metric v1.34.0 h1:+eTR3U0MyfWjRDhmFMxe2SsW64QrZ84AOhvqS7Y+PoQ= go.opentelemetry.io/otel/metric v1.34.0/go.mod h1:CEDrp0fy2D0MvkXE+dPV7cMi8tWZwX3dmaIhwPOaqHE= -go.opentelemetry.io/otel/sdk v1.34.0 h1:95zS4k/2GOy069d321O8jWgYsW3MzVV+KuSPKp7Wr1A= -go.opentelemetry.io/otel/sdk v1.34.0/go.mod h1:0e/pNiaMAqaykJGKbi+tSjWfNNHMTxoC9qANsCzbyxU= -go.opentelemetry.io/otel/sdk/metric v1.34.0 h1:5CeK9ujjbFVL5c1PhLuStg1wxA7vQv7ce1EK0Gyvahk= -go.opentelemetry.io/otel/sdk/metric v1.34.0/go.mod h1:jQ/r8Ze28zRKoNRdkjCZxfs6YvBTG1+YIqyFVFYec5w= go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC8mh/k= go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE= go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= -go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= -go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU= -go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA= go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM= -go.uber.org/zap v1.18.1/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI= go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= -golang.org/x/arch v0.15.0 h1:QtOrQd0bTUnhNVNndMpLHNWrDmYzZ2KDqSrEymqInZw= -golang.org/x/arch v0.15.0/go.mod h1:JmwW7aLIoRUKgaTzhkiEFxvcEiQGyOg9BMonBJUS7EE= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190411191339-88737f569e3a/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= @@ -486,28 +459,17 @@ golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDf golang.org/x/crypto v0.20.0/go.mod h1:Xwo95rrVNIoSMx9wa1JroENMToLWn3RNVrTBpLHgZPQ= golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34= golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc= -golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20250305212735-054e65f0b394 h1:nDVHiLt8aIbd/VzvPWN6kSOPE7+F/fNFDSXLVYkE/Iw= -golang.org/x/exp v0.0.0-20250305212735-054e65f0b394/go.mod h1:sIifuuw/Yco/y6yb6+bDNfyeQ/MdPUy/hKEMYQV17cM= -golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= -golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= -golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/exp v0.0.0-20250911091902-df9299821621 h1:2id6c1/gto0kaHYyrixvknJ8tUK/Qs5IsmBtrc+FtgU= +golang.org/x/exp v0.0.0-20250911091902-df9299821621/go.mod h1:TwQYMMnGpvZyc+JpB/UAuTNIsVJifOlSkrZkhcvpVUk= golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= -golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= @@ -515,17 +477,11 @@ golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= golang.org/x/net v0.37.0 h1:1zLorHbz+LYj7MQlSf1+2tPIIgibq2eL5xkrGk6f+2c= golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8= -golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= -golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw= -golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= -golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug= +golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -537,11 +493,9 @@ golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -570,23 +524,17 @@ golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY= -golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4= +golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk= +golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190425163242-31fd60d6bfdc/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= -golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190823170909-c4a336ef6a2f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= @@ -595,24 +543,14 @@ golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8T golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= -google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= -google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= -google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= -google.golang.org/genproto v0.0.0-20200423170343-7949de9c1215/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto/googleapis/api v0.0.0-20250313205543-e70fdf4c4cb4 h1:IFnXJq3UPB3oBREOodn1v1aGQeZYQclEmvWRMN0PSsY= -google.golang.org/genproto/googleapis/api v0.0.0-20250313205543-e70fdf4c4cb4/go.mod h1:c8q6Z6OCqnfVIqUFJkCzKcrj8eCvUrz+K4KRzSTuANg= -google.golang.org/genproto/googleapis/rpc v0.0.0-20250313205543-e70fdf4c4cb4 h1:iK2jbkWL86DXjEx0qiHcRE9dE4/Ahua5k6V8OWFb//c= -google.golang.org/genproto/googleapis/rpc v0.0.0-20250313205543-e70fdf4c4cb4/go.mod h1:LuRYeWDFV6WOn90g357N17oMCaxpgCnbi/44qJvDn2I= -google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= -google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= -google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= -google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= -google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= +google.golang.org/genproto/googleapis/api v0.0.0-20250922171735-9219d122eba9 h1:jm6v6kMRpTYKxBRrDkYAitNJegUeO1Mf3Kt80obv0gg= +google.golang.org/genproto/googleapis/api v0.0.0-20250922171735-9219d122eba9/go.mod h1:LmwNphe5Afor5V3R5BppOULHOnt2mCIf+NxMd4XiygE= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250922171735-9219d122eba9 h1:V1jCN2HBa8sySkR5vLcCSqJSTMv093Rw9EJefhQGP7M= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250922171735-9219d122eba9/go.mod h1:HSkG/KdJWusxU1F6CNrwNDjBMgisKxGnc5dAZfT0mjQ= google.golang.org/grpc v1.71.0 h1:kF77BGdPTQ4/JZWMlb9VpJ5pa25aqvVqogsxNHHdeBg= google.golang.org/grpc v1.71.0/go.mod h1:H0GRtasmQOh9LkFoCPDu3ZrwUtD1YGE+b2vYBYd/8Ec= -google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM= -google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= +google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= +google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= @@ -626,16 +564,12 @@ gopkg.in/inconshreveable/log15.v2 v2.0.0-20180818164646-67afb5ed74ec/go.mod h1:a gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gorm.io/driver/postgres v1.0.8/go.mod h1:4eOzrI1MUfm6ObJU/UcmbXyiHSs8jSwH95G5P5dxcAg= gorm.io/gorm v1.20.12/go.mod h1:0HFTzE/SqkGTzK6TlDPPQbAYCluiVvhzoA1+aVyzenw= gorm.io/gorm v1.21.4/go.mod h1:0HFTzE/SqkGTzK6TlDPPQbAYCluiVvhzoA1+aVyzenw= -honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= diff --git a/internal/api/api.go b/internal/api/api.go index d0ec6015..3c8b5ef3 100644 --- a/internal/api/api.go +++ b/internal/api/api.go @@ -2,22 +2,16 @@ package api import ( "context" - "fmt" + "encoding/json" + "io" "net/http" "strconv" - "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" - "github.com/newrelic/go-agent/v3/newrelic" "github.com/raystack/stencil/core/namespace" "github.com/raystack/stencil/core/schema" "github.com/raystack/stencil/core/search" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" - "google.golang.org/grpc/health/grpc_health_v1" ) -type getSchemaData func(http.ResponseWriter, *http.Request, map[string]string) (*schema.Metadata, []byte, error) -type errHandleFunc func(http.ResponseWriter, *http.Request, map[string]string) error - type NamespaceService interface { Create(ctx context.Context, ns namespace.Namespace) (namespace.Namespace, error) Update(ctx context.Context, ns namespace.Namespace) (namespace.Namespace, error) @@ -44,8 +38,6 @@ type SearchService interface { } type API struct { - stencilv1beta1.UnimplementedStencilServiceServer - grpc_health_v1.UnimplementedHealthServer namespace NamespaceService schema SchemaService search SearchService @@ -59,57 +51,113 @@ func NewAPI(namespace NamespaceService, schema SchemaService, search SearchServi } } -// RegisterSchemaHandlers registers HTTP handlers for schema download -func (a *API) RegisterSchemaHandlers(mux *runtime.ServeMux, app *newrelic.Application) { - mux.HandlePath("GET", "/ping", func(w http.ResponseWriter, r *http.Request, pathParams map[string]string) { - fmt.Fprint(w, "pong") - }) - mux.HandlePath(wrapHandler(app, "GET", "/v1beta1/namespaces/{namespace}/schemas/{name}/versions/{version}", handleSchemaResponse(mux, a.HTTPGetSchema))) - mux.HandlePath(wrapHandler(app, "GET", "/v1beta1/namespaces/{namespace}/schemas/{name}", handleSchemaResponse(mux, a.HTTPLatestSchema))) - mux.HandlePath(wrapHandler(app, "POST", "/v1beta1/namespaces/{namespace}/schemas/{name}", wrapErrHandler(mux, a.HTTPUpload))) - mux.HandlePath(wrapHandler(app, "POST", "/v1beta1/namespaces/{namespace}/schemas/{name}/check", wrapErrHandler(mux, a.HTTPCheckCompatibility))) +// RegisterSchemaHandlers registers custom HTTP handlers for schema binary endpoints. +// These serve raw schema bytes (protobuf/JSON) rather than standard RPC responses. +func (a *API) RegisterSchemaHandlers(mux *http.ServeMux) { + mux.HandleFunc("GET /v1beta1/namespaces/{namespace}/schemas/{name}/versions/{version}", a.handleGetSchema) + mux.HandleFunc("GET /v1beta1/namespaces/{namespace}/schemas/{name}", a.handleGetLatestSchema) + mux.HandleFunc("POST /v1beta1/namespaces/{namespace}/schemas/{name}", a.handleUploadSchema) + mux.HandleFunc("POST /v1beta1/namespaces/{namespace}/schemas/{name}/check", a.handleCheckCompatibility) } -func handleSchemaResponse(mux *runtime.ServeMux, getSchemaFn getSchemaData) runtime.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request, pathParams map[string]string) { - meta, data, err := getSchemaFn(w, r, pathParams) - if err != nil { - _, outbound := runtime.MarshalerForRequest(mux, r) - runtime.HTTPError(r.Context(), mux, outbound, w, r, err) - return - } - contentType := "application/json" - if meta.Format == "FORMAT_PROTOBUF" { - contentType = "application/octet-stream" - } - w.Header().Set("Content-Type", contentType) - w.Header().Set("Content-Length", strconv.Itoa(len(data))) - w.WriteHeader(http.StatusOK) - w.Write(data) +func (a *API) handleGetSchema(w http.ResponseWriter, r *http.Request) { + namespaceID := r.PathValue("namespace") + schemaName := r.PathValue("name") + versionStr := r.PathValue("version") + + v, err := strconv.ParseInt(versionStr, 10, 32) + if err != nil { + writeError(w, http.StatusBadRequest, "invalid version number") + return + } + + meta, data, err := a.schema.Get(r.Context(), namespaceID, schemaName, int32(v)) + if err != nil { + writeServiceError(w, err) + return } + + writeSchemaResponse(w, meta, data) } -func wrapErrHandler(mux *runtime.ServeMux, handler errHandleFunc) runtime.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request, pathParams map[string]string) { - err := handler(w, r, pathParams) - if err != nil { - _, outbound := runtime.MarshalerForRequest(mux, r) - runtime.DefaultHTTPErrorHandler(r.Context(), mux, outbound, w, r, err) - return - } +func (a *API) handleGetLatestSchema(w http.ResponseWriter, r *http.Request) { + namespaceID := r.PathValue("namespace") + schemaName := r.PathValue("name") + + meta, data, err := a.schema.GetLatest(r.Context(), namespaceID, schemaName) + if err != nil { + writeServiceError(w, err) + return + } + + writeSchemaResponse(w, meta, data) +} + +func (a *API) handleUploadSchema(w http.ResponseWriter, r *http.Request) { + data, err := readBody(r) + if err != nil { + writeError(w, http.StatusBadRequest, "failed to read request body") + return + } + + format := r.Header.Get("X-Format") + compatibility := r.Header.Get("X-Compatibility") + metadata := &schema.Metadata{Format: format, Compatibility: compatibility} + namespaceID := r.PathValue("namespace") + schemaName := r.PathValue("name") + + sc, err := a.schema.Create(r.Context(), namespaceID, schemaName, metadata, data) + if err != nil { + writeServiceError(w, err) + return } + + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusCreated) + json.NewEncoder(w).Encode(sc) } -func wrapHandler(app *newrelic.Application, method, pattern string, handler runtime.HandlerFunc) (string, string, runtime.HandlerFunc) { - if app == nil { - return method, pattern, handler +func (a *API) handleCheckCompatibility(w http.ResponseWriter, r *http.Request) { + data, err := readBody(r) + if err != nil { + writeError(w, http.StatusBadRequest, "failed to read request body") + return + } + + compatibility := r.Header.Get("X-Compatibility") + namespaceID := r.PathValue("namespace") + schemaName := r.PathValue("name") + + if err := a.schema.CheckCompatibility(r.Context(), namespaceID, schemaName, compatibility, data); err != nil { + writeServiceError(w, err) + return } - return method, pattern, func(w http.ResponseWriter, r *http.Request, pathParams map[string]string) { - txn := app.StartTransaction(method + " " + pattern) - defer txn.End() - w = txn.SetWebResponse(w) - txn.SetWebRequestHTTP(r) - r = newrelic.RequestWithTransactionContext(r, txn) - handler(w, r, pathParams) + + w.WriteHeader(http.StatusOK) +} + +func writeSchemaResponse(w http.ResponseWriter, meta *schema.Metadata, data []byte) { + contentType := "application/json" + if meta.Format == "FORMAT_PROTOBUF" { + contentType = "application/octet-stream" } + w.Header().Set("Content-Type", contentType) + w.Header().Set("Content-Length", strconv.Itoa(len(data))) + w.WriteHeader(http.StatusOK) + w.Write(data) +} + +func writeError(w http.ResponseWriter, statusCode int, msg string) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(statusCode) + json.NewEncoder(w).Encode(map[string]string{"error": msg}) +} + +func writeServiceError(w http.ResponseWriter, err error) { + writeError(w, http.StatusInternalServerError, err.Error()) +} + +func readBody(r *http.Request) ([]byte, error) { + defer r.Body.Close() + return io.ReadAll(r.Body) } diff --git a/internal/api/api_test.go b/internal/api/api_test.go index c38b7c5e..fe4979a6 100644 --- a/internal/api/api_test.go +++ b/internal/api/api_test.go @@ -1,17 +1,18 @@ package api_test import ( - "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" + "net/http" + "github.com/raystack/stencil/internal/api" "github.com/raystack/stencil/internal/api/mocks" ) -func setup() (*mocks.NamespaceService, *mocks.SchemaService, *mocks.SearchService, *runtime.ServeMux, *api.API) { +func setup() (*mocks.NamespaceService, *mocks.SchemaService, *mocks.SearchService, *http.ServeMux, *api.API) { nsService := &mocks.NamespaceService{} schemaService := &mocks.SchemaService{} searchService := &mocks.SearchService{} - mux := runtime.NewServeMux() + mux := http.NewServeMux() v1beta1 := api.NewAPI(nsService, schemaService, searchService) - v1beta1.RegisterSchemaHandlers(mux, nil) + v1beta1.RegisterSchemaHandlers(mux) return nsService, schemaService, searchService, mux, v1beta1 } diff --git a/internal/api/namespace.go b/internal/api/namespace.go index f7e3bb58..51bdd128 100644 --- a/internal/api/namespace.go +++ b/internal/api/namespace.go @@ -3,8 +3,9 @@ package api import ( "context" + "connectrpc.com/connect" "github.com/raystack/stencil/core/namespace" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + stencilv1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" "google.golang.org/protobuf/types/known/timestamppb" ) @@ -29,37 +30,49 @@ func namespaceToProto(ns namespace.Namespace) *stencilv1beta1.Namespace { } // CreateNamespace handler for creating namespace -func (a *API) CreateNamespace(ctx context.Context, in *stencilv1beta1.CreateNamespaceRequest) (*stencilv1beta1.CreateNamespaceResponse, error) { - ns := createNamespaceRequestToNamespace(in) +func (a *API) CreateNamespace(ctx context.Context, req *connect.Request[stencilv1beta1.CreateNamespaceRequest]) (*connect.Response[stencilv1beta1.CreateNamespaceResponse], error) { + ns := createNamespaceRequestToNamespace(req.Msg) newNamespace, err := a.namespace.Create(ctx, ns) - return &stencilv1beta1.CreateNamespaceResponse{Namespace: namespaceToProto(newNamespace)}, err + if err != nil { + return nil, err + } + return connect.NewResponse(&stencilv1beta1.CreateNamespaceResponse{Namespace: namespaceToProto(newNamespace)}), nil } -func (a *API) UpdateNamespace(ctx context.Context, in *stencilv1beta1.UpdateNamespaceRequest) (*stencilv1beta1.UpdateNamespaceResponse, error) { - ns, err := a.namespace.Update(ctx, namespace.Namespace{ID: in.GetId(), Format: in.GetFormat().String(), Compatibility: in.GetCompatibility().String(), Description: in.GetDescription()}) - return &stencilv1beta1.UpdateNamespaceResponse{Namespace: namespaceToProto(ns)}, err +func (a *API) UpdateNamespace(ctx context.Context, req *connect.Request[stencilv1beta1.UpdateNamespaceRequest]) (*connect.Response[stencilv1beta1.UpdateNamespaceResponse], error) { + ns, err := a.namespace.Update(ctx, namespace.Namespace{ID: req.Msg.GetId(), Format: req.Msg.GetFormat().String(), Compatibility: req.Msg.GetCompatibility().String(), Description: req.Msg.GetDescription()}) + if err != nil { + return nil, err + } + return connect.NewResponse(&stencilv1beta1.UpdateNamespaceResponse{Namespace: namespaceToProto(ns)}), nil } -func (a *API) GetNamespace(ctx context.Context, in *stencilv1beta1.GetNamespaceRequest) (*stencilv1beta1.GetNamespaceResponse, error) { - namespace, err := a.namespace.Get(ctx, in.GetId()) - return &stencilv1beta1.GetNamespaceResponse{Namespace: namespaceToProto(namespace)}, err +func (a *API) GetNamespace(ctx context.Context, req *connect.Request[stencilv1beta1.GetNamespaceRequest]) (*connect.Response[stencilv1beta1.GetNamespaceResponse], error) { + namespace, err := a.namespace.Get(ctx, req.Msg.GetId()) + if err != nil { + return nil, err + } + return connect.NewResponse(&stencilv1beta1.GetNamespaceResponse{Namespace: namespaceToProto(namespace)}), nil } // ListNamespaces handler for returning list of available namespaces -func (a *API) ListNamespaces(ctx context.Context, in *stencilv1beta1.ListNamespacesRequest) (*stencilv1beta1.ListNamespacesResponse, error) { +func (a *API) ListNamespaces(ctx context.Context, req *connect.Request[stencilv1beta1.ListNamespacesRequest]) (*connect.Response[stencilv1beta1.ListNamespacesResponse], error) { namespaces, err := a.namespace.List(ctx) + if err != nil { + return nil, err + } var nsp []*stencilv1beta1.Namespace for _, n := range namespaces { nsp = append(nsp, namespaceToProto(n)) } - return &stencilv1beta1.ListNamespacesResponse{Namespaces: nsp}, err + return connect.NewResponse(&stencilv1beta1.ListNamespacesResponse{Namespaces: nsp}), nil } -func (a *API) DeleteNamespace(ctx context.Context, in *stencilv1beta1.DeleteNamespaceRequest) (*stencilv1beta1.DeleteNamespaceResponse, error) { - err := a.namespace.Delete(ctx, in.GetId()) +func (a *API) DeleteNamespace(ctx context.Context, req *connect.Request[stencilv1beta1.DeleteNamespaceRequest]) (*connect.Response[stencilv1beta1.DeleteNamespaceResponse], error) { + err := a.namespace.Delete(ctx, req.Msg.GetId()) message := "success" if err != nil { message = "failed" } - return &stencilv1beta1.DeleteNamespaceResponse{Message: message}, err + return connect.NewResponse(&stencilv1beta1.DeleteNamespaceResponse{Message: message}), err } diff --git a/internal/api/ping.go b/internal/api/ping.go deleted file mode 100644 index b65c682d..00000000 --- a/internal/api/ping.go +++ /dev/null @@ -1,12 +0,0 @@ -package api - -import ( - "context" - - "google.golang.org/grpc/health/grpc_health_v1" -) - -// Check grpc health check -func (s *API) Check(ctx context.Context, in *grpc_health_v1.HealthCheckRequest) (*grpc_health_v1.HealthCheckResponse, error) { - return &grpc_health_v1.HealthCheckResponse{Status: grpc_health_v1.HealthCheckResponse_SERVING}, nil -} diff --git a/internal/api/schema.go b/internal/api/schema.go index a7df1564..64b4b194 100644 --- a/internal/api/schema.go +++ b/internal/api/schema.go @@ -2,15 +2,10 @@ package api import ( "context" - "encoding/json" - "errors" - "io" - "net/http" - "strconv" - "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" + "connectrpc.com/connect" "github.com/raystack/stencil/core/schema" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + stencilv1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" ) func schemaToProto(s schema.Schema) *stencilv1beta1.Schema { @@ -22,137 +17,111 @@ func schemaToProto(s schema.Schema) *stencilv1beta1.Schema { } } -func (a *API) CreateSchema(ctx context.Context, in *stencilv1beta1.CreateSchemaRequest) (*stencilv1beta1.CreateSchemaResponse, error) { - metadata := &schema.Metadata{Format: in.GetFormat().String(), Compatibility: in.GetCompatibility().String()} - sc, err := a.schema.Create(ctx, in.NamespaceId, in.SchemaId, metadata, in.GetData()) - return &stencilv1beta1.CreateSchemaResponse{ +func (a *API) CreateSchema(ctx context.Context, req *connect.Request[stencilv1beta1.CreateSchemaRequest]) (*connect.Response[stencilv1beta1.CreateSchemaResponse], error) { + metadata := &schema.Metadata{Format: req.Msg.GetFormat().String(), Compatibility: req.Msg.GetCompatibility().String()} + sc, err := a.schema.Create(ctx, req.Msg.GetNamespaceId(), req.Msg.GetSchemaId(), metadata, req.Msg.GetData()) + if err != nil { + return nil, err + } + return connect.NewResponse(&stencilv1beta1.CreateSchemaResponse{ Version: sc.Version, Id: sc.ID, Location: sc.Location, - }, err + }), nil } -func (a *API) HTTPUpload(w http.ResponseWriter, req *http.Request, pathParams map[string]string) error { - data, err := io.ReadAll(req.Body) - if err != nil { - return err - } - format := req.Header.Get("X-Format") - compatibility := req.Header.Get("X-Compatibility") - metadata := &schema.Metadata{Format: format, Compatibility: compatibility} - namespaceID := pathParams["namespace"] - schemaName := pathParams["name"] - sc, err := a.schema.Create(req.Context(), namespaceID, schemaName, metadata, data) + +func (a *API) CheckCompatibility(ctx context.Context, req *connect.Request[stencilv1beta1.CheckCompatibilityRequest]) (*connect.Response[stencilv1beta1.CheckCompatibilityResponse], error) { + err := a.schema.CheckCompatibility(ctx, req.Msg.GetNamespaceId(), req.Msg.GetSchemaId(), req.Msg.GetCompatibility().String(), req.Msg.GetData()) if err != nil { - return err + return nil, err } - respData, _ := json.Marshal(sc) - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(http.StatusCreated) - w.Write(respData) - return nil + return connect.NewResponse(&stencilv1beta1.CheckCompatibilityResponse{}), nil } -func (a *API) CheckCompatibility(ctx context.Context, req *stencilv1beta1.CheckCompatibilityRequest) (*stencilv1beta1.CheckCompatibilityResponse, error) { - resp := &stencilv1beta1.CheckCompatibilityResponse{} - err := a.schema.CheckCompatibility(ctx, req.GetNamespaceId(), req.GetSchemaId(), req.GetCompatibility().String(), req.GetData()) - return resp, err -} - -func (a *API) HTTPCheckCompatibility(w http.ResponseWriter, req *http.Request, pathParams map[string]string) error { - data, err := io.ReadAll(req.Body) +func (a *API) ListSchemas(ctx context.Context, req *connect.Request[stencilv1beta1.ListSchemasRequest]) (*connect.Response[stencilv1beta1.ListSchemasResponse], error) { + schemas, err := a.schema.List(ctx, req.Msg.GetId()) if err != nil { - return err + return nil, err } - compatibility := req.Header.Get("X-Compatibility") - namespaceID := pathParams["namespace"] - schemaName := pathParams["name"] - return a.schema.CheckCompatibility(req.Context(), namespaceID, schemaName, compatibility, data) -} - -func (a *API) ListSchemas(ctx context.Context, in *stencilv1beta1.ListSchemasRequest) (*stencilv1beta1.ListSchemasResponse, error) { - schemas, err := a.schema.List(ctx, in.Id) - var ss []*stencilv1beta1.Schema for _, s := range schemas { ss = append(ss, schemaToProto(s)) } - return &stencilv1beta1.ListSchemasResponse{Schemas: ss}, err + return connect.NewResponse(&stencilv1beta1.ListSchemasResponse{Schemas: ss}), nil } -func (a *API) GetLatestSchema(ctx context.Context, in *stencilv1beta1.GetLatestSchemaRequest) (*stencilv1beta1.GetLatestSchemaResponse, error) { - _, data, err := a.schema.GetLatest(ctx, in.NamespaceId, in.SchemaId) - return &stencilv1beta1.GetLatestSchemaResponse{ +func (a *API) GetLatestSchema(ctx context.Context, req *connect.Request[stencilv1beta1.GetLatestSchemaRequest]) (*connect.Response[stencilv1beta1.GetLatestSchemaResponse], error) { + _, data, err := a.schema.GetLatest(ctx, req.Msg.GetNamespaceId(), req.Msg.GetSchemaId()) + if err != nil { + return nil, err + } + return connect.NewResponse(&stencilv1beta1.GetLatestSchemaResponse{ Data: data, - }, err -} - -func (a *API) HTTPLatestSchema(w http.ResponseWriter, req *http.Request, pathParams map[string]string) (*schema.Metadata, []byte, error) { - namespaceID := pathParams["namespace"] - schemaName := pathParams["name"] - return a.schema.GetLatest(req.Context(), namespaceID, schemaName) + }), nil } -func (a *API) GetSchema(ctx context.Context, in *stencilv1beta1.GetSchemaRequest) (*stencilv1beta1.GetSchemaResponse, error) { - _, data, err := a.schema.Get(ctx, in.NamespaceId, in.SchemaId, in.GetVersionId()) - return &stencilv1beta1.GetSchemaResponse{ +func (a *API) GetSchema(ctx context.Context, req *connect.Request[stencilv1beta1.GetSchemaRequest]) (*connect.Response[stencilv1beta1.GetSchemaResponse], error) { + _, data, err := a.schema.Get(ctx, req.Msg.GetNamespaceId(), req.Msg.GetSchemaId(), req.Msg.GetVersionId()) + if err != nil { + return nil, err + } + return connect.NewResponse(&stencilv1beta1.GetSchemaResponse{ Data: data, - }, err + }), nil } -func (a *API) HTTPGetSchema(w http.ResponseWriter, req *http.Request, pathParams map[string]string) (*schema.Metadata, []byte, error) { - namespaceID := pathParams["namespace"] - schemaName := pathParams["name"] - versionString := pathParams["version"] - v, err := strconv.ParseInt(versionString, 10, 32) +func (a *API) ListVersions(ctx context.Context, req *connect.Request[stencilv1beta1.ListVersionsRequest]) (*connect.Response[stencilv1beta1.ListVersionsResponse], error) { + versions, err := a.schema.ListVersions(ctx, req.Msg.GetNamespaceId(), req.Msg.GetSchemaId()) if err != nil { - return nil, nil, &runtime.HTTPStatusError{HTTPStatus: http.StatusBadRequest, Err: errors.New("invalid version number")} + return nil, err } - return a.schema.Get(req.Context(), namespaceID, schemaName, int32(v)) + return connect.NewResponse(&stencilv1beta1.ListVersionsResponse{Versions: versions}), nil } -func (a *API) ListVersions(ctx context.Context, in *stencilv1beta1.ListVersionsRequest) (*stencilv1beta1.ListVersionsResponse, error) { - versions, err := a.schema.ListVersions(ctx, in.NamespaceId, in.SchemaId) - return &stencilv1beta1.ListVersionsResponse{Versions: versions}, err -} - -func (a *API) GetSchemaMetadata(ctx context.Context, in *stencilv1beta1.GetSchemaMetadataRequest) (*stencilv1beta1.GetSchemaMetadataResponse, error) { - meta, err := a.schema.GetMetadata(ctx, in.NamespaceId, in.SchemaId) - return &stencilv1beta1.GetSchemaMetadataResponse{ +func (a *API) GetSchemaMetadata(ctx context.Context, req *connect.Request[stencilv1beta1.GetSchemaMetadataRequest]) (*connect.Response[stencilv1beta1.GetSchemaMetadataResponse], error) { + meta, err := a.schema.GetMetadata(ctx, req.Msg.GetNamespaceId(), req.Msg.GetSchemaId()) + if err != nil { + return nil, err + } + return connect.NewResponse(&stencilv1beta1.GetSchemaMetadataResponse{ Format: stencilv1beta1.Schema_Format(stencilv1beta1.Schema_Format_value[meta.Format]), Compatibility: stencilv1beta1.Schema_Compatibility(stencilv1beta1.Schema_Compatibility_value[meta.Compatibility]), Authority: meta.Authority, - }, err + }), nil } -func (a *API) UpdateSchemaMetadata(ctx context.Context, in *stencilv1beta1.UpdateSchemaMetadataRequest) (*stencilv1beta1.UpdateSchemaMetadataResponse, error) { - meta, err := a.schema.UpdateMetadata(ctx, in.NamespaceId, in.SchemaId, &schema.Metadata{ - Compatibility: in.Compatibility.String(), +func (a *API) UpdateSchemaMetadata(ctx context.Context, req *connect.Request[stencilv1beta1.UpdateSchemaMetadataRequest]) (*connect.Response[stencilv1beta1.UpdateSchemaMetadataResponse], error) { + meta, err := a.schema.UpdateMetadata(ctx, req.Msg.GetNamespaceId(), req.Msg.GetSchemaId(), &schema.Metadata{ + Compatibility: req.Msg.GetCompatibility().String(), }) - return &stencilv1beta1.UpdateSchemaMetadataResponse{ + if err != nil { + return nil, err + } + return connect.NewResponse(&stencilv1beta1.UpdateSchemaMetadataResponse{ Format: stencilv1beta1.Schema_Format(stencilv1beta1.Schema_Format_value[meta.Format]), Compatibility: stencilv1beta1.Schema_Compatibility(stencilv1beta1.Schema_Compatibility_value[meta.Compatibility]), Authority: meta.Authority, - }, err + }), nil } -func (a *API) DeleteSchema(ctx context.Context, in *stencilv1beta1.DeleteSchemaRequest) (*stencilv1beta1.DeleteSchemaResponse, error) { - err := a.schema.Delete(ctx, in.NamespaceId, in.SchemaId) +func (a *API) DeleteSchema(ctx context.Context, req *connect.Request[stencilv1beta1.DeleteSchemaRequest]) (*connect.Response[stencilv1beta1.DeleteSchemaResponse], error) { + err := a.schema.Delete(ctx, req.Msg.GetNamespaceId(), req.Msg.GetSchemaId()) message := "success" if err != nil { message = "failed" } - return &stencilv1beta1.DeleteSchemaResponse{ + return connect.NewResponse(&stencilv1beta1.DeleteSchemaResponse{ Message: message, - }, err + }), err } -func (a *API) DeleteVersion(ctx context.Context, in *stencilv1beta1.DeleteVersionRequest) (*stencilv1beta1.DeleteVersionResponse, error) { - err := a.schema.DeleteVersion(ctx, in.NamespaceId, in.SchemaId, in.GetVersionId()) +func (a *API) DeleteVersion(ctx context.Context, req *connect.Request[stencilv1beta1.DeleteVersionRequest]) (*connect.Response[stencilv1beta1.DeleteVersionResponse], error) { + err := a.schema.DeleteVersion(ctx, req.Msg.GetNamespaceId(), req.Msg.GetSchemaId(), req.Msg.GetVersionId()) message := "success" if err != nil { message = "failed" } - return &stencilv1beta1.DeleteVersionResponse{ + return connect.NewResponse(&stencilv1beta1.DeleteVersionResponse{ Message: message, - }, err + }), err } diff --git a/internal/api/schema_test.go b/internal/api/schema_test.go index a83da075..d33b6d80 100644 --- a/internal/api/schema_test.go +++ b/internal/api/schema_test.go @@ -22,7 +22,6 @@ func TestHTTPGetSchema(t *testing.T) { req, _ := http.NewRequest("GET", fmt.Sprintf("/v1beta1/namespaces/%s/schemas/%s/versions/invalidNumber", nsName, schemaName), nil) mux.ServeHTTP(w, req) assert.Equal(t, 400, w.Code) - assert.JSONEq(t, `{"code":2,"message":"invalid version number","details":[]}`, w.Body.String()) }) t.Run("should return http error if getSchema fails", func(t *testing.T) { version := int32(2) @@ -32,7 +31,6 @@ func TestHTTPGetSchema(t *testing.T) { req, _ := http.NewRequest("GET", fmt.Sprintf("/v1beta1/namespaces/%s/schemas/%s/versions/%d", nsName, schemaName, version), nil) mux.ServeHTTP(w, req) assert.Equal(t, 500, w.Code) - assert.JSONEq(t, `{"code":2,"message":"get error","details":[]}`, w.Body.String()) }) t.Run("should return octet-stream content type for protobuf schema", func(t *testing.T) { version := int32(2) @@ -75,7 +73,6 @@ func TestHTTPSchemaCreate(t *testing.T) { req.Header.Add("X-Compatibility", compatibility) mux.ServeHTTP(w, req) assert.Equal(t, 201, w.Code) - assert.JSONEq(t, `{"id": "someID", "location": "", "version": 2}`, w.Body.String()) schemaSvc.AssertExpectations(t) }) } diff --git a/internal/api/search.go b/internal/api/search.go index e733d322..7263e701 100644 --- a/internal/api/search.go +++ b/internal/api/search.go @@ -4,18 +4,19 @@ import ( "context" "fmt" + "connectrpc.com/connect" "github.com/raystack/stencil/core/search" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + stencilv1beta1 "github.com/raystack/stencil/gen/raystack/stencil/v1beta1" ) -func (a *API) Search(ctx context.Context, in *stencilv1beta1.SearchRequest) (*stencilv1beta1.SearchResponse, error) { +func (a *API) Search(ctx context.Context, req *connect.Request[stencilv1beta1.SearchRequest]) (*connect.Response[stencilv1beta1.SearchResponse], error) { searchReq := &search.SearchRequest{ - NamespaceID: in.GetNamespaceId(), - Query: in.GetQuery(), - SchemaID: in.GetSchemaId(), + NamespaceID: req.Msg.GetNamespaceId(), + Query: req.Msg.GetQuery(), + SchemaID: req.Msg.GetSchemaId(), } - switch v := in.GetVersion().(type) { + switch v := req.Msg.GetVersion().(type) { case *stencilv1beta1.SearchRequest_VersionId: searchReq.VersionID = v.VersionId case *stencilv1beta1.SearchRequest_History: @@ -38,10 +39,10 @@ func (a *API) Search(ctx context.Context, in *stencilv1beta1.SearchRequest) (*st Path: fmt.Sprintf("/v1beta1/namespaces/%s/schemas/%s/versions/%d", hit.NamespaceID, hit.SchemaID, hit.VersionID), }) } - return &stencilv1beta1.SearchResponse{ + return connect.NewResponse(&stencilv1beta1.SearchResponse{ Hits: hits, Meta: &stencilv1beta1.SearchMeta{ Total: uint32(len(hits)), }, - }, nil + }), nil } diff --git a/internal/middleware/error_response.go b/internal/middleware/error_response.go new file mode 100644 index 00000000..4a0accc0 --- /dev/null +++ b/internal/middleware/error_response.go @@ -0,0 +1,48 @@ +package middleware + +import ( + "context" + "errors" + "fmt" + "log/slog" + "net/http" + "time" + + "connectrpc.com/connect" + "github.com/raystack/stencil/internal/store" +) + +// ErrorResponse returns a new unary interceptor that standardizes error formatting. +// It ensures all errors returned from handlers are proper Connect errors. +// Non-Connect errors are sanitized to prevent leaking internal details. +func ErrorResponse() connect.UnaryInterceptorFunc { + return func(next connect.UnaryFunc) connect.UnaryFunc { + return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) { + resp, err := next(ctx, req) + if err != nil { + return resp, ensureConnectError(ctx, err) + } + return resp, nil + } + } +} + +// ensureConnectError wraps non-Connect errors as sanitized internal Connect errors. +func ensureConnectError(ctx context.Context, err error) error { + var connectErr *connect.Error + if errors.As(err, &connectErr) { + return err + } + // Convert known domain errors to proper Connect error codes + var storageErr store.StorageErr + if errors.As(err, &storageErr) { + return storageErr.ConnectError() + } + ref := time.Now().Unix() + slog.ErrorContext(ctx, "unhandled error", "error", err, "ref", ref) + return connect.NewError(connect.CodeInternal, fmt.Errorf( + "%s - ref (%d)", + http.StatusText(http.StatusInternalServerError), + ref, + )) +} diff --git a/internal/middleware/logger.go b/internal/middleware/logger.go new file mode 100644 index 00000000..f766fef5 --- /dev/null +++ b/internal/middleware/logger.go @@ -0,0 +1,40 @@ +package middleware + +import ( + "context" + "log/slog" + "time" + + "connectrpc.com/connect" +) + +// Logger returns a new unary interceptor that logs request details. +func Logger() connect.UnaryInterceptorFunc { + return func(next connect.UnaryFunc) connect.UnaryFunc { + return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) { + start := time.Now() + + resp, err := next(ctx, req) + + duration := time.Since(start) + attrs := []slog.Attr{ + slog.String("procedure", req.Spec().Procedure), + slog.Duration("duration", duration), + slog.String("peer_addr", req.Peer().Addr), + } + + if err != nil { + attrs = append(attrs, slog.Any("error", err)) + connectErr, ok := err.(*connect.Error) + if ok { + attrs = append(attrs, slog.String("code", connectErr.Code().String())) + } + slog.LogAttrs(ctx, slog.LevelError, "request failed", attrs...) + } else { + slog.LogAttrs(ctx, slog.LevelDebug, "request completed", attrs...) + } + + return resp, err + } + } +} diff --git a/internal/middleware/recovery.go b/internal/middleware/recovery.go new file mode 100644 index 00000000..a292028c --- /dev/null +++ b/internal/middleware/recovery.go @@ -0,0 +1,29 @@ +package middleware + +import ( + "context" + "fmt" + "log" + "runtime/debug" + + "connectrpc.com/connect" +) + +// Recovery returns a new unary interceptor that recovers from panics. +func Recovery() connect.UnaryInterceptorFunc { + return func(next connect.UnaryFunc) connect.UnaryFunc { + return func(ctx context.Context, req connect.AnyRequest) (resp connect.AnyResponse, err error) { + defer func() { + if r := recover(); r != nil { + stack := debug.Stack() + log.Printf("panic recovered: %v\n%s", r, string(stack)) + err = connect.NewError( + connect.CodeInternal, + fmt.Errorf("internal server error"), + ) + } + }() + return next(ctx, req) + } + } +} diff --git a/internal/server/graceful.go b/internal/server/graceful.go deleted file mode 100644 index 80618549..00000000 --- a/internal/server/graceful.go +++ /dev/null @@ -1,43 +0,0 @@ -package server - -import ( - "context" - "errors" - "fmt" - "log" - "net/http" - "os" - "os/signal" - "syscall" - - "github.com/raystack/stencil/config" -) - -func runWithGracefulShutdown(config *config.Config, router http.Handler, cleanUp func()) { - srv := &http.Server{ - Addr: fmt.Sprintf(":%s", config.Port), - Handler: router, - } - go func() { - if err := srv.ListenAndServe(); err != nil && errors.Is(err, http.ErrServerClosed) { - log.Printf("listen: %s\n", err) - } - }() - - quit := make(chan os.Signal, 2) - - signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) - <-quit - log.Println("Shutting down server...") - - ctx, cancel := context.WithTimeout(context.Background(), config.Timeout) - defer cancel() - - if err := srv.Shutdown(ctx); err != nil { - cleanUp() - log.Fatal("Server forced to shutdown:", err) - } - cleanUp() - - log.Println("Server exiting") -} diff --git a/internal/server/newrelic.go b/internal/server/newrelic.go deleted file mode 100644 index 194d612a..00000000 --- a/internal/server/newrelic.go +++ /dev/null @@ -1,21 +0,0 @@ -package server - -import ( - "log" - - "github.com/newrelic/go-agent/v3/newrelic" - "github.com/raystack/stencil/config" -) - -func getNewRelic(config *config.Config) *newrelic.Application { - newRelicConfig := config.NewRelic - app, err := newrelic.NewApplication( - newrelic.ConfigAppName(newRelicConfig.AppName), - newrelic.ConfigLicense(newRelicConfig.License), - newrelic.ConfigEnabled(newRelicConfig.Enabled), - ) - if err != nil { - log.Fatal(err) - } - return app -} diff --git a/internal/server/server.go b/internal/server/server.go index 545276f5..14bd5a89 100644 --- a/internal/server/server.go +++ b/internal/server/server.go @@ -2,43 +2,43 @@ package server import ( "context" + "errors" "fmt" "log" + "log/slog" "net/http" - "strings" - + "os" + "os/signal" + "syscall" + "time" + + "connectrpc.com/connect" + connectcors "connectrpc.com/cors" + "connectrpc.com/grpcreflect" + "connectrpc.com/validate" "github.com/dgraph-io/ristretto" - "github.com/gorilla/mux" - "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" - "github.com/newrelic/go-agent/v3/integrations/nrgrpc" "github.com/raystack/salt/server/spa" "github.com/raystack/stencil/config" - "github.com/raystack/stencil/internal/store/postgres" - "github.com/raystack/stencil/ui" - - grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware" - grpc_zap "github.com/grpc-ecosystem/go-grpc-middleware/logging/zap" - grpc_recovery "github.com/grpc-ecosystem/go-grpc-middleware/recovery" - grpc_ctxtags "github.com/grpc-ecosystem/go-grpc-middleware/tags" "github.com/raystack/stencil/core/namespace" "github.com/raystack/stencil/core/schema" "github.com/raystack/stencil/core/schema/provider" "github.com/raystack/stencil/core/search" + stencilv1beta1connect "github.com/raystack/stencil/gen/raystack/stencil/v1beta1/stencilv1beta1connect" "github.com/raystack/stencil/internal/api" - "github.com/raystack/stencil/pkg/logger" - "github.com/raystack/stencil/pkg/validator" - stencilv1beta1 "github.com/raystack/stencil/proto/raystack/stencil/v1beta1" + "github.com/raystack/stencil/internal/middleware" + "github.com/raystack/stencil/internal/store/postgres" + "github.com/raystack/stencil/ui" + "github.com/rs/cors" "golang.org/x/net/http2" "golang.org/x/net/http2/h2c" - "google.golang.org/grpc" - "google.golang.org/grpc/health/grpc_health_v1" ) // Start Entry point to start the server func Start(cfg config.Config) { - ctx := context.Background() + logger := slog.Default().With("component", "server") db := postgres.NewStore(cfg.DB.ConnectionString) + defer db.Close() namespaceRepository := postgres.NewNamespaceRepository(db) namespaceService := namespace.NewService(namespaceRepository) @@ -57,69 +57,93 @@ func Start(cfg config.Config) { searchRepository := postgres.NewSearchRepository(db) searchService := search.NewService(searchRepository) - api := api.NewAPI(namespaceService, schemaService, searchService) - - port := fmt.Sprintf(":%s", cfg.Port) - nr := getNewRelic(&cfg) - gatewayMux := runtime.NewServeMux() - - // init grpc server - opts := []grpc.ServerOption{ - grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer( - grpc_recovery.UnaryServerInterceptor(), - grpc_ctxtags.UnaryServerInterceptor(), - nrgrpc.UnaryServerInterceptor(nr), - grpc_zap.UnaryServerInterceptor(logger.Logger), - validator.UnaryServerInterceptor())), - grpc.MaxRecvMsgSize(cfg.GRPC.MaxRecvMsgSizeInMB << 20), - grpc.MaxSendMsgSize(cfg.GRPC.MaxSendMsgSizeInMB << 20), - } - // Create a gRPC server object - s := grpc.NewServer(opts...) - stencilv1beta1.RegisterStencilServiceServer(s, api) - grpc_health_v1.RegisterHealthServer(s, api) - conn, err := grpc.DialContext( - context.Background(), - port, - grpc.WithInsecure(), + handler := api.NewAPI(namespaceService, schemaService, searchService) + + // Build interceptor chain + validateInterceptor := validate.NewInterceptor() + interceptors := connect.WithInterceptors( + middleware.Recovery(), + middleware.Logger(), + validateInterceptor, + middleware.ErrorResponse(), ) - if err != nil { - log.Fatalln("Failed to dial server:", err) - } - api.RegisterSchemaHandlers(gatewayMux, nr) - if err = stencilv1beta1.RegisterStencilServiceHandler(ctx, gatewayMux, conn); err != nil { - log.Fatalln("Failed to register stencil service handler:", err) - } + // Create HTTP mux + mux := http.NewServeMux() - rtr := mux.NewRouter() + // Register connect service handler + path, svcHandler := stencilv1beta1connect.NewStencilServiceHandler( + handler, + interceptors, + connect.WithReadMaxBytes(cfg.MaxRecvMsgSize), + connect.WithSendMaxBytes(cfg.MaxSendMsgSize), + ) + mux.Handle(path, svcHandler) + // Register gRPC reflection for tooling compatibility (grpcurl, etc.) + reflector := grpcreflect.NewStaticReflector( + "raystack.stencil.v1beta1.StencilService", + ) + mux.Handle(grpcreflect.NewHandlerV1(reflector)) + mux.Handle(grpcreflect.NewHandlerV1Alpha(reflector)) + + // Register custom HTTP handlers for schema binary endpoints + handler.RegisterSchemaHandlers(mux) + + // Health check endpoint + mux.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + _, _ = w.Write([]byte("pong")) + }) + + // UI SPA handler spaHandler, err := spa.Handler(ui.Assets, "build", "index.html", false) if err != nil { log.Fatalln("Failed to load spa:", err) } - rtr.PathPrefix("/ui").Handler(http.StripPrefix("/ui", spaHandler)) + mux.Handle("/ui/", http.StripPrefix("/ui", spaHandler)) - runWithGracefulShutdown(&cfg, grpcHandlerFunc(s, gatewayMux, rtr), func() { - conn.Close() - s.GracefulStop() - db.Close() + // CORS middleware + allowedOrigins := cfg.CORS.AllowedOrigins + if len(allowedOrigins) == 0 { + allowedOrigins = []string{"*"} + } + corsHandler := cors.New(cors.Options{ + AllowedOrigins: allowedOrigins, + AllowedMethods: connectcors.AllowedMethods(), + AllowedHeaders: connectcors.AllowedHeaders(), + ExposedHeaders: connectcors.ExposedHeaders(), }) -} -// grpcHandlerFunc returns an http.Handler that delegates to grpcServer on incoming gRPC -// connections or otherHandler otherwise. -func grpcHandlerFunc(grpcServer *grpc.Server, otherHandler http.Handler, uiHandler http.Handler) http.Handler { - return h2c.NewHandler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - // This is a partial recreation of gRPC's internal checks https://github.com/grpc/grpc-go/pull/514/files#diff-95e9a25b738459a2d3030e1e6fa2a718R61 - if r.ProtoMajor == 2 && strings.Contains(r.Header.Get("Content-Type"), "application/grpc") { - grpcServer.ServeHTTP(w, r) - } else { - if strings.HasPrefix(r.URL.Path, "/ui") { - uiHandler.ServeHTTP(w, r) - } else { - otherHandler.ServeHTTP(w, r) - } + // Create HTTP server with h2c support for HTTP/2 without TLS + addr := fmt.Sprintf(":%s", cfg.Port) + server := &http.Server{ + Addr: addr, + Handler: h2c.NewHandler(corsHandler.Handler(mux), &http2.Server{}), + ReadTimeout: 60 * time.Second, + WriteTimeout: 60 * time.Second, + IdleTimeout: 120 * time.Second, + } + + // Start server in goroutine + go func() { + logger.Info("starting server", "addr", addr) + if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { + log.Fatalf("server error: %v", err) } - }), &http2.Server{}) + }() + + // Wait for shutdown signal + quit := make(chan os.Signal, 2) + signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) + <-quit + + logger.Info("shutting down server") + ctx, cancel := context.WithTimeout(context.Background(), cfg.Timeout) + defer cancel() + + if err := server.Shutdown(ctx); err != nil { + log.Fatalf("server forced to shutdown: %v", err) + } + logger.Info("server stopped") } diff --git a/internal/store/errors.go b/internal/store/errors.go index 77b68a6a..f59adda7 100644 --- a/internal/store/errors.go +++ b/internal/store/errors.go @@ -3,8 +3,7 @@ package store import ( "fmt" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" + "connectrpc.com/connect" ) type errKind int @@ -39,15 +38,15 @@ func (e StorageErr) Error() string { return e.name } -// GRPCStatus this is used by gateway interceptor to return appropriate http status code and message -func (e StorageErr) GRPCStatus() *status.Status { +// ConnectError returns an appropriate Connect error for this storage error. +func (e StorageErr) ConnectError() *connect.Error { if e.kind == noRows { - return status.New(codes.NotFound, fmt.Sprintf("%s %s", e.name, "not found")) + return connect.NewError(connect.CodeNotFound, fmt.Errorf("%s %s", e.name, "not found")) } if e.kind == conflict { - return status.New(codes.AlreadyExists, fmt.Sprintf("%s %s", e.name, "resource already exists")) + return connect.NewError(connect.CodeAlreadyExists, fmt.Errorf("%s %s", e.name, "resource already exists")) } - return status.New(codes.Unknown, e.Error()) + return connect.NewError(connect.CodeUnknown, e) } // WithErr convenience function to override sentinel errors diff --git a/pkg/validator/validator.go b/pkg/validator/validator.go deleted file mode 100644 index de2cdd34..00000000 --- a/pkg/validator/validator.go +++ /dev/null @@ -1,95 +0,0 @@ -package validator - -import ( - "context" - "fmt" - "strings" - - "google.golang.org/genproto/googleapis/api/annotations" - "google.golang.org/grpc" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" - "google.golang.org/protobuf/proto" - "google.golang.org/protobuf/reflect/protoreflect" -) - -func checkIfFieldRequired(f protoreflect.FieldDescriptor) bool { - opts := f.Options() - v := opts.ProtoReflect().Get(annotations.E_FieldBehavior.TypeDescriptor()) - if v.List().IsValid() { - l := v.List() - for i := 0; i < l.Len(); i++ { - eVal := l.Get(i) - if annotations.FieldBehavior(eVal.Enum()) == annotations.FieldBehavior_REQUIRED { - return true - } - } - } - return false -} - -func checkValueExists(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool { - switch fd.Kind() { - case protoreflect.BytesKind: - d := v.Bytes() - return len(d) > 0 - case protoreflect.StringKind: - d := v.String() - return len(d) > 0 - case protoreflect.EnumKind: - d := v.Enum() - ed := fd.Enum().Values().ByNumber(d) - return ed != nil - default: - return true - } -} - -func addPrefix(prefix string, fieldNames []string) []string { - for i := 0; i < len(fieldNames); i++ { - field := fieldNames[i] - fieldNames[i] = fmt.Sprintf("%s.%s", prefix, field) - } - return fieldNames -} - -func validateMessage(m protoreflect.ProtoMessage) []string { - var missingFields []string - md := m.ProtoReflect().Descriptor() - fds := md.Fields() - for i := 0; i < fds.Len(); i++ { - fd := fds.Get(i) - v := m.ProtoReflect().Get(fd) - if fd.Kind() == protoreflect.MessageKind && proto.Size(v.Message().Interface()) != 0 { - nestedFields := validateMessage(v.Message().Interface()) - prefixedFields := addPrefix(fd.JSONName(), nestedFields) - missingFields = append(missingFields, prefixedFields...) - } - if checkIfFieldRequired(fd) && !checkValueExists(fd, v) { - missingFields = append(missingFields, fd.JSONName()) - } - } - return missingFields -} - -func validate(req interface{}) error { - msg, ok := req.(proto.Message) - if !ok { - return nil - } - missingFields := validateMessage(msg) - if len(missingFields) == 0 { - return nil - } - return status.Error(codes.InvalidArgument, fmt.Sprintf("following fields are missing: %s", strings.Join(missingFields, ", "))) -} - -// UnaryServerInterceptor interceptor for validating required fields -func UnaryServerInterceptor() grpc.UnaryServerInterceptor { - return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) { - if validErr := validate(req); validErr != nil { - return nil, validErr - } - return handler(ctx, req) - } -} diff --git a/proto/apidocs.swagger.json b/proto/apidocs.swagger.json deleted file mode 100644 index ed67272d..00000000 --- a/proto/apidocs.swagger.json +++ /dev/null @@ -1,777 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "raystack/stencil/v1beta1/stencil.proto", - "version": "0.1.4" - }, - "tags": [ - { - "name": "StencilService" - } - ], - "schemes": ["http"], - "consumes": ["application/json"], - "produces": ["application/json"], - "paths": { - "/v1beta1/namespaces": { - "get": { - "summary": "List names of namespaces", - "operationId": "StencilService_ListNamespaces", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1ListNamespacesResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "tags": ["namespace"] - }, - "post": { - "summary": "Create namespace entry", - "operationId": "StencilService_CreateNamespace", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1CreateNamespaceResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "body", - "in": "body", - "required": true, - "schema": { - "$ref": "#/definitions/v1beta1CreateNamespaceRequest" - } - } - ], - "tags": ["namespace"] - } - }, - "/v1beta1/namespaces/{id}": { - "get": { - "summary": "Get namespace by id", - "operationId": "StencilService_GetNamespace", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1GetNamespaceResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "id", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": ["namespace"] - }, - "delete": { - "summary": "Delete namespace by id", - "description": "Ensure all schemas under this namespace is deleted, otherwise it will throw error", - "operationId": "StencilService_DeleteNamespace", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1DeleteNamespaceResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "id", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": ["namespace"] - }, - "put": { - "summary": "Update namespace entity by id", - "operationId": "StencilService_UpdateNamespace", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1UpdateNamespaceResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "id", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "body", - "in": "body", - "required": true, - "schema": { - "type": "object", - "properties": { - "format": { - "$ref": "#/definitions/SchemaFormat" - }, - "compatibility": { - "$ref": "#/definitions/SchemaCompatibility" - }, - "description": { - "type": "string" - } - } - } - } - ], - "tags": ["namespace"] - } - }, - "/v1beta1/namespaces/{id}/schemas": { - "get": { - "summary": "List schemas under the namespace", - "operationId": "StencilService_ListSchemas", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1ListSchemasResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "id", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": ["schema"] - } - }, - "/v1beta1/namespaces/{namespaceId}/schemas/{schemaId}": { - "delete": { - "summary": "Delete specified schema", - "operationId": "StencilService_DeleteSchema", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1DeleteSchemaResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "namespaceId", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "schemaId", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": ["schema"] - }, - "patch": { - "summary": "Update only schema metadata", - "operationId": "StencilService_UpdateSchemaMetadata", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1UpdateSchemaMetadataResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "namespaceId", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "schemaId", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "body", - "in": "body", - "required": true, - "schema": { - "type": "object", - "properties": { - "compatibility": { - "$ref": "#/definitions/SchemaCompatibility" - } - } - } - } - ], - "tags": ["schema"] - } - }, - "/v1beta1/namespaces/{namespaceId}/schemas/{schemaId}/meta": { - "get": { - "summary": "Create schema under the namespace. Returns version number, unique ID and location", - "operationId": "StencilService_GetSchemaMetadata", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1GetSchemaMetadataResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "namespaceId", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "schemaId", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": ["schema"] - } - }, - "/v1beta1/namespaces/{namespaceId}/schemas/{schemaId}/versions": { - "get": { - "summary": "List all version numbers for schema", - "operationId": "StencilService_ListVersions", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1ListVersionsResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "namespaceId", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "schemaId", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": ["schema", "version"] - } - }, - "/v1beta1/namespaces/{namespaceId}/schemas/{schemaId}/versions/{versionId}": { - "delete": { - "summary": "Delete specified version of the schema", - "operationId": "StencilService_DeleteVersion", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1DeleteVersionResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "namespaceId", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "schemaId", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "versionId", - "in": "path", - "required": true, - "type": "integer", - "format": "int32" - } - ], - "tags": ["schema", "version"] - } - }, - "/v1beta1/search": { - "get": { - "summary": "Global Search API", - "operationId": "StencilService_Search", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1SearchResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "namespaceId", - "in": "query", - "required": false, - "type": "string" - }, - { - "name": "schemaId", - "in": "query", - "required": false, - "type": "string" - }, - { - "name": "query", - "in": "query", - "required": true, - "type": "string" - }, - { - "name": "history", - "in": "query", - "required": false, - "type": "boolean" - }, - { - "name": "versionId", - "in": "query", - "required": false, - "type": "integer", - "format": "int32" - } - ], - "tags": ["schema"] - } - } - }, - "definitions": { - "SchemaCompatibility": { - "type": "string", - "enum": [ - "COMPATIBILITY_UNSPECIFIED", - "COMPATIBILITY_BACKWARD", - "COMPATIBILITY_BACKWARD_TRANSITIVE", - "COMPATIBILITY_FORWARD", - "COMPATIBILITY_FORWARD_TRANSITIVE", - "COMPATIBILITY_FULL", - "COMPATIBILITY_FULL_TRANSITIVE" - ], - "default": "COMPATIBILITY_UNSPECIFIED" - }, - "SchemaFormat": { - "type": "string", - "enum": [ - "FORMAT_UNSPECIFIED", - "FORMAT_PROTOBUF", - "FORMAT_AVRO", - "FORMAT_JSON" - ], - "default": "FORMAT_UNSPECIFIED" - }, - "protobufAny": { - "type": "object", - "properties": { - "@type": { - "type": "string" - } - }, - "additionalProperties": {} - }, - "rpcStatus": { - "type": "object", - "properties": { - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - } - } - } - }, - "stencilv1beta1Schema": { - "type": "object", - "properties": { - "name": { - "type": "string" - }, - "format": { - "$ref": "#/definitions/SchemaFormat" - }, - "authority": { - "type": "string" - }, - "compatibility": { - "$ref": "#/definitions/SchemaCompatibility" - }, - "createdAt": { - "type": "string", - "format": "date-time" - }, - "updatedAt": { - "type": "string", - "format": "date-time" - } - } - }, - "v1beta1CheckCompatibilityResponse": { - "type": "object" - }, - "v1beta1CreateNamespaceRequest": { - "type": "object", - "properties": { - "id": { - "type": "string", - "required": ["id"] - }, - "format": { - "$ref": "#/definitions/SchemaFormat" - }, - "compatibility": { - "$ref": "#/definitions/SchemaCompatibility" - }, - "description": { - "type": "string" - } - }, - "required": ["id"] - }, - "v1beta1CreateNamespaceResponse": { - "type": "object", - "properties": { - "namespace": { - "$ref": "#/definitions/v1beta1Namespace" - } - } - }, - "v1beta1CreateSchemaResponse": { - "type": "object", - "properties": { - "version": { - "type": "integer", - "format": "int32" - }, - "id": { - "type": "string" - }, - "location": { - "type": "string" - } - } - }, - "v1beta1DeleteNamespaceResponse": { - "type": "object", - "properties": { - "message": { - "type": "string" - } - } - }, - "v1beta1DeleteSchemaResponse": { - "type": "object", - "properties": { - "message": { - "type": "string" - } - } - }, - "v1beta1DeleteVersionResponse": { - "type": "object", - "properties": { - "message": { - "type": "string" - } - } - }, - "v1beta1GetLatestSchemaResponse": { - "type": "object", - "properties": { - "data": { - "type": "string", - "format": "byte" - } - } - }, - "v1beta1GetNamespaceResponse": { - "type": "object", - "properties": { - "namespace": { - "$ref": "#/definitions/v1beta1Namespace" - } - } - }, - "v1beta1GetSchemaMetadataResponse": { - "type": "object", - "properties": { - "format": { - "$ref": "#/definitions/SchemaFormat" - }, - "compatibility": { - "$ref": "#/definitions/SchemaCompatibility" - }, - "authority": { - "type": "string" - }, - "name": { - "type": "string" - }, - "createdAt": { - "type": "string", - "format": "date-time" - }, - "updatedAt": { - "type": "string", - "format": "date-time" - } - } - }, - "v1beta1GetSchemaResponse": { - "type": "object", - "properties": { - "data": { - "type": "string", - "format": "byte" - } - } - }, - "v1beta1ListNamespacesResponse": { - "type": "object", - "properties": { - "namespaces": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1Namespace" - } - } - } - }, - "v1beta1ListSchemasResponse": { - "type": "object", - "properties": { - "schemas": { - "type": "array", - "items": { - "$ref": "#/definitions/stencilv1beta1Schema" - } - } - } - }, - "v1beta1ListVersionsResponse": { - "type": "object", - "properties": { - "versions": { - "type": "array", - "items": { - "type": "integer", - "format": "int32" - } - } - } - }, - "v1beta1Namespace": { - "type": "object", - "properties": { - "id": { - "type": "string" - }, - "format": { - "$ref": "#/definitions/SchemaFormat" - }, - "Compatibility": { - "$ref": "#/definitions/SchemaCompatibility" - }, - "description": { - "type": "string" - }, - "createdAt": { - "type": "string", - "format": "date-time" - }, - "updatedAt": { - "type": "string", - "format": "date-time" - } - } - }, - "v1beta1SearchHits": { - "type": "object", - "properties": { - "namespaceId": { - "type": "string" - }, - "schemaId": { - "type": "string" - }, - "versionId": { - "type": "integer", - "format": "int32" - }, - "fields": { - "type": "array", - "items": { - "type": "string" - } - }, - "types": { - "type": "array", - "items": { - "type": "string" - } - }, - "path": { - "type": "string" - } - } - }, - "v1beta1SearchMeta": { - "type": "object", - "properties": { - "total": { - "type": "integer", - "format": "int64" - } - } - }, - "v1beta1SearchResponse": { - "type": "object", - "properties": { - "hits": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1SearchHits" - } - }, - "meta": { - "$ref": "#/definitions/v1beta1SearchMeta" - } - } - }, - "v1beta1UpdateNamespaceResponse": { - "type": "object", - "properties": { - "namespace": { - "$ref": "#/definitions/v1beta1Namespace" - } - } - }, - "v1beta1UpdateSchemaMetadataResponse": { - "type": "object", - "properties": { - "format": { - "$ref": "#/definitions/SchemaFormat" - }, - "compatibility": { - "$ref": "#/definitions/SchemaCompatibility" - }, - "authority": { - "type": "string" - } - } - } - } -} diff --git a/proto/raystack/stencil/v1beta1/stencil.pb.go b/proto/raystack/stencil/v1beta1/stencil.pb.go deleted file mode 100644 index 5449873f..00000000 --- a/proto/raystack/stencil/v1beta1/stencil.pb.go +++ /dev/null @@ -1,3351 +0,0 @@ -// Code generated by protoc-gen-go. DO NOT EDIT. -// versions: -// protoc-gen-go v1.28.0 -// protoc (unknown) -// source: raystack/stencil/v1beta1/stencil.proto - -package stencilv1beta1 - -import ( - _ "github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2/options" - _ "google.golang.org/genproto/googleapis/api/annotations" - protoreflect "google.golang.org/protobuf/reflect/protoreflect" - protoimpl "google.golang.org/protobuf/runtime/protoimpl" - _ "google.golang.org/protobuf/types/descriptorpb" - timestamppb "google.golang.org/protobuf/types/known/timestamppb" - 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 Schema_Format int32 - -const ( - Schema_FORMAT_UNSPECIFIED Schema_Format = 0 - Schema_FORMAT_PROTOBUF Schema_Format = 1 - Schema_FORMAT_AVRO Schema_Format = 2 - Schema_FORMAT_JSON Schema_Format = 3 -) - -// Enum value maps for Schema_Format. -var ( - Schema_Format_name = map[int32]string{ - 0: "FORMAT_UNSPECIFIED", - 1: "FORMAT_PROTOBUF", - 2: "FORMAT_AVRO", - 3: "FORMAT_JSON", - } - Schema_Format_value = map[string]int32{ - "FORMAT_UNSPECIFIED": 0, - "FORMAT_PROTOBUF": 1, - "FORMAT_AVRO": 2, - "FORMAT_JSON": 3, - } -) - -func (x Schema_Format) Enum() *Schema_Format { - p := new(Schema_Format) - *p = x - return p -} - -func (x Schema_Format) String() string { - return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) -} - -func (Schema_Format) Descriptor() protoreflect.EnumDescriptor { - return file_raystack_stencil_v1beta1_stencil_proto_enumTypes[0].Descriptor() -} - -func (Schema_Format) Type() protoreflect.EnumType { - return &file_raystack_stencil_v1beta1_stencil_proto_enumTypes[0] -} - -func (x Schema_Format) Number() protoreflect.EnumNumber { - return protoreflect.EnumNumber(x) -} - -// Deprecated: Use Schema_Format.Descriptor instead. -func (Schema_Format) EnumDescriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{1, 0} -} - -type Schema_Compatibility int32 - -const ( - Schema_COMPATIBILITY_UNSPECIFIED Schema_Compatibility = 0 - Schema_COMPATIBILITY_BACKWARD Schema_Compatibility = 1 - Schema_COMPATIBILITY_BACKWARD_TRANSITIVE Schema_Compatibility = 2 - Schema_COMPATIBILITY_FORWARD Schema_Compatibility = 3 - Schema_COMPATIBILITY_FORWARD_TRANSITIVE Schema_Compatibility = 4 - Schema_COMPATIBILITY_FULL Schema_Compatibility = 5 - Schema_COMPATIBILITY_FULL_TRANSITIVE Schema_Compatibility = 6 -) - -// Enum value maps for Schema_Compatibility. -var ( - Schema_Compatibility_name = map[int32]string{ - 0: "COMPATIBILITY_UNSPECIFIED", - 1: "COMPATIBILITY_BACKWARD", - 2: "COMPATIBILITY_BACKWARD_TRANSITIVE", - 3: "COMPATIBILITY_FORWARD", - 4: "COMPATIBILITY_FORWARD_TRANSITIVE", - 5: "COMPATIBILITY_FULL", - 6: "COMPATIBILITY_FULL_TRANSITIVE", - } - Schema_Compatibility_value = map[string]int32{ - "COMPATIBILITY_UNSPECIFIED": 0, - "COMPATIBILITY_BACKWARD": 1, - "COMPATIBILITY_BACKWARD_TRANSITIVE": 2, - "COMPATIBILITY_FORWARD": 3, - "COMPATIBILITY_FORWARD_TRANSITIVE": 4, - "COMPATIBILITY_FULL": 5, - "COMPATIBILITY_FULL_TRANSITIVE": 6, - } -) - -func (x Schema_Compatibility) Enum() *Schema_Compatibility { - p := new(Schema_Compatibility) - *p = x - return p -} - -func (x Schema_Compatibility) String() string { - return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) -} - -func (Schema_Compatibility) Descriptor() protoreflect.EnumDescriptor { - return file_raystack_stencil_v1beta1_stencil_proto_enumTypes[1].Descriptor() -} - -func (Schema_Compatibility) Type() protoreflect.EnumType { - return &file_raystack_stencil_v1beta1_stencil_proto_enumTypes[1] -} - -func (x Schema_Compatibility) Number() protoreflect.EnumNumber { - return protoreflect.EnumNumber(x) -} - -// Deprecated: Use Schema_Compatibility.Descriptor instead. -func (Schema_Compatibility) EnumDescriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{1, 1} -} - -type Namespace struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Format Schema_Format `protobuf:"varint,2,opt,name=format,proto3,enum=raystack.stencil.v1beta1.Schema_Format" json:"format,omitempty"` - Compatibility Schema_Compatibility `protobuf:"varint,3,opt,name=Compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"Compatibility,omitempty"` - Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` - CreatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` - UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` -} - -func (x *Namespace) Reset() { - *x = Namespace{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[0] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Namespace) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Namespace) ProtoMessage() {} - -func (x *Namespace) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_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 Namespace.ProtoReflect.Descriptor instead. -func (*Namespace) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{0} -} - -func (x *Namespace) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *Namespace) GetFormat() Schema_Format { - if x != nil { - return x.Format - } - return Schema_FORMAT_UNSPECIFIED -} - -func (x *Namespace) GetCompatibility() Schema_Compatibility { - if x != nil { - return x.Compatibility - } - return Schema_COMPATIBILITY_UNSPECIFIED -} - -func (x *Namespace) GetDescription() string { - if x != nil { - return x.Description - } - return "" -} - -func (x *Namespace) GetCreatedAt() *timestamppb.Timestamp { - if x != nil { - return x.CreatedAt - } - return nil -} - -func (x *Namespace) GetUpdatedAt() *timestamppb.Timestamp { - if x != nil { - return x.UpdatedAt - } - return nil -} - -type Schema struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Format Schema_Format `protobuf:"varint,2,opt,name=format,proto3,enum=raystack.stencil.v1beta1.Schema_Format" json:"format,omitempty"` - Authority string `protobuf:"bytes,3,opt,name=authority,proto3" json:"authority,omitempty"` - Compatibility Schema_Compatibility `protobuf:"varint,4,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` - CreatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` - UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` -} - -func (x *Schema) Reset() { - *x = Schema{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[1] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *Schema) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Schema) ProtoMessage() {} - -func (x *Schema) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_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 Schema.ProtoReflect.Descriptor instead. -func (*Schema) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{1} -} - -func (x *Schema) GetName() string { - if x != nil { - return x.Name - } - return "" -} - -func (x *Schema) GetFormat() Schema_Format { - if x != nil { - return x.Format - } - return Schema_FORMAT_UNSPECIFIED -} - -func (x *Schema) GetAuthority() string { - if x != nil { - return x.Authority - } - return "" -} - -func (x *Schema) GetCompatibility() Schema_Compatibility { - if x != nil { - return x.Compatibility - } - return Schema_COMPATIBILITY_UNSPECIFIED -} - -func (x *Schema) GetCreatedAt() *timestamppb.Timestamp { - if x != nil { - return x.CreatedAt - } - return nil -} - -func (x *Schema) GetUpdatedAt() *timestamppb.Timestamp { - if x != nil { - return x.UpdatedAt - } - return nil -} - -type ListNamespacesRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields -} - -func (x *ListNamespacesRequest) Reset() { - *x = ListNamespacesRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[2] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *ListNamespacesRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ListNamespacesRequest) ProtoMessage() {} - -func (x *ListNamespacesRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_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 ListNamespacesRequest.ProtoReflect.Descriptor instead. -func (*ListNamespacesRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{2} -} - -type ListNamespacesResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Namespaces []*Namespace `protobuf:"bytes,1,rep,name=namespaces,proto3" json:"namespaces,omitempty"` -} - -func (x *ListNamespacesResponse) Reset() { - *x = ListNamespacesResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[3] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *ListNamespacesResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ListNamespacesResponse) ProtoMessage() {} - -func (x *ListNamespacesResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_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 ListNamespacesResponse.ProtoReflect.Descriptor instead. -func (*ListNamespacesResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{3} -} - -func (x *ListNamespacesResponse) GetNamespaces() []*Namespace { - if x != nil { - return x.Namespaces - } - return nil -} - -type GetNamespaceRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` -} - -func (x *GetNamespaceRequest) Reset() { - *x = GetNamespaceRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[4] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *GetNamespaceRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetNamespaceRequest) ProtoMessage() {} - -func (x *GetNamespaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_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 GetNamespaceRequest.ProtoReflect.Descriptor instead. -func (*GetNamespaceRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{4} -} - -func (x *GetNamespaceRequest) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -type GetNamespaceResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Namespace *Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"` -} - -func (x *GetNamespaceResponse) Reset() { - *x = GetNamespaceResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[5] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *GetNamespaceResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetNamespaceResponse) ProtoMessage() {} - -func (x *GetNamespaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_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 GetNamespaceResponse.ProtoReflect.Descriptor instead. -func (*GetNamespaceResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{5} -} - -func (x *GetNamespaceResponse) GetNamespace() *Namespace { - if x != nil { - return x.Namespace - } - return nil -} - -type CreateNamespaceRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Format Schema_Format `protobuf:"varint,2,opt,name=format,proto3,enum=raystack.stencil.v1beta1.Schema_Format" json:"format,omitempty"` - Compatibility Schema_Compatibility `protobuf:"varint,3,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` - Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` -} - -func (x *CreateNamespaceRequest) Reset() { - *x = CreateNamespaceRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[6] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *CreateNamespaceRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*CreateNamespaceRequest) ProtoMessage() {} - -func (x *CreateNamespaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_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 CreateNamespaceRequest.ProtoReflect.Descriptor instead. -func (*CreateNamespaceRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{6} -} - -func (x *CreateNamespaceRequest) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *CreateNamespaceRequest) GetFormat() Schema_Format { - if x != nil { - return x.Format - } - return Schema_FORMAT_UNSPECIFIED -} - -func (x *CreateNamespaceRequest) GetCompatibility() Schema_Compatibility { - if x != nil { - return x.Compatibility - } - return Schema_COMPATIBILITY_UNSPECIFIED -} - -func (x *CreateNamespaceRequest) GetDescription() string { - if x != nil { - return x.Description - } - return "" -} - -type CreateNamespaceResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Namespace *Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"` -} - -func (x *CreateNamespaceResponse) Reset() { - *x = CreateNamespaceResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[7] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *CreateNamespaceResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*CreateNamespaceResponse) ProtoMessage() {} - -func (x *CreateNamespaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_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 CreateNamespaceResponse.ProtoReflect.Descriptor instead. -func (*CreateNamespaceResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{7} -} - -func (x *CreateNamespaceResponse) GetNamespace() *Namespace { - if x != nil { - return x.Namespace - } - return nil -} - -type UpdateNamespaceRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Format Schema_Format `protobuf:"varint,2,opt,name=format,proto3,enum=raystack.stencil.v1beta1.Schema_Format" json:"format,omitempty"` - Compatibility Schema_Compatibility `protobuf:"varint,3,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` - Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` -} - -func (x *UpdateNamespaceRequest) Reset() { - *x = UpdateNamespaceRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[8] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *UpdateNamespaceRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*UpdateNamespaceRequest) ProtoMessage() {} - -func (x *UpdateNamespaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_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 UpdateNamespaceRequest.ProtoReflect.Descriptor instead. -func (*UpdateNamespaceRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{8} -} - -func (x *UpdateNamespaceRequest) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *UpdateNamespaceRequest) GetFormat() Schema_Format { - if x != nil { - return x.Format - } - return Schema_FORMAT_UNSPECIFIED -} - -func (x *UpdateNamespaceRequest) GetCompatibility() Schema_Compatibility { - if x != nil { - return x.Compatibility - } - return Schema_COMPATIBILITY_UNSPECIFIED -} - -func (x *UpdateNamespaceRequest) GetDescription() string { - if x != nil { - return x.Description - } - return "" -} - -type UpdateNamespaceResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Namespace *Namespace `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"` -} - -func (x *UpdateNamespaceResponse) Reset() { - *x = UpdateNamespaceResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[9] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *UpdateNamespaceResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*UpdateNamespaceResponse) ProtoMessage() {} - -func (x *UpdateNamespaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_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 UpdateNamespaceResponse.ProtoReflect.Descriptor instead. -func (*UpdateNamespaceResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{9} -} - -func (x *UpdateNamespaceResponse) GetNamespace() *Namespace { - if x != nil { - return x.Namespace - } - return nil -} - -type DeleteNamespaceRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` -} - -func (x *DeleteNamespaceRequest) Reset() { - *x = DeleteNamespaceRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[10] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *DeleteNamespaceRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*DeleteNamespaceRequest) ProtoMessage() {} - -func (x *DeleteNamespaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[10] - 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 DeleteNamespaceRequest.ProtoReflect.Descriptor instead. -func (*DeleteNamespaceRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{10} -} - -func (x *DeleteNamespaceRequest) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -type DeleteNamespaceResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` -} - -func (x *DeleteNamespaceResponse) Reset() { - *x = DeleteNamespaceResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[11] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *DeleteNamespaceResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*DeleteNamespaceResponse) ProtoMessage() {} - -func (x *DeleteNamespaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[11] - 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 DeleteNamespaceResponse.ProtoReflect.Descriptor instead. -func (*DeleteNamespaceResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{11} -} - -func (x *DeleteNamespaceResponse) GetMessage() string { - if x != nil { - return x.Message - } - return "" -} - -type ListSchemasRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` -} - -func (x *ListSchemasRequest) Reset() { - *x = ListSchemasRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[12] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *ListSchemasRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ListSchemasRequest) ProtoMessage() {} - -func (x *ListSchemasRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[12] - 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 ListSchemasRequest.ProtoReflect.Descriptor instead. -func (*ListSchemasRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{12} -} - -func (x *ListSchemasRequest) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -type ListSchemasResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Schemas []*Schema `protobuf:"bytes,1,rep,name=schemas,proto3" json:"schemas,omitempty"` -} - -func (x *ListSchemasResponse) Reset() { - *x = ListSchemasResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[13] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *ListSchemasResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ListSchemasResponse) ProtoMessage() {} - -func (x *ListSchemasResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[13] - 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 ListSchemasResponse.ProtoReflect.Descriptor instead. -func (*ListSchemasResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{13} -} - -func (x *ListSchemasResponse) GetSchemas() []*Schema { - if x != nil { - return x.Schemas - } - return nil -} - -type GetLatestSchemaRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` - SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` -} - -func (x *GetLatestSchemaRequest) Reset() { - *x = GetLatestSchemaRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[14] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *GetLatestSchemaRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetLatestSchemaRequest) ProtoMessage() {} - -func (x *GetLatestSchemaRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[14] - 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 GetLatestSchemaRequest.ProtoReflect.Descriptor instead. -func (*GetLatestSchemaRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{14} -} - -func (x *GetLatestSchemaRequest) GetNamespaceId() string { - if x != nil { - return x.NamespaceId - } - return "" -} - -func (x *GetLatestSchemaRequest) GetSchemaId() string { - if x != nil { - return x.SchemaId - } - return "" -} - -type GetLatestSchemaResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` -} - -func (x *GetLatestSchemaResponse) Reset() { - *x = GetLatestSchemaResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[15] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *GetLatestSchemaResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetLatestSchemaResponse) ProtoMessage() {} - -func (x *GetLatestSchemaResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[15] - 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 GetLatestSchemaResponse.ProtoReflect.Descriptor instead. -func (*GetLatestSchemaResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{15} -} - -func (x *GetLatestSchemaResponse) GetData() []byte { - if x != nil { - return x.Data - } - return nil -} - -type CreateSchemaRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` - SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` - Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` - Format Schema_Format `protobuf:"varint,4,opt,name=format,proto3,enum=raystack.stencil.v1beta1.Schema_Format" json:"format,omitempty"` - Compatibility Schema_Compatibility `protobuf:"varint,5,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` -} - -func (x *CreateSchemaRequest) Reset() { - *x = CreateSchemaRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[16] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *CreateSchemaRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*CreateSchemaRequest) ProtoMessage() {} - -func (x *CreateSchemaRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[16] - 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 CreateSchemaRequest.ProtoReflect.Descriptor instead. -func (*CreateSchemaRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{16} -} - -func (x *CreateSchemaRequest) GetNamespaceId() string { - if x != nil { - return x.NamespaceId - } - return "" -} - -func (x *CreateSchemaRequest) GetSchemaId() string { - if x != nil { - return x.SchemaId - } - return "" -} - -func (x *CreateSchemaRequest) GetData() []byte { - if x != nil { - return x.Data - } - return nil -} - -func (x *CreateSchemaRequest) GetFormat() Schema_Format { - if x != nil { - return x.Format - } - return Schema_FORMAT_UNSPECIFIED -} - -func (x *CreateSchemaRequest) GetCompatibility() Schema_Compatibility { - if x != nil { - return x.Compatibility - } - return Schema_COMPATIBILITY_UNSPECIFIED -} - -type CreateSchemaResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Version int32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"` - Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` - Location string `protobuf:"bytes,3,opt,name=location,proto3" json:"location,omitempty"` -} - -func (x *CreateSchemaResponse) Reset() { - *x = CreateSchemaResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[17] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *CreateSchemaResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*CreateSchemaResponse) ProtoMessage() {} - -func (x *CreateSchemaResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[17] - 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 CreateSchemaResponse.ProtoReflect.Descriptor instead. -func (*CreateSchemaResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{17} -} - -func (x *CreateSchemaResponse) GetVersion() int32 { - if x != nil { - return x.Version - } - return 0 -} - -func (x *CreateSchemaResponse) GetId() string { - if x != nil { - return x.Id - } - return "" -} - -func (x *CreateSchemaResponse) GetLocation() string { - if x != nil { - return x.Location - } - return "" -} - -type CheckCompatibilityRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` - SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` - Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` - Compatibility Schema_Compatibility `protobuf:"varint,4,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` -} - -func (x *CheckCompatibilityRequest) Reset() { - *x = CheckCompatibilityRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[18] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *CheckCompatibilityRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*CheckCompatibilityRequest) ProtoMessage() {} - -func (x *CheckCompatibilityRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[18] - 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 CheckCompatibilityRequest.ProtoReflect.Descriptor instead. -func (*CheckCompatibilityRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{18} -} - -func (x *CheckCompatibilityRequest) GetNamespaceId() string { - if x != nil { - return x.NamespaceId - } - return "" -} - -func (x *CheckCompatibilityRequest) GetSchemaId() string { - if x != nil { - return x.SchemaId - } - return "" -} - -func (x *CheckCompatibilityRequest) GetData() []byte { - if x != nil { - return x.Data - } - return nil -} - -func (x *CheckCompatibilityRequest) GetCompatibility() Schema_Compatibility { - if x != nil { - return x.Compatibility - } - return Schema_COMPATIBILITY_UNSPECIFIED -} - -type CheckCompatibilityResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields -} - -func (x *CheckCompatibilityResponse) Reset() { - *x = CheckCompatibilityResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[19] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *CheckCompatibilityResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*CheckCompatibilityResponse) ProtoMessage() {} - -func (x *CheckCompatibilityResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[19] - 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 CheckCompatibilityResponse.ProtoReflect.Descriptor instead. -func (*CheckCompatibilityResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{19} -} - -type GetSchemaMetadataRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` - SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` -} - -func (x *GetSchemaMetadataRequest) Reset() { - *x = GetSchemaMetadataRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[20] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *GetSchemaMetadataRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetSchemaMetadataRequest) ProtoMessage() {} - -func (x *GetSchemaMetadataRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[20] - 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 GetSchemaMetadataRequest.ProtoReflect.Descriptor instead. -func (*GetSchemaMetadataRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{20} -} - -func (x *GetSchemaMetadataRequest) GetNamespaceId() string { - if x != nil { - return x.NamespaceId - } - return "" -} - -func (x *GetSchemaMetadataRequest) GetSchemaId() string { - if x != nil { - return x.SchemaId - } - return "" -} - -type GetSchemaMetadataResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Format Schema_Format `protobuf:"varint,1,opt,name=format,proto3,enum=raystack.stencil.v1beta1.Schema_Format" json:"format,omitempty"` - Compatibility Schema_Compatibility `protobuf:"varint,2,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` - Authority string `protobuf:"bytes,3,opt,name=authority,proto3" json:"authority,omitempty"` - Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` - CreatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` - UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"` -} - -func (x *GetSchemaMetadataResponse) Reset() { - *x = GetSchemaMetadataResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[21] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *GetSchemaMetadataResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetSchemaMetadataResponse) ProtoMessage() {} - -func (x *GetSchemaMetadataResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[21] - 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 GetSchemaMetadataResponse.ProtoReflect.Descriptor instead. -func (*GetSchemaMetadataResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{21} -} - -func (x *GetSchemaMetadataResponse) GetFormat() Schema_Format { - if x != nil { - return x.Format - } - return Schema_FORMAT_UNSPECIFIED -} - -func (x *GetSchemaMetadataResponse) GetCompatibility() Schema_Compatibility { - if x != nil { - return x.Compatibility - } - return Schema_COMPATIBILITY_UNSPECIFIED -} - -func (x *GetSchemaMetadataResponse) GetAuthority() string { - if x != nil { - return x.Authority - } - return "" -} - -func (x *GetSchemaMetadataResponse) GetName() string { - if x != nil { - return x.Name - } - return "" -} - -func (x *GetSchemaMetadataResponse) GetCreatedAt() *timestamppb.Timestamp { - if x != nil { - return x.CreatedAt - } - return nil -} - -func (x *GetSchemaMetadataResponse) GetUpdatedAt() *timestamppb.Timestamp { - if x != nil { - return x.UpdatedAt - } - return nil -} - -type UpdateSchemaMetadataRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` - SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` - Compatibility Schema_Compatibility `protobuf:"varint,3,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` -} - -func (x *UpdateSchemaMetadataRequest) Reset() { - *x = UpdateSchemaMetadataRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[22] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *UpdateSchemaMetadataRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*UpdateSchemaMetadataRequest) ProtoMessage() {} - -func (x *UpdateSchemaMetadataRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[22] - 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 UpdateSchemaMetadataRequest.ProtoReflect.Descriptor instead. -func (*UpdateSchemaMetadataRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{22} -} - -func (x *UpdateSchemaMetadataRequest) GetNamespaceId() string { - if x != nil { - return x.NamespaceId - } - return "" -} - -func (x *UpdateSchemaMetadataRequest) GetSchemaId() string { - if x != nil { - return x.SchemaId - } - return "" -} - -func (x *UpdateSchemaMetadataRequest) GetCompatibility() Schema_Compatibility { - if x != nil { - return x.Compatibility - } - return Schema_COMPATIBILITY_UNSPECIFIED -} - -type UpdateSchemaMetadataResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Format Schema_Format `protobuf:"varint,1,opt,name=format,proto3,enum=raystack.stencil.v1beta1.Schema_Format" json:"format,omitempty"` - Compatibility Schema_Compatibility `protobuf:"varint,2,opt,name=compatibility,proto3,enum=raystack.stencil.v1beta1.Schema_Compatibility" json:"compatibility,omitempty"` - Authority string `protobuf:"bytes,3,opt,name=authority,proto3" json:"authority,omitempty"` -} - -func (x *UpdateSchemaMetadataResponse) Reset() { - *x = UpdateSchemaMetadataResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[23] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *UpdateSchemaMetadataResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*UpdateSchemaMetadataResponse) ProtoMessage() {} - -func (x *UpdateSchemaMetadataResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[23] - 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 UpdateSchemaMetadataResponse.ProtoReflect.Descriptor instead. -func (*UpdateSchemaMetadataResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{23} -} - -func (x *UpdateSchemaMetadataResponse) GetFormat() Schema_Format { - if x != nil { - return x.Format - } - return Schema_FORMAT_UNSPECIFIED -} - -func (x *UpdateSchemaMetadataResponse) GetCompatibility() Schema_Compatibility { - if x != nil { - return x.Compatibility - } - return Schema_COMPATIBILITY_UNSPECIFIED -} - -func (x *UpdateSchemaMetadataResponse) GetAuthority() string { - if x != nil { - return x.Authority - } - return "" -} - -type DeleteSchemaRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` - SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` -} - -func (x *DeleteSchemaRequest) Reset() { - *x = DeleteSchemaRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[24] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *DeleteSchemaRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*DeleteSchemaRequest) ProtoMessage() {} - -func (x *DeleteSchemaRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[24] - 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 DeleteSchemaRequest.ProtoReflect.Descriptor instead. -func (*DeleteSchemaRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{24} -} - -func (x *DeleteSchemaRequest) GetNamespaceId() string { - if x != nil { - return x.NamespaceId - } - return "" -} - -func (x *DeleteSchemaRequest) GetSchemaId() string { - if x != nil { - return x.SchemaId - } - return "" -} - -type DeleteSchemaResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` -} - -func (x *DeleteSchemaResponse) Reset() { - *x = DeleteSchemaResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[25] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *DeleteSchemaResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*DeleteSchemaResponse) ProtoMessage() {} - -func (x *DeleteSchemaResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[25] - 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 DeleteSchemaResponse.ProtoReflect.Descriptor instead. -func (*DeleteSchemaResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{25} -} - -func (x *DeleteSchemaResponse) GetMessage() string { - if x != nil { - return x.Message - } - return "" -} - -type ListVersionsRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` - SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` -} - -func (x *ListVersionsRequest) Reset() { - *x = ListVersionsRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[26] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *ListVersionsRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ListVersionsRequest) ProtoMessage() {} - -func (x *ListVersionsRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[26] - 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 ListVersionsRequest.ProtoReflect.Descriptor instead. -func (*ListVersionsRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{26} -} - -func (x *ListVersionsRequest) GetNamespaceId() string { - if x != nil { - return x.NamespaceId - } - return "" -} - -func (x *ListVersionsRequest) GetSchemaId() string { - if x != nil { - return x.SchemaId - } - return "" -} - -type ListVersionsResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Versions []int32 `protobuf:"varint,1,rep,packed,name=versions,proto3" json:"versions,omitempty"` -} - -func (x *ListVersionsResponse) Reset() { - *x = ListVersionsResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[27] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *ListVersionsResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*ListVersionsResponse) ProtoMessage() {} - -func (x *ListVersionsResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[27] - 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 ListVersionsResponse.ProtoReflect.Descriptor instead. -func (*ListVersionsResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{27} -} - -func (x *ListVersionsResponse) GetVersions() []int32 { - if x != nil { - return x.Versions - } - return nil -} - -type GetSchemaRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` - SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` - VersionId int32 `protobuf:"varint,3,opt,name=version_id,json=versionId,proto3" json:"version_id,omitempty"` -} - -func (x *GetSchemaRequest) Reset() { - *x = GetSchemaRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[28] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *GetSchemaRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetSchemaRequest) ProtoMessage() {} - -func (x *GetSchemaRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[28] - 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 GetSchemaRequest.ProtoReflect.Descriptor instead. -func (*GetSchemaRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{28} -} - -func (x *GetSchemaRequest) GetNamespaceId() string { - if x != nil { - return x.NamespaceId - } - return "" -} - -func (x *GetSchemaRequest) GetSchemaId() string { - if x != nil { - return x.SchemaId - } - return "" -} - -func (x *GetSchemaRequest) GetVersionId() int32 { - if x != nil { - return x.VersionId - } - return 0 -} - -type GetSchemaResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` -} - -func (x *GetSchemaResponse) Reset() { - *x = GetSchemaResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[29] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *GetSchemaResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*GetSchemaResponse) ProtoMessage() {} - -func (x *GetSchemaResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[29] - 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 GetSchemaResponse.ProtoReflect.Descriptor instead. -func (*GetSchemaResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{29} -} - -func (x *GetSchemaResponse) GetData() []byte { - if x != nil { - return x.Data - } - return nil -} - -type DeleteVersionRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` - SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` - VersionId int32 `protobuf:"varint,3,opt,name=version_id,json=versionId,proto3" json:"version_id,omitempty"` -} - -func (x *DeleteVersionRequest) Reset() { - *x = DeleteVersionRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[30] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *DeleteVersionRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*DeleteVersionRequest) ProtoMessage() {} - -func (x *DeleteVersionRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[30] - 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 DeleteVersionRequest.ProtoReflect.Descriptor instead. -func (*DeleteVersionRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{30} -} - -func (x *DeleteVersionRequest) GetNamespaceId() string { - if x != nil { - return x.NamespaceId - } - return "" -} - -func (x *DeleteVersionRequest) GetSchemaId() string { - if x != nil { - return x.SchemaId - } - return "" -} - -func (x *DeleteVersionRequest) GetVersionId() int32 { - if x != nil { - return x.VersionId - } - return 0 -} - -type DeleteVersionResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` -} - -func (x *DeleteVersionResponse) Reset() { - *x = DeleteVersionResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[31] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *DeleteVersionResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*DeleteVersionResponse) ProtoMessage() {} - -func (x *DeleteVersionResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[31] - 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 DeleteVersionResponse.ProtoReflect.Descriptor instead. -func (*DeleteVersionResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{31} -} - -func (x *DeleteVersionResponse) GetMessage() string { - if x != nil { - return x.Message - } - return "" -} - -type SearchRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` - SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` - Query string `protobuf:"bytes,3,opt,name=query,proto3" json:"query,omitempty"` - // Types that are assignable to Version: - // - // *SearchRequest_History - // *SearchRequest_VersionId - Version isSearchRequest_Version `protobuf_oneof:"version"` -} - -func (x *SearchRequest) Reset() { - *x = SearchRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[32] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *SearchRequest) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SearchRequest) ProtoMessage() {} - -func (x *SearchRequest) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[32] - 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 SearchRequest.ProtoReflect.Descriptor instead. -func (*SearchRequest) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{32} -} - -func (x *SearchRequest) GetNamespaceId() string { - if x != nil { - return x.NamespaceId - } - return "" -} - -func (x *SearchRequest) GetSchemaId() string { - if x != nil { - return x.SchemaId - } - return "" -} - -func (x *SearchRequest) GetQuery() string { - if x != nil { - return x.Query - } - return "" -} - -func (m *SearchRequest) GetVersion() isSearchRequest_Version { - if m != nil { - return m.Version - } - return nil -} - -func (x *SearchRequest) GetHistory() bool { - if x, ok := x.GetVersion().(*SearchRequest_History); ok { - return x.History - } - return false -} - -func (x *SearchRequest) GetVersionId() int32 { - if x, ok := x.GetVersion().(*SearchRequest_VersionId); ok { - return x.VersionId - } - return 0 -} - -type isSearchRequest_Version interface { - isSearchRequest_Version() -} - -type SearchRequest_History struct { - History bool `protobuf:"varint,4,opt,name=history,proto3,oneof"` -} - -type SearchRequest_VersionId struct { - VersionId int32 `protobuf:"varint,5,opt,name=version_id,json=versionId,proto3,oneof"` -} - -func (*SearchRequest_History) isSearchRequest_Version() {} - -func (*SearchRequest_VersionId) isSearchRequest_Version() {} - -type SearchResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Hits []*SearchHits `protobuf:"bytes,1,rep,name=hits,proto3" json:"hits,omitempty"` - Meta *SearchMeta `protobuf:"bytes,2,opt,name=meta,proto3" json:"meta,omitempty"` -} - -func (x *SearchResponse) Reset() { - *x = SearchResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[33] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *SearchResponse) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SearchResponse) ProtoMessage() {} - -func (x *SearchResponse) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[33] - 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 SearchResponse.ProtoReflect.Descriptor instead. -func (*SearchResponse) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{33} -} - -func (x *SearchResponse) GetHits() []*SearchHits { - if x != nil { - return x.Hits - } - return nil -} - -func (x *SearchResponse) GetMeta() *SearchMeta { - if x != nil { - return x.Meta - } - return nil -} - -type SearchHits struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` - SchemaId string `protobuf:"bytes,2,opt,name=schema_id,json=schemaId,proto3" json:"schema_id,omitempty"` - VersionId int32 `protobuf:"varint,3,opt,name=version_id,json=versionId,proto3" json:"version_id,omitempty"` - Fields []string `protobuf:"bytes,4,rep,name=fields,proto3" json:"fields,omitempty"` - Types []string `protobuf:"bytes,5,rep,name=types,proto3" json:"types,omitempty"` - Path string `protobuf:"bytes,6,opt,name=path,proto3" json:"path,omitempty"` -} - -func (x *SearchHits) Reset() { - *x = SearchHits{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[34] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *SearchHits) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SearchHits) ProtoMessage() {} - -func (x *SearchHits) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[34] - 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 SearchHits.ProtoReflect.Descriptor instead. -func (*SearchHits) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{34} -} - -func (x *SearchHits) GetNamespaceId() string { - if x != nil { - return x.NamespaceId - } - return "" -} - -func (x *SearchHits) GetSchemaId() string { - if x != nil { - return x.SchemaId - } - return "" -} - -func (x *SearchHits) GetVersionId() int32 { - if x != nil { - return x.VersionId - } - return 0 -} - -func (x *SearchHits) GetFields() []string { - if x != nil { - return x.Fields - } - return nil -} - -func (x *SearchHits) GetTypes() []string { - if x != nil { - return x.Types - } - return nil -} - -func (x *SearchHits) GetPath() string { - if x != nil { - return x.Path - } - return "" -} - -type SearchMeta struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Total uint32 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"` -} - -func (x *SearchMeta) Reset() { - *x = SearchMeta{} - if protoimpl.UnsafeEnabled { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[35] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *SearchMeta) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*SearchMeta) ProtoMessage() {} - -func (x *SearchMeta) ProtoReflect() protoreflect.Message { - mi := &file_raystack_stencil_v1beta1_stencil_proto_msgTypes[35] - 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 SearchMeta.ProtoReflect.Descriptor instead. -func (*SearchMeta) Descriptor() ([]byte, []int) { - return file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP(), []int{35} -} - -func (x *SearchMeta) GetTotal() uint32 { - if x != nil { - return x.Total - } - return 0 -} - -var File_raystack_stencil_v1beta1_stencil_proto protoreflect.FileDescriptor - -var file_raystack_stencil_v1beta1_stencil_proto_rawDesc = []byte{ - 0x0a, 0x22, 0x6f, 0x64, 0x70, 0x66, 0x2f, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2f, 0x76, - 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x14, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, - 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, - 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, - 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x62, 0x65, 0x68, 0x61, 0x76, - 0x69, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, - 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, - 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, - 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, - 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x63, 0x2d, 0x67, 0x65, 0x6e, 0x2d, 0x6f, 0x70, 0x65, 0x6e, 0x61, 0x70, 0x69, - 0x76, 0x32, 0x2f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc2, 0x02, 0x0a, - 0x09, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3b, 0x0a, 0x06, 0x66, 0x6f, - 0x72, 0x6d, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x6f, 0x64, 0x70, - 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, - 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x50, 0x0a, 0x0d, 0x43, 0x6f, 0x6d, 0x70, 0x61, - 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, - 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, - 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x43, 0x6f, 0x6d, - 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x0d, 0x43, 0x6f, 0x6d, 0x70, - 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, - 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, - 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x39, 0x0a, 0x0a, 0x63, - 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 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, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x63, 0x72, 0x65, - 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, - 0x64, 0x5f, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, - 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, - 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, - 0x74, 0x22, 0x88, 0x05, 0x0a, 0x06, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x12, 0x0a, 0x04, - 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, - 0x12, 0x3b, 0x0a, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, - 0x32, 0x23, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, - 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x46, - 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x1c, 0x0a, - 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x50, 0x0a, 0x0d, 0x63, - 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, - 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, - 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x0d, - 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x39, 0x0a, - 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 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, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x63, - 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x75, 0x70, 0x64, 0x61, - 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, - 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, - 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, - 0x64, 0x41, 0x74, 0x22, 0x57, 0x0a, 0x06, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x16, 0x0a, - 0x12, 0x46, 0x4f, 0x52, 0x4d, 0x41, 0x54, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, - 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x46, 0x4f, 0x52, 0x4d, 0x41, 0x54, 0x5f, - 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x42, 0x55, 0x46, 0x10, 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x46, 0x4f, - 0x52, 0x4d, 0x41, 0x54, 0x5f, 0x41, 0x56, 0x52, 0x4f, 0x10, 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x46, - 0x4f, 0x52, 0x4d, 0x41, 0x54, 0x5f, 0x4a, 0x53, 0x4f, 0x4e, 0x10, 0x03, 0x22, 0xed, 0x01, 0x0a, - 0x0d, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x1d, - 0x0a, 0x19, 0x43, 0x4f, 0x4d, 0x50, 0x41, 0x54, 0x49, 0x42, 0x49, 0x4c, 0x49, 0x54, 0x59, 0x5f, - 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1a, 0x0a, - 0x16, 0x43, 0x4f, 0x4d, 0x50, 0x41, 0x54, 0x49, 0x42, 0x49, 0x4c, 0x49, 0x54, 0x59, 0x5f, 0x42, - 0x41, 0x43, 0x4b, 0x57, 0x41, 0x52, 0x44, 0x10, 0x01, 0x12, 0x25, 0x0a, 0x21, 0x43, 0x4f, 0x4d, - 0x50, 0x41, 0x54, 0x49, 0x42, 0x49, 0x4c, 0x49, 0x54, 0x59, 0x5f, 0x42, 0x41, 0x43, 0x4b, 0x57, - 0x41, 0x52, 0x44, 0x5f, 0x54, 0x52, 0x41, 0x4e, 0x53, 0x49, 0x54, 0x49, 0x56, 0x45, 0x10, 0x02, - 0x12, 0x19, 0x0a, 0x15, 0x43, 0x4f, 0x4d, 0x50, 0x41, 0x54, 0x49, 0x42, 0x49, 0x4c, 0x49, 0x54, - 0x59, 0x5f, 0x46, 0x4f, 0x52, 0x57, 0x41, 0x52, 0x44, 0x10, 0x03, 0x12, 0x24, 0x0a, 0x20, 0x43, - 0x4f, 0x4d, 0x50, 0x41, 0x54, 0x49, 0x42, 0x49, 0x4c, 0x49, 0x54, 0x59, 0x5f, 0x46, 0x4f, 0x52, - 0x57, 0x41, 0x52, 0x44, 0x5f, 0x54, 0x52, 0x41, 0x4e, 0x53, 0x49, 0x54, 0x49, 0x56, 0x45, 0x10, - 0x04, 0x12, 0x16, 0x0a, 0x12, 0x43, 0x4f, 0x4d, 0x50, 0x41, 0x54, 0x49, 0x42, 0x49, 0x4c, 0x49, - 0x54, 0x59, 0x5f, 0x46, 0x55, 0x4c, 0x4c, 0x10, 0x05, 0x12, 0x21, 0x0a, 0x1d, 0x43, 0x4f, 0x4d, - 0x50, 0x41, 0x54, 0x49, 0x42, 0x49, 0x4c, 0x49, 0x54, 0x59, 0x5f, 0x46, 0x55, 0x4c, 0x4c, 0x5f, - 0x54, 0x52, 0x41, 0x4e, 0x53, 0x49, 0x54, 0x49, 0x56, 0x45, 0x10, 0x06, 0x22, 0x17, 0x0a, 0x15, - 0x4c, 0x69, 0x73, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x59, 0x0a, 0x16, 0x4c, 0x69, 0x73, 0x74, 0x4e, 0x61, 0x6d, - 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x3f, 0x0a, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, - 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x52, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, - 0x22, 0x25, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x55, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x4e, 0x61, - 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x3d, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, - 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0xeb, - 0x01, 0x0a, 0x16, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x02, 0x69, 0x64, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x04, 0xe2, 0x41, 0x01, 0x02, 0x52, 0x02, 0x69, 0x64, 0x12, - 0x41, 0x0a, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, - 0x23, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, - 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x46, 0x6f, - 0x72, 0x6d, 0x61, 0x74, 0x42, 0x04, 0xe2, 0x41, 0x01, 0x02, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6d, - 0x61, 0x74, 0x12, 0x56, 0x0a, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, - 0x69, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x6f, 0x64, 0x70, 0x66, - 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, - 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, - 0x69, 0x6c, 0x69, 0x74, 0x79, 0x42, 0x04, 0xe2, 0x41, 0x01, 0x02, 0x52, 0x0d, 0x63, 0x6f, 0x6d, - 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, - 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x58, 0x0a, 0x17, - 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3d, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x6f, 0x64, 0x70, - 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x09, 0x6e, 0x61, 0x6d, - 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0xe5, 0x01, 0x0a, 0x16, 0x55, 0x70, 0x64, 0x61, 0x74, - 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, - 0x64, 0x12, 0x41, 0x0a, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x0e, 0x32, 0x23, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, - 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, - 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x42, 0x04, 0xe2, 0x41, 0x01, 0x02, 0x52, 0x06, 0x66, 0x6f, - 0x72, 0x6d, 0x61, 0x74, 0x12, 0x56, 0x0a, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, - 0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x6f, 0x64, - 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, - 0x61, 0x31, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, - 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x42, 0x04, 0xe2, 0x41, 0x01, 0x02, 0x52, 0x0d, 0x63, - 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x20, 0x0a, 0x0b, - 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x58, - 0x0a, 0x17, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3d, 0x0a, 0x09, 0x6e, 0x61, 0x6d, - 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x6f, - 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, - 0x74, 0x61, 0x31, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x09, 0x6e, - 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x28, 0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65, - 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, - 0x69, 0x64, 0x22, 0x33, 0x0a, 0x17, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, - 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, - 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x24, 0x0a, 0x12, 0x4c, 0x69, 0x73, 0x74, 0x53, - 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, - 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x4d, 0x0a, - 0x13, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x36, 0x0a, 0x07, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x18, - 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, - 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x63, 0x68, - 0x65, 0x6d, 0x61, 0x52, 0x07, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x22, 0x58, 0x0a, 0x16, - 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6e, 0x61, - 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x63, 0x68, - 0x65, 0x6d, 0x61, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x49, 0x64, 0x22, 0x2d, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, - 0x65, 0x73, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, - 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0xfe, 0x01, 0x0a, 0x13, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, - 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, - 0x0c, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x49, 0x64, - 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x49, 0x64, 0x12, 0x18, 0x0a, - 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x04, 0xe2, 0x41, 0x01, - 0x02, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x3b, 0x0a, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, - 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, - 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, - 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x06, 0x66, 0x6f, - 0x72, 0x6d, 0x61, 0x74, 0x12, 0x50, 0x0a, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, - 0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x6f, 0x64, - 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, - 0x61, 0x31, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, - 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, - 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x22, 0x5c, 0x0a, 0x14, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, - 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, - 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x6c, 0x6f, 0x63, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6c, 0x6f, 0x63, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xc7, 0x01, 0x0a, 0x19, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x43, 0x6f, - 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x5f, - 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, - 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, - 0x49, 0x64, 0x12, 0x18, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, - 0x42, 0x04, 0xe2, 0x41, 0x01, 0x02, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x50, 0x0a, 0x0d, - 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, - 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, - 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x22, 0x1c, - 0x0a, 0x1a, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, - 0x6c, 0x69, 0x74, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x5a, 0x0a, 0x18, - 0x47, 0x65, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, - 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x61, 0x6d, 0x65, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, - 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x73, - 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, - 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x49, 0x64, 0x22, 0xd2, 0x02, 0x0a, 0x19, 0x47, 0x65, 0x74, - 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, - 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x06, 0x66, 0x6f, 0x72, - 0x6d, 0x61, 0x74, 0x12, 0x50, 0x0a, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, - 0x6c, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x6f, 0x64, 0x70, - 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, - 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, - 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, - 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, - 0x69, 0x74, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, - 0x65, 0x64, 0x5f, 0x61, 0x74, 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, 0x54, 0x69, - 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, - 0x41, 0x74, 0x12, 0x39, 0x0a, 0x0a, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, - 0x6d, 0x70, 0x52, 0x09, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x22, 0xaf, 0x01, - 0x0a, 0x1b, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x65, - 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, - 0x0c, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x49, 0x64, - 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x49, 0x64, 0x12, 0x50, 0x0a, - 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, - 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, - 0x52, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x22, - 0xcb, 0x01, 0x0a, 0x1c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, - 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x3b, 0x0a, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, - 0x32, 0x23, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, - 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x46, - 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x50, 0x0a, - 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, - 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, - 0x52, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, - 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x55, 0x0a, - 0x13, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6e, 0x61, 0x6d, 0x65, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x49, 0x64, 0x22, 0x30, 0x0a, 0x14, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, - 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, - 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x55, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x65, - 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, - 0x0c, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x49, 0x64, - 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x49, 0x64, 0x22, 0x32, 0x0a, - 0x14, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x73, 0x22, 0x71, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6e, 0x61, 0x6d, - 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x63, 0x68, - 0x65, 0x6d, 0x61, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x76, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x27, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, - 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x75, 0x0a, - 0x14, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6e, 0x61, 0x6d, - 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x63, 0x68, - 0x65, 0x6d, 0x61, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x76, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x31, 0x0a, 0x15, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x56, 0x65, - 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, - 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, - 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0xb3, 0x01, 0x0a, 0x0d, 0x53, 0x65, 0x61, 0x72, - 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x61, 0x6d, - 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0b, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, - 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x08, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x05, 0x71, 0x75, 0x65, - 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x04, 0xe2, 0x41, 0x01, 0x02, 0x52, 0x05, - 0x71, 0x75, 0x65, 0x72, 0x79, 0x12, 0x1a, 0x0a, 0x07, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x07, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, - 0x79, 0x12, 0x1f, 0x0a, 0x0a, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, - 0x05, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x09, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x49, 0x64, 0x42, 0x09, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x7c, 0x0a, - 0x0e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x34, 0x0a, 0x04, 0x68, 0x69, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, - 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, - 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x48, 0x69, 0x74, 0x73, 0x52, - 0x04, 0x68, 0x69, 0x74, 0x73, 0x12, 0x34, 0x0a, 0x04, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, - 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, - 0x68, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x04, 0x6d, 0x65, 0x74, 0x61, 0x22, 0xad, 0x01, 0x0a, 0x0a, - 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x48, 0x69, 0x74, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x61, - 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0b, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x49, 0x64, 0x12, 0x1b, 0x0a, - 0x09, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x08, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x76, 0x65, - 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, - 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, - 0x6c, 0x64, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, - 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, - 0x52, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, - 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x22, 0x22, 0x0a, 0x0a, 0x53, - 0x65, 0x61, 0x72, 0x63, 0x68, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x74, - 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x32, - 0xb1, 0x17, 0x0a, 0x0e, 0x53, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x53, 0x65, 0x72, 0x76, 0x69, - 0x63, 0x65, 0x12, 0xb0, 0x01, 0x0a, 0x0e, 0x4c, 0x69, 0x73, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x73, 0x12, 0x2b, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, - 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x73, - 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, - 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x4e, 0x61, - 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x43, 0x92, 0x41, 0x25, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x12, 0x18, 0x4c, 0x69, 0x73, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, - 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, - 0x12, 0x13, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x73, 0x12, 0xaa, 0x01, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x4e, 0x61, 0x6d, - 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x29, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, - 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x47, 0x65, - 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x2a, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, - 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4e, 0x61, 0x6d, 0x65, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x43, 0x92, - 0x41, 0x20, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x13, 0x47, - 0x65, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x62, 0x79, 0x20, - 0x69, 0x64, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, - 0x61, 0x31, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x69, - 0x64, 0x7d, 0x12, 0xb4, 0x01, 0x0a, 0x0f, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4e, 0x61, 0x6d, - 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x2c, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, - 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x72, - 0x65, 0x61, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, - 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, - 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x44, 0x92, 0x41, 0x23, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x12, 0x16, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x18, 0x22, 0x13, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x6e, 0x61, 0x6d, 0x65, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x3a, 0x01, 0x2a, 0x12, 0xc0, 0x01, 0x0a, 0x0f, 0x55, 0x70, - 0x64, 0x61, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x2c, 0x2e, - 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, - 0x65, 0x74, 0x61, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x6f, 0x64, - 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, - 0x61, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x50, 0x92, 0x41, 0x2a, 0x0a, - 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1d, 0x55, 0x70, 0x64, 0x61, - 0x74, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x65, 0x6e, 0x74, - 0x69, 0x74, 0x79, 0x20, 0x62, 0x79, 0x20, 0x69, 0x64, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x1a, - 0x18, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x3a, 0x01, 0x2a, 0x12, 0x8a, 0x02, 0x0a, - 0x0f, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x12, 0x2c, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, - 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4e, 0x61, - 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, - 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, - 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4e, 0x61, 0x6d, 0x65, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x99, 0x01, - 0x92, 0x41, 0x76, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x16, - 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, - 0x20, 0x62, 0x79, 0x20, 0x69, 0x64, 0x1a, 0x51, 0x45, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x20, 0x61, - 0x6c, 0x6c, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, - 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, - 0x69, 0x73, 0x20, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x2c, 0x20, 0x6f, 0x74, 0x68, 0x65, - 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x69, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x74, 0x68, - 0x72, 0x6f, 0x77, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x2a, - 0x18, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0xb9, 0x01, 0x0a, 0x0b, 0x4c, 0x69, - 0x73, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x12, 0x28, 0x2e, 0x6f, 0x64, 0x70, 0x66, - 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, - 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, - 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53, - 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x55, - 0x92, 0x41, 0x2a, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x20, 0x4c, 0x69, 0x73, - 0x74, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, - 0x74, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x22, 0x12, 0x20, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x6e, 0x61, - 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x2f, 0x73, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x73, 0x12, 0x67, 0x0a, 0x0c, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, - 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x29, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, - 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x72, 0x65, - 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x2a, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, - 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x79, - 0x0a, 0x12, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, - 0x6c, 0x69, 0x74, 0x79, 0x12, 0x2f, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, - 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, - 0x6b, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, - 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x68, 0x65, - 0x63, 0x6b, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x98, 0x02, 0x0a, 0x11, 0x47, 0x65, - 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, - 0x2e, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, - 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, - 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x2f, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, - 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, - 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0xa1, 0x01, 0x92, 0x41, 0x5b, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x51, - 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x20, 0x75, 0x6e, - 0x64, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x2e, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x2c, 0x20, 0x75, 0x6e, 0x69, 0x71, 0x75, - 0x65, 0x20, 0x49, 0x44, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3d, 0x12, 0x3b, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x6e, 0x61, - 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x73, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x73, 0x2f, 0x7b, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x69, 0x64, 0x7d, 0x2f, - 0x6d, 0x65, 0x74, 0x61, 0x12, 0xe8, 0x01, 0x0a, 0x14, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, - 0x63, 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x31, 0x2e, - 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, - 0x65, 0x74, 0x61, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x32, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, - 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x69, 0x92, 0x41, 0x25, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x12, 0x1b, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x20, 0x6f, 0x6e, 0x6c, 0x79, 0x20, 0x73, - 0x63, 0x68, 0x65, 0x6d, 0x61, 0x20, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x3b, 0x32, 0x36, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x6e, - 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x73, - 0x2f, 0x7b, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x69, 0x64, 0x7d, 0x3a, 0x01, 0x2a, 0x12, - 0x70, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x53, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x12, 0x2c, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, - 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, - 0x65, 0x73, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x2d, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, - 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, - 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x00, 0x12, 0xc9, 0x01, 0x0a, 0x0c, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x12, 0x29, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, - 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, - 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, - 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, - 0x65, 0x74, 0x61, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x62, 0x92, 0x41, 0x21, 0x0a, 0x06, - 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x17, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x20, 0x73, - 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x38, 0x2a, 0x36, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, - 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x6e, 0x61, 0x6d, 0x65, - 0x73, 0x70, 0x61, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, - 0x73, 0x2f, 0x7b, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0x5e, 0x0a, - 0x09, 0x47, 0x65, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x26, 0x2e, 0x6f, 0x64, 0x70, - 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, - 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x63, 0x68, - 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0xe8, 0x01, - 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x29, - 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, - 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, - 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6f, 0x64, 0x70, 0x66, - 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, - 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x80, 0x01, 0x92, 0x41, 0x36, 0x0a, 0x06, 0x73, 0x63, 0x68, - 0x65, 0x6d, 0x61, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x4c, 0x69, - 0x73, 0x74, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6e, - 0x75, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x41, 0x12, 0x3f, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x6e, 0x61, - 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x73, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x73, 0x2f, 0x7b, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x69, 0x64, 0x7d, 0x2f, - 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0xfb, 0x01, 0x0a, 0x0d, 0x44, 0x65, 0x6c, - 0x65, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2a, 0x2e, 0x6f, 0x64, 0x70, - 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, - 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x44, 0x65, - 0x6c, 0x65, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x90, 0x01, 0x92, 0x41, 0x39, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x26, 0x44, 0x65, 0x6c, 0x65, - 0x74, 0x65, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x76, 0x65, 0x72, - 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x4e, 0x2a, 0x4c, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, - 0x61, 0x31, 0x2f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x6e, - 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x73, 0x63, 0x68, - 0x65, 0x6d, 0x61, 0x73, 0x2f, 0x7b, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x5f, 0x69, 0x64, 0x7d, - 0x2f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x7b, 0x76, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0x8a, 0x01, 0x0a, 0x06, 0x53, 0x65, 0x61, 0x72, 0x63, - 0x68, 0x12, 0x23, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x6c, - 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6f, 0x64, 0x70, 0x66, 0x2e, 0x73, 0x74, - 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x65, - 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x35, 0x92, 0x41, - 0x1b, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x11, 0x47, 0x6c, 0x6f, 0x62, 0x61, - 0x6c, 0x20, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x41, 0x50, 0x49, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x11, 0x12, 0x0f, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x65, 0x61, - 0x72, 0x63, 0x68, 0x42, 0x46, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, - 0x6d, 0x2f, 0x6f, 0x64, 0x70, 0x66, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x6e, 0x2f, 0x73, 0x74, - 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x3b, 0x73, 0x74, - 0x65, 0x6e, 0x63, 0x69, 0x6c, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x92, 0x41, 0x0c, 0x12, - 0x07, 0x32, 0x05, 0x30, 0x2e, 0x31, 0x2e, 0x34, 0x2a, 0x01, 0x01, 0x62, 0x06, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x33, -} - -var ( - file_raystack_stencil_v1beta1_stencil_proto_rawDescOnce sync.Once - file_raystack_stencil_v1beta1_stencil_proto_rawDescData = file_raystack_stencil_v1beta1_stencil_proto_rawDesc -) - -func file_raystack_stencil_v1beta1_stencil_proto_rawDescGZIP() []byte { - file_raystack_stencil_v1beta1_stencil_proto_rawDescOnce.Do(func() { - file_raystack_stencil_v1beta1_stencil_proto_rawDescData = protoimpl.X.CompressGZIP(file_raystack_stencil_v1beta1_stencil_proto_rawDescData) - }) - return file_raystack_stencil_v1beta1_stencil_proto_rawDescData -} - -var file_raystack_stencil_v1beta1_stencil_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_raystack_stencil_v1beta1_stencil_proto_msgTypes = make([]protoimpl.MessageInfo, 36) -var file_raystack_stencil_v1beta1_stencil_proto_goTypes = []interface{}{ - (Schema_Format)(0), // 0: raystack.stencil.v1beta1.Schema.Format - (Schema_Compatibility)(0), // 1: raystack.stencil.v1beta1.Schema.Compatibility - (*Namespace)(nil), // 2: raystack.stencil.v1beta1.Namespace - (*Schema)(nil), // 3: raystack.stencil.v1beta1.Schema - (*ListNamespacesRequest)(nil), // 4: raystack.stencil.v1beta1.ListNamespacesRequest - (*ListNamespacesResponse)(nil), // 5: raystack.stencil.v1beta1.ListNamespacesResponse - (*GetNamespaceRequest)(nil), // 6: raystack.stencil.v1beta1.GetNamespaceRequest - (*GetNamespaceResponse)(nil), // 7: raystack.stencil.v1beta1.GetNamespaceResponse - (*CreateNamespaceRequest)(nil), // 8: raystack.stencil.v1beta1.CreateNamespaceRequest - (*CreateNamespaceResponse)(nil), // 9: raystack.stencil.v1beta1.CreateNamespaceResponse - (*UpdateNamespaceRequest)(nil), // 10: raystack.stencil.v1beta1.UpdateNamespaceRequest - (*UpdateNamespaceResponse)(nil), // 11: raystack.stencil.v1beta1.UpdateNamespaceResponse - (*DeleteNamespaceRequest)(nil), // 12: raystack.stencil.v1beta1.DeleteNamespaceRequest - (*DeleteNamespaceResponse)(nil), // 13: raystack.stencil.v1beta1.DeleteNamespaceResponse - (*ListSchemasRequest)(nil), // 14: raystack.stencil.v1beta1.ListSchemasRequest - (*ListSchemasResponse)(nil), // 15: raystack.stencil.v1beta1.ListSchemasResponse - (*GetLatestSchemaRequest)(nil), // 16: raystack.stencil.v1beta1.GetLatestSchemaRequest - (*GetLatestSchemaResponse)(nil), // 17: raystack.stencil.v1beta1.GetLatestSchemaResponse - (*CreateSchemaRequest)(nil), // 18: raystack.stencil.v1beta1.CreateSchemaRequest - (*CreateSchemaResponse)(nil), // 19: raystack.stencil.v1beta1.CreateSchemaResponse - (*CheckCompatibilityRequest)(nil), // 20: raystack.stencil.v1beta1.CheckCompatibilityRequest - (*CheckCompatibilityResponse)(nil), // 21: raystack.stencil.v1beta1.CheckCompatibilityResponse - (*GetSchemaMetadataRequest)(nil), // 22: raystack.stencil.v1beta1.GetSchemaMetadataRequest - (*GetSchemaMetadataResponse)(nil), // 23: raystack.stencil.v1beta1.GetSchemaMetadataResponse - (*UpdateSchemaMetadataRequest)(nil), // 24: raystack.stencil.v1beta1.UpdateSchemaMetadataRequest - (*UpdateSchemaMetadataResponse)(nil), // 25: raystack.stencil.v1beta1.UpdateSchemaMetadataResponse - (*DeleteSchemaRequest)(nil), // 26: raystack.stencil.v1beta1.DeleteSchemaRequest - (*DeleteSchemaResponse)(nil), // 27: raystack.stencil.v1beta1.DeleteSchemaResponse - (*ListVersionsRequest)(nil), // 28: raystack.stencil.v1beta1.ListVersionsRequest - (*ListVersionsResponse)(nil), // 29: raystack.stencil.v1beta1.ListVersionsResponse - (*GetSchemaRequest)(nil), // 30: raystack.stencil.v1beta1.GetSchemaRequest - (*GetSchemaResponse)(nil), // 31: raystack.stencil.v1beta1.GetSchemaResponse - (*DeleteVersionRequest)(nil), // 32: raystack.stencil.v1beta1.DeleteVersionRequest - (*DeleteVersionResponse)(nil), // 33: raystack.stencil.v1beta1.DeleteVersionResponse - (*SearchRequest)(nil), // 34: raystack.stencil.v1beta1.SearchRequest - (*SearchResponse)(nil), // 35: raystack.stencil.v1beta1.SearchResponse - (*SearchHits)(nil), // 36: raystack.stencil.v1beta1.SearchHits - (*SearchMeta)(nil), // 37: raystack.stencil.v1beta1.SearchMeta - (*timestamppb.Timestamp)(nil), // 38: google.protobuf.Timestamp -} -var file_raystack_stencil_v1beta1_stencil_proto_depIdxs = []int32{ - 0, // 0: raystack.stencil.v1beta1.Namespace.format:type_name -> raystack.stencil.v1beta1.Schema.Format - 1, // 1: raystack.stencil.v1beta1.Namespace.Compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility - 38, // 2: raystack.stencil.v1beta1.Namespace.created_at:type_name -> google.protobuf.Timestamp - 38, // 3: raystack.stencil.v1beta1.Namespace.updated_at:type_name -> google.protobuf.Timestamp - 0, // 4: raystack.stencil.v1beta1.Schema.format:type_name -> raystack.stencil.v1beta1.Schema.Format - 1, // 5: raystack.stencil.v1beta1.Schema.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility - 38, // 6: raystack.stencil.v1beta1.Schema.created_at:type_name -> google.protobuf.Timestamp - 38, // 7: raystack.stencil.v1beta1.Schema.updated_at:type_name -> google.protobuf.Timestamp - 2, // 8: raystack.stencil.v1beta1.ListNamespacesResponse.namespaces:type_name -> raystack.stencil.v1beta1.Namespace - 2, // 9: raystack.stencil.v1beta1.GetNamespaceResponse.namespace:type_name -> raystack.stencil.v1beta1.Namespace - 0, // 10: raystack.stencil.v1beta1.CreateNamespaceRequest.format:type_name -> raystack.stencil.v1beta1.Schema.Format - 1, // 11: raystack.stencil.v1beta1.CreateNamespaceRequest.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility - 2, // 12: raystack.stencil.v1beta1.CreateNamespaceResponse.namespace:type_name -> raystack.stencil.v1beta1.Namespace - 0, // 13: raystack.stencil.v1beta1.UpdateNamespaceRequest.format:type_name -> raystack.stencil.v1beta1.Schema.Format - 1, // 14: raystack.stencil.v1beta1.UpdateNamespaceRequest.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility - 2, // 15: raystack.stencil.v1beta1.UpdateNamespaceResponse.namespace:type_name -> raystack.stencil.v1beta1.Namespace - 3, // 16: raystack.stencil.v1beta1.ListSchemasResponse.schemas:type_name -> raystack.stencil.v1beta1.Schema - 0, // 17: raystack.stencil.v1beta1.CreateSchemaRequest.format:type_name -> raystack.stencil.v1beta1.Schema.Format - 1, // 18: raystack.stencil.v1beta1.CreateSchemaRequest.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility - 1, // 19: raystack.stencil.v1beta1.CheckCompatibilityRequest.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility - 0, // 20: raystack.stencil.v1beta1.GetSchemaMetadataResponse.format:type_name -> raystack.stencil.v1beta1.Schema.Format - 1, // 21: raystack.stencil.v1beta1.GetSchemaMetadataResponse.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility - 38, // 22: raystack.stencil.v1beta1.GetSchemaMetadataResponse.created_at:type_name -> google.protobuf.Timestamp - 38, // 23: raystack.stencil.v1beta1.GetSchemaMetadataResponse.updated_at:type_name -> google.protobuf.Timestamp - 1, // 24: raystack.stencil.v1beta1.UpdateSchemaMetadataRequest.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility - 0, // 25: raystack.stencil.v1beta1.UpdateSchemaMetadataResponse.format:type_name -> raystack.stencil.v1beta1.Schema.Format - 1, // 26: raystack.stencil.v1beta1.UpdateSchemaMetadataResponse.compatibility:type_name -> raystack.stencil.v1beta1.Schema.Compatibility - 36, // 27: raystack.stencil.v1beta1.SearchResponse.hits:type_name -> raystack.stencil.v1beta1.SearchHits - 37, // 28: raystack.stencil.v1beta1.SearchResponse.meta:type_name -> raystack.stencil.v1beta1.SearchMeta - 4, // 29: raystack.stencil.v1beta1.StencilService.ListNamespaces:input_type -> raystack.stencil.v1beta1.ListNamespacesRequest - 6, // 30: raystack.stencil.v1beta1.StencilService.GetNamespace:input_type -> raystack.stencil.v1beta1.GetNamespaceRequest - 8, // 31: raystack.stencil.v1beta1.StencilService.CreateNamespace:input_type -> raystack.stencil.v1beta1.CreateNamespaceRequest - 10, // 32: raystack.stencil.v1beta1.StencilService.UpdateNamespace:input_type -> raystack.stencil.v1beta1.UpdateNamespaceRequest - 12, // 33: raystack.stencil.v1beta1.StencilService.DeleteNamespace:input_type -> raystack.stencil.v1beta1.DeleteNamespaceRequest - 14, // 34: raystack.stencil.v1beta1.StencilService.ListSchemas:input_type -> raystack.stencil.v1beta1.ListSchemasRequest - 18, // 35: raystack.stencil.v1beta1.StencilService.CreateSchema:input_type -> raystack.stencil.v1beta1.CreateSchemaRequest - 20, // 36: raystack.stencil.v1beta1.StencilService.CheckCompatibility:input_type -> raystack.stencil.v1beta1.CheckCompatibilityRequest - 22, // 37: raystack.stencil.v1beta1.StencilService.GetSchemaMetadata:input_type -> raystack.stencil.v1beta1.GetSchemaMetadataRequest - 24, // 38: raystack.stencil.v1beta1.StencilService.UpdateSchemaMetadata:input_type -> raystack.stencil.v1beta1.UpdateSchemaMetadataRequest - 16, // 39: raystack.stencil.v1beta1.StencilService.GetLatestSchema:input_type -> raystack.stencil.v1beta1.GetLatestSchemaRequest - 26, // 40: raystack.stencil.v1beta1.StencilService.DeleteSchema:input_type -> raystack.stencil.v1beta1.DeleteSchemaRequest - 30, // 41: raystack.stencil.v1beta1.StencilService.GetSchema:input_type -> raystack.stencil.v1beta1.GetSchemaRequest - 28, // 42: raystack.stencil.v1beta1.StencilService.ListVersions:input_type -> raystack.stencil.v1beta1.ListVersionsRequest - 32, // 43: raystack.stencil.v1beta1.StencilService.DeleteVersion:input_type -> raystack.stencil.v1beta1.DeleteVersionRequest - 34, // 44: raystack.stencil.v1beta1.StencilService.Search:input_type -> raystack.stencil.v1beta1.SearchRequest - 5, // 45: raystack.stencil.v1beta1.StencilService.ListNamespaces:output_type -> raystack.stencil.v1beta1.ListNamespacesResponse - 7, // 46: raystack.stencil.v1beta1.StencilService.GetNamespace:output_type -> raystack.stencil.v1beta1.GetNamespaceResponse - 9, // 47: raystack.stencil.v1beta1.StencilService.CreateNamespace:output_type -> raystack.stencil.v1beta1.CreateNamespaceResponse - 11, // 48: raystack.stencil.v1beta1.StencilService.UpdateNamespace:output_type -> raystack.stencil.v1beta1.UpdateNamespaceResponse - 13, // 49: raystack.stencil.v1beta1.StencilService.DeleteNamespace:output_type -> raystack.stencil.v1beta1.DeleteNamespaceResponse - 15, // 50: raystack.stencil.v1beta1.StencilService.ListSchemas:output_type -> raystack.stencil.v1beta1.ListSchemasResponse - 19, // 51: raystack.stencil.v1beta1.StencilService.CreateSchema:output_type -> raystack.stencil.v1beta1.CreateSchemaResponse - 21, // 52: raystack.stencil.v1beta1.StencilService.CheckCompatibility:output_type -> raystack.stencil.v1beta1.CheckCompatibilityResponse - 23, // 53: raystack.stencil.v1beta1.StencilService.GetSchemaMetadata:output_type -> raystack.stencil.v1beta1.GetSchemaMetadataResponse - 25, // 54: raystack.stencil.v1beta1.StencilService.UpdateSchemaMetadata:output_type -> raystack.stencil.v1beta1.UpdateSchemaMetadataResponse - 17, // 55: raystack.stencil.v1beta1.StencilService.GetLatestSchema:output_type -> raystack.stencil.v1beta1.GetLatestSchemaResponse - 27, // 56: raystack.stencil.v1beta1.StencilService.DeleteSchema:output_type -> raystack.stencil.v1beta1.DeleteSchemaResponse - 31, // 57: raystack.stencil.v1beta1.StencilService.GetSchema:output_type -> raystack.stencil.v1beta1.GetSchemaResponse - 29, // 58: raystack.stencil.v1beta1.StencilService.ListVersions:output_type -> raystack.stencil.v1beta1.ListVersionsResponse - 33, // 59: raystack.stencil.v1beta1.StencilService.DeleteVersion:output_type -> raystack.stencil.v1beta1.DeleteVersionResponse - 35, // 60: raystack.stencil.v1beta1.StencilService.Search:output_type -> raystack.stencil.v1beta1.SearchResponse - 45, // [45:61] is the sub-list for method output_type - 29, // [29:45] is the sub-list for method input_type - 29, // [29:29] is the sub-list for extension type_name - 29, // [29:29] is the sub-list for extension extendee - 0, // [0:29] is the sub-list for field type_name -} - -func init() { file_raystack_stencil_v1beta1_stencil_proto_init() } -func file_raystack_stencil_v1beta1_stencil_proto_init() { - if File_raystack_stencil_v1beta1_stencil_proto != nil { - return - } - if !protoimpl.UnsafeEnabled { - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*Namespace); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*Schema); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListNamespacesRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListNamespacesResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetNamespaceRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetNamespaceResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CreateNamespaceRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CreateNamespaceResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*UpdateNamespaceRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*UpdateNamespaceResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DeleteNamespaceRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DeleteNamespaceResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListSchemasRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListSchemasResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetLatestSchemaRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetLatestSchemaResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CreateSchemaRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CreateSchemaResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CheckCompatibilityRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CheckCompatibilityResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetSchemaMetadataRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetSchemaMetadataResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*UpdateSchemaMetadataRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*UpdateSchemaMetadataResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DeleteSchemaRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DeleteSchemaResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListVersionsRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListVersionsResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetSchemaRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetSchemaResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DeleteVersionRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DeleteVersionResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SearchRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SearchResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SearchHits); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SearchMeta); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - } - file_raystack_stencil_v1beta1_stencil_proto_msgTypes[32].OneofWrappers = []interface{}{ - (*SearchRequest_History)(nil), - (*SearchRequest_VersionId)(nil), - } - type x struct{} - out := protoimpl.TypeBuilder{ - File: protoimpl.DescBuilder{ - GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: file_raystack_stencil_v1beta1_stencil_proto_rawDesc, - NumEnums: 2, - NumMessages: 36, - NumExtensions: 0, - NumServices: 1, - }, - GoTypes: file_raystack_stencil_v1beta1_stencil_proto_goTypes, - DependencyIndexes: file_raystack_stencil_v1beta1_stencil_proto_depIdxs, - EnumInfos: file_raystack_stencil_v1beta1_stencil_proto_enumTypes, - MessageInfos: file_raystack_stencil_v1beta1_stencil_proto_msgTypes, - }.Build() - File_raystack_stencil_v1beta1_stencil_proto = out.File - file_raystack_stencil_v1beta1_stencil_proto_rawDesc = nil - file_raystack_stencil_v1beta1_stencil_proto_goTypes = nil - file_raystack_stencil_v1beta1_stencil_proto_depIdxs = nil -} diff --git a/proto/raystack/stencil/v1beta1/stencil.pb.gw.go b/proto/raystack/stencil/v1beta1/stencil.pb.gw.go deleted file mode 100644 index 61edad45..00000000 --- a/proto/raystack/stencil/v1beta1/stencil.pb.gw.go +++ /dev/null @@ -1,1382 +0,0 @@ -// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. -// source: raystack/stencil/v1beta1/stencil.proto - -/* -Package stencilv1beta1 is a reverse proxy. - -It translates gRPC into RESTful JSON APIs. -*/ -package stencilv1beta1 - -import ( - "context" - "io" - "net/http" - - "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" - "github.com/grpc-ecosystem/grpc-gateway/v2/utilities" - "google.golang.org/grpc" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/grpclog" - "google.golang.org/grpc/metadata" - "google.golang.org/grpc/status" - "google.golang.org/protobuf/proto" -) - -// Suppress "imported and not used" errors -var _ codes.Code -var _ io.Reader -var _ status.Status -var _ = runtime.String -var _ = utilities.NewDoubleArray -var _ = metadata.Join - -func request_StencilService_ListNamespaces_0(ctx context.Context, marshaler runtime.Marshaler, client StencilServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListNamespacesRequest - var metadata runtime.ServerMetadata - - msg, err := client.ListNamespaces(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) - return msg, metadata, err - -} - -func local_request_StencilService_ListNamespaces_0(ctx context.Context, marshaler runtime.Marshaler, server StencilServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListNamespacesRequest - var metadata runtime.ServerMetadata - - msg, err := server.ListNamespaces(ctx, &protoReq) - return msg, metadata, err - -} - -func request_StencilService_GetNamespace_0(ctx context.Context, marshaler runtime.Marshaler, client StencilServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq GetNamespaceRequest - var metadata runtime.ServerMetadata - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") - } - - protoReq.Id, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) - } - - msg, err := client.GetNamespace(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) - return msg, metadata, err - -} - -func local_request_StencilService_GetNamespace_0(ctx context.Context, marshaler runtime.Marshaler, server StencilServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq GetNamespaceRequest - var metadata runtime.ServerMetadata - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") - } - - protoReq.Id, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) - } - - msg, err := server.GetNamespace(ctx, &protoReq) - return msg, metadata, err - -} - -func request_StencilService_CreateNamespace_0(ctx context.Context, marshaler runtime.Marshaler, client StencilServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq CreateNamespaceRequest - var metadata runtime.ServerMetadata - - newReader, berr := utilities.IOReaderFactory(req.Body) - if berr != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) - } - if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - - msg, err := client.CreateNamespace(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) - return msg, metadata, err - -} - -func local_request_StencilService_CreateNamespace_0(ctx context.Context, marshaler runtime.Marshaler, server StencilServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq CreateNamespaceRequest - var metadata runtime.ServerMetadata - - newReader, berr := utilities.IOReaderFactory(req.Body) - if berr != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) - } - if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - - msg, err := server.CreateNamespace(ctx, &protoReq) - return msg, metadata, err - -} - -func request_StencilService_UpdateNamespace_0(ctx context.Context, marshaler runtime.Marshaler, client StencilServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq UpdateNamespaceRequest - var metadata runtime.ServerMetadata - - newReader, berr := utilities.IOReaderFactory(req.Body) - if berr != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) - } - if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") - } - - protoReq.Id, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) - } - - msg, err := client.UpdateNamespace(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) - return msg, metadata, err - -} - -func local_request_StencilService_UpdateNamespace_0(ctx context.Context, marshaler runtime.Marshaler, server StencilServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq UpdateNamespaceRequest - var metadata runtime.ServerMetadata - - newReader, berr := utilities.IOReaderFactory(req.Body) - if berr != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) - } - if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") - } - - protoReq.Id, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) - } - - msg, err := server.UpdateNamespace(ctx, &protoReq) - return msg, metadata, err - -} - -func request_StencilService_DeleteNamespace_0(ctx context.Context, marshaler runtime.Marshaler, client StencilServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq DeleteNamespaceRequest - var metadata runtime.ServerMetadata - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") - } - - protoReq.Id, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) - } - - msg, err := client.DeleteNamespace(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) - return msg, metadata, err - -} - -func local_request_StencilService_DeleteNamespace_0(ctx context.Context, marshaler runtime.Marshaler, server StencilServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq DeleteNamespaceRequest - var metadata runtime.ServerMetadata - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") - } - - protoReq.Id, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) - } - - msg, err := server.DeleteNamespace(ctx, &protoReq) - return msg, metadata, err - -} - -func request_StencilService_ListSchemas_0(ctx context.Context, marshaler runtime.Marshaler, client StencilServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListSchemasRequest - var metadata runtime.ServerMetadata - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") - } - - protoReq.Id, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) - } - - msg, err := client.ListSchemas(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) - return msg, metadata, err - -} - -func local_request_StencilService_ListSchemas_0(ctx context.Context, marshaler runtime.Marshaler, server StencilServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListSchemasRequest - var metadata runtime.ServerMetadata - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") - } - - protoReq.Id, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) - } - - msg, err := server.ListSchemas(ctx, &protoReq) - return msg, metadata, err - -} - -func request_StencilService_GetSchemaMetadata_0(ctx context.Context, marshaler runtime.Marshaler, client StencilServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq GetSchemaMetadataRequest - var metadata runtime.ServerMetadata - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["namespace_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "namespace_id") - } - - protoReq.NamespaceId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "namespace_id", err) - } - - val, ok = pathParams["schema_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "schema_id") - } - - protoReq.SchemaId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "schema_id", err) - } - - msg, err := client.GetSchemaMetadata(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) - return msg, metadata, err - -} - -func local_request_StencilService_GetSchemaMetadata_0(ctx context.Context, marshaler runtime.Marshaler, server StencilServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq GetSchemaMetadataRequest - var metadata runtime.ServerMetadata - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["namespace_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "namespace_id") - } - - protoReq.NamespaceId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "namespace_id", err) - } - - val, ok = pathParams["schema_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "schema_id") - } - - protoReq.SchemaId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "schema_id", err) - } - - msg, err := server.GetSchemaMetadata(ctx, &protoReq) - return msg, metadata, err - -} - -func request_StencilService_UpdateSchemaMetadata_0(ctx context.Context, marshaler runtime.Marshaler, client StencilServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq UpdateSchemaMetadataRequest - var metadata runtime.ServerMetadata - - newReader, berr := utilities.IOReaderFactory(req.Body) - if berr != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) - } - if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["namespace_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "namespace_id") - } - - protoReq.NamespaceId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "namespace_id", err) - } - - val, ok = pathParams["schema_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "schema_id") - } - - protoReq.SchemaId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "schema_id", err) - } - - msg, err := client.UpdateSchemaMetadata(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) - return msg, metadata, err - -} - -func local_request_StencilService_UpdateSchemaMetadata_0(ctx context.Context, marshaler runtime.Marshaler, server StencilServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq UpdateSchemaMetadataRequest - var metadata runtime.ServerMetadata - - newReader, berr := utilities.IOReaderFactory(req.Body) - if berr != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) - } - if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["namespace_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "namespace_id") - } - - protoReq.NamespaceId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "namespace_id", err) - } - - val, ok = pathParams["schema_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "schema_id") - } - - protoReq.SchemaId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "schema_id", err) - } - - msg, err := server.UpdateSchemaMetadata(ctx, &protoReq) - return msg, metadata, err - -} - -func request_StencilService_DeleteSchema_0(ctx context.Context, marshaler runtime.Marshaler, client StencilServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq DeleteSchemaRequest - var metadata runtime.ServerMetadata - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["namespace_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "namespace_id") - } - - protoReq.NamespaceId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "namespace_id", err) - } - - val, ok = pathParams["schema_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "schema_id") - } - - protoReq.SchemaId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "schema_id", err) - } - - msg, err := client.DeleteSchema(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) - return msg, metadata, err - -} - -func local_request_StencilService_DeleteSchema_0(ctx context.Context, marshaler runtime.Marshaler, server StencilServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq DeleteSchemaRequest - var metadata runtime.ServerMetadata - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["namespace_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "namespace_id") - } - - protoReq.NamespaceId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "namespace_id", err) - } - - val, ok = pathParams["schema_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "schema_id") - } - - protoReq.SchemaId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "schema_id", err) - } - - msg, err := server.DeleteSchema(ctx, &protoReq) - return msg, metadata, err - -} - -func request_StencilService_ListVersions_0(ctx context.Context, marshaler runtime.Marshaler, client StencilServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListVersionsRequest - var metadata runtime.ServerMetadata - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["namespace_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "namespace_id") - } - - protoReq.NamespaceId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "namespace_id", err) - } - - val, ok = pathParams["schema_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "schema_id") - } - - protoReq.SchemaId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "schema_id", err) - } - - msg, err := client.ListVersions(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) - return msg, metadata, err - -} - -func local_request_StencilService_ListVersions_0(ctx context.Context, marshaler runtime.Marshaler, server StencilServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListVersionsRequest - var metadata runtime.ServerMetadata - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["namespace_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "namespace_id") - } - - protoReq.NamespaceId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "namespace_id", err) - } - - val, ok = pathParams["schema_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "schema_id") - } - - protoReq.SchemaId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "schema_id", err) - } - - msg, err := server.ListVersions(ctx, &protoReq) - return msg, metadata, err - -} - -func request_StencilService_DeleteVersion_0(ctx context.Context, marshaler runtime.Marshaler, client StencilServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq DeleteVersionRequest - var metadata runtime.ServerMetadata - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["namespace_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "namespace_id") - } - - protoReq.NamespaceId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "namespace_id", err) - } - - val, ok = pathParams["schema_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "schema_id") - } - - protoReq.SchemaId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "schema_id", err) - } - - val, ok = pathParams["version_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "version_id") - } - - protoReq.VersionId, err = runtime.Int32(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "version_id", err) - } - - msg, err := client.DeleteVersion(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) - return msg, metadata, err - -} - -func local_request_StencilService_DeleteVersion_0(ctx context.Context, marshaler runtime.Marshaler, server StencilServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq DeleteVersionRequest - var metadata runtime.ServerMetadata - - var ( - val string - ok bool - err error - _ = err - ) - - val, ok = pathParams["namespace_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "namespace_id") - } - - protoReq.NamespaceId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "namespace_id", err) - } - - val, ok = pathParams["schema_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "schema_id") - } - - protoReq.SchemaId, err = runtime.String(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "schema_id", err) - } - - val, ok = pathParams["version_id"] - if !ok { - return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "version_id") - } - - protoReq.VersionId, err = runtime.Int32(val) - if err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "version_id", err) - } - - msg, err := server.DeleteVersion(ctx, &protoReq) - return msg, metadata, err - -} - -var ( - filter_StencilService_Search_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) - -func request_StencilService_Search_0(ctx context.Context, marshaler runtime.Marshaler, client StencilServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq SearchRequest - var metadata runtime.ServerMetadata - - if err := req.ParseForm(); err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_StencilService_Search_0); err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - - msg, err := client.Search(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) - return msg, metadata, err - -} - -func local_request_StencilService_Search_0(ctx context.Context, marshaler runtime.Marshaler, server StencilServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq SearchRequest - var metadata runtime.ServerMetadata - - if err := req.ParseForm(); err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_StencilService_Search_0); err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - - msg, err := server.Search(ctx, &protoReq) - return msg, metadata, err - -} - -// RegisterStencilServiceHandlerServer registers the http handlers for service StencilService to "mux". -// UnaryRPC :call StencilServiceServer directly. -// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. -// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterStencilServiceHandlerFromEndpoint instead. -func RegisterStencilServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server StencilServiceServer) error { - - mux.Handle("GET", pattern_StencilService_ListNamespaces_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - var stream runtime.ServerTransportStream - ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/ListNamespaces", runtime.WithHTTPPathPattern("/v1beta1/namespaces")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := local_request_StencilService_ListNamespaces_0(ctx, inboundMarshaler, server, req, pathParams) - md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_ListNamespaces_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("GET", pattern_StencilService_GetNamespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - var stream runtime.ServerTransportStream - ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/GetNamespace", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{id}")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := local_request_StencilService_GetNamespace_0(ctx, inboundMarshaler, server, req, pathParams) - md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_GetNamespace_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("POST", pattern_StencilService_CreateNamespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - var stream runtime.ServerTransportStream - ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/CreateNamespace", runtime.WithHTTPPathPattern("/v1beta1/namespaces")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := local_request_StencilService_CreateNamespace_0(ctx, inboundMarshaler, server, req, pathParams) - md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_CreateNamespace_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("PUT", pattern_StencilService_UpdateNamespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - var stream runtime.ServerTransportStream - ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/UpdateNamespace", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{id}")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := local_request_StencilService_UpdateNamespace_0(ctx, inboundMarshaler, server, req, pathParams) - md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_UpdateNamespace_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("DELETE", pattern_StencilService_DeleteNamespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - var stream runtime.ServerTransportStream - ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/DeleteNamespace", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{id}")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := local_request_StencilService_DeleteNamespace_0(ctx, inboundMarshaler, server, req, pathParams) - md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_DeleteNamespace_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("GET", pattern_StencilService_ListSchemas_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - var stream runtime.ServerTransportStream - ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/ListSchemas", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{id}/schemas")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := local_request_StencilService_ListSchemas_0(ctx, inboundMarshaler, server, req, pathParams) - md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_ListSchemas_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("GET", pattern_StencilService_GetSchemaMetadata_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - var stream runtime.ServerTransportStream - ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/GetSchemaMetadata", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{namespace_id}/schemas/{schema_id}/meta")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := local_request_StencilService_GetSchemaMetadata_0(ctx, inboundMarshaler, server, req, pathParams) - md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_GetSchemaMetadata_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("PATCH", pattern_StencilService_UpdateSchemaMetadata_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - var stream runtime.ServerTransportStream - ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/UpdateSchemaMetadata", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{namespace_id}/schemas/{schema_id}")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := local_request_StencilService_UpdateSchemaMetadata_0(ctx, inboundMarshaler, server, req, pathParams) - md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_UpdateSchemaMetadata_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("DELETE", pattern_StencilService_DeleteSchema_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - var stream runtime.ServerTransportStream - ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/DeleteSchema", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{namespace_id}/schemas/{schema_id}")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := local_request_StencilService_DeleteSchema_0(ctx, inboundMarshaler, server, req, pathParams) - md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_DeleteSchema_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("GET", pattern_StencilService_ListVersions_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - var stream runtime.ServerTransportStream - ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/ListVersions", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{namespace_id}/schemas/{schema_id}/versions")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := local_request_StencilService_ListVersions_0(ctx, inboundMarshaler, server, req, pathParams) - md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_ListVersions_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("DELETE", pattern_StencilService_DeleteVersion_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - var stream runtime.ServerTransportStream - ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/DeleteVersion", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{namespace_id}/schemas/{schema_id}/versions/{version_id}")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := local_request_StencilService_DeleteVersion_0(ctx, inboundMarshaler, server, req, pathParams) - md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_DeleteVersion_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("GET", pattern_StencilService_Search_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - var stream runtime.ServerTransportStream - ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/Search", runtime.WithHTTPPathPattern("/v1beta1/search")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := local_request_StencilService_Search_0(ctx, inboundMarshaler, server, req, pathParams) - md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_Search_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - return nil -} - -// RegisterStencilServiceHandlerFromEndpoint is same as RegisterStencilServiceHandler but -// automatically dials to "endpoint" and closes the connection when "ctx" gets done. -func RegisterStencilServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { - conn, err := grpc.Dial(endpoint, opts...) - if err != nil { - return err - } - defer func() { - if err != nil { - if cerr := conn.Close(); cerr != nil { - grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) - } - return - } - go func() { - <-ctx.Done() - if cerr := conn.Close(); cerr != nil { - grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) - } - }() - }() - - return RegisterStencilServiceHandler(ctx, mux, conn) -} - -// RegisterStencilServiceHandler registers the http handlers for service StencilService to "mux". -// The handlers forward requests to the grpc endpoint over "conn". -func RegisterStencilServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { - return RegisterStencilServiceHandlerClient(ctx, mux, NewStencilServiceClient(conn)) -} - -// RegisterStencilServiceHandlerClient registers the http handlers for service StencilService -// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "StencilServiceClient". -// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "StencilServiceClient" -// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in -// "StencilServiceClient" to call the correct interceptors. -func RegisterStencilServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client StencilServiceClient) error { - - mux.Handle("GET", pattern_StencilService_ListNamespaces_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/ListNamespaces", runtime.WithHTTPPathPattern("/v1beta1/namespaces")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := request_StencilService_ListNamespaces_0(ctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_ListNamespaces_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("GET", pattern_StencilService_GetNamespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/GetNamespace", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{id}")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := request_StencilService_GetNamespace_0(ctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_GetNamespace_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("POST", pattern_StencilService_CreateNamespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/CreateNamespace", runtime.WithHTTPPathPattern("/v1beta1/namespaces")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := request_StencilService_CreateNamespace_0(ctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_CreateNamespace_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("PUT", pattern_StencilService_UpdateNamespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/UpdateNamespace", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{id}")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := request_StencilService_UpdateNamespace_0(ctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_UpdateNamespace_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("DELETE", pattern_StencilService_DeleteNamespace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/DeleteNamespace", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{id}")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := request_StencilService_DeleteNamespace_0(ctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_DeleteNamespace_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("GET", pattern_StencilService_ListSchemas_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/ListSchemas", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{id}/schemas")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := request_StencilService_ListSchemas_0(ctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_ListSchemas_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("GET", pattern_StencilService_GetSchemaMetadata_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/GetSchemaMetadata", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{namespace_id}/schemas/{schema_id}/meta")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := request_StencilService_GetSchemaMetadata_0(ctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_GetSchemaMetadata_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("PATCH", pattern_StencilService_UpdateSchemaMetadata_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/UpdateSchemaMetadata", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{namespace_id}/schemas/{schema_id}")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := request_StencilService_UpdateSchemaMetadata_0(ctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_UpdateSchemaMetadata_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("DELETE", pattern_StencilService_DeleteSchema_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/DeleteSchema", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{namespace_id}/schemas/{schema_id}")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := request_StencilService_DeleteSchema_0(ctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_DeleteSchema_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("GET", pattern_StencilService_ListVersions_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/ListVersions", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{namespace_id}/schemas/{schema_id}/versions")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := request_StencilService_ListVersions_0(ctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_ListVersions_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("DELETE", pattern_StencilService_DeleteVersion_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/DeleteVersion", runtime.WithHTTPPathPattern("/v1beta1/namespaces/{namespace_id}/schemas/{schema_id}/versions/{version_id}")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := request_StencilService_DeleteVersion_0(ctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_DeleteVersion_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - mux.Handle("GET", pattern_StencilService_Search_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - var err error - ctx, err = runtime.AnnotateContext(ctx, mux, req, "/raystack.stencil.v1beta1.StencilService/Search", runtime.WithHTTPPathPattern("/v1beta1/search")) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := request_StencilService_Search_0(ctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_StencilService_Search_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - return nil -} - -var ( - pattern_StencilService_ListNamespaces_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1beta1", "namespaces"}, "")) - - pattern_StencilService_GetNamespace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"v1beta1", "namespaces", "id"}, "")) - - pattern_StencilService_CreateNamespace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1beta1", "namespaces"}, "")) - - pattern_StencilService_UpdateNamespace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"v1beta1", "namespaces", "id"}, "")) - - pattern_StencilService_DeleteNamespace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"v1beta1", "namespaces", "id"}, "")) - - pattern_StencilService_ListSchemas_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"v1beta1", "namespaces", "id", "schemas"}, "")) - - pattern_StencilService_GetSchemaMetadata_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"v1beta1", "namespaces", "namespace_id", "schemas", "schema_id", "meta"}, "")) - - pattern_StencilService_UpdateSchemaMetadata_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1beta1", "namespaces", "namespace_id", "schemas", "schema_id"}, "")) - - pattern_StencilService_DeleteSchema_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1beta1", "namespaces", "namespace_id", "schemas", "schema_id"}, "")) - - pattern_StencilService_ListVersions_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"v1beta1", "namespaces", "namespace_id", "schemas", "schema_id", "versions"}, "")) - - pattern_StencilService_DeleteVersion_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6}, []string{"v1beta1", "namespaces", "namespace_id", "schemas", "schema_id", "versions", "version_id"}, "")) - - pattern_StencilService_Search_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1beta1", "search"}, "")) -) - -var ( - forward_StencilService_ListNamespaces_0 = runtime.ForwardResponseMessage - - forward_StencilService_GetNamespace_0 = runtime.ForwardResponseMessage - - forward_StencilService_CreateNamespace_0 = runtime.ForwardResponseMessage - - forward_StencilService_UpdateNamespace_0 = runtime.ForwardResponseMessage - - forward_StencilService_DeleteNamespace_0 = runtime.ForwardResponseMessage - - forward_StencilService_ListSchemas_0 = runtime.ForwardResponseMessage - - forward_StencilService_GetSchemaMetadata_0 = runtime.ForwardResponseMessage - - forward_StencilService_UpdateSchemaMetadata_0 = runtime.ForwardResponseMessage - - forward_StencilService_DeleteSchema_0 = runtime.ForwardResponseMessage - - forward_StencilService_ListVersions_0 = runtime.ForwardResponseMessage - - forward_StencilService_DeleteVersion_0 = runtime.ForwardResponseMessage - - forward_StencilService_Search_0 = runtime.ForwardResponseMessage -) diff --git a/proto/raystack/stencil/v1beta1/stencil.pb.validate.go b/proto/raystack/stencil/v1beta1/stencil.pb.validate.go deleted file mode 100644 index 5145874e..00000000 --- a/proto/raystack/stencil/v1beta1/stencil.pb.validate.go +++ /dev/null @@ -1,4193 +0,0 @@ -// Code generated by protoc-gen-validate. DO NOT EDIT. -// source: raystack/stencil/v1beta1/stencil.proto - -package stencilv1beta1 - -import ( - "bytes" - "errors" - "fmt" - "net" - "net/mail" - "net/url" - "regexp" - "sort" - "strings" - "time" - "unicode/utf8" - - "google.golang.org/protobuf/types/known/anypb" -) - -// ensure the imports are used -var ( - _ = bytes.MinRead - _ = errors.New("") - _ = fmt.Print - _ = utf8.UTFMax - _ = (*regexp.Regexp)(nil) - _ = (*strings.Reader)(nil) - _ = net.IPv4len - _ = time.Duration(0) - _ = (*url.URL)(nil) - _ = (*mail.Address)(nil) - _ = anypb.Any{} - _ = sort.Sort -) - -// Validate checks the field values on Namespace with the rules defined in the -// proto definition for this message. If any rules are violated, the first -// error encountered is returned, or nil if there are no violations. -func (m *Namespace) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on Namespace with the rules defined in -// the proto definition for this message. If any rules are violated, the -// result is a list of violation errors wrapped in NamespaceMultiError, or nil -// if none found. -func (m *Namespace) ValidateAll() error { - return m.validate(true) -} - -func (m *Namespace) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Id - - // no validation rules for Format - - // no validation rules for Compatibility - - // no validation rules for Description - - if all { - switch v := interface{}(m.GetCreatedAt()).(type) { - case interface{ ValidateAll() error }: - if err := v.ValidateAll(); err != nil { - errors = append(errors, NamespaceValidationError{ - field: "CreatedAt", - reason: "embedded message failed validation", - cause: err, - }) - } - case interface{ Validate() error }: - if err := v.Validate(); err != nil { - errors = append(errors, NamespaceValidationError{ - field: "CreatedAt", - reason: "embedded message failed validation", - cause: err, - }) - } - } - } else if v, ok := interface{}(m.GetCreatedAt()).(interface{ Validate() error }); ok { - if err := v.Validate(); err != nil { - return NamespaceValidationError{ - field: "CreatedAt", - reason: "embedded message failed validation", - cause: err, - } - } - } - - if all { - switch v := interface{}(m.GetUpdatedAt()).(type) { - case interface{ ValidateAll() error }: - if err := v.ValidateAll(); err != nil { - errors = append(errors, NamespaceValidationError{ - field: "UpdatedAt", - reason: "embedded message failed validation", - cause: err, - }) - } - case interface{ Validate() error }: - if err := v.Validate(); err != nil { - errors = append(errors, NamespaceValidationError{ - field: "UpdatedAt", - reason: "embedded message failed validation", - cause: err, - }) - } - } - } else if v, ok := interface{}(m.GetUpdatedAt()).(interface{ Validate() error }); ok { - if err := v.Validate(); err != nil { - return NamespaceValidationError{ - field: "UpdatedAt", - reason: "embedded message failed validation", - cause: err, - } - } - } - - if len(errors) > 0 { - return NamespaceMultiError(errors) - } - return nil -} - -// NamespaceMultiError is an error wrapping multiple validation errors returned -// by Namespace.ValidateAll() if the designated constraints aren't met. -type NamespaceMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m NamespaceMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m NamespaceMultiError) AllErrors() []error { return m } - -// NamespaceValidationError is the validation error returned by -// Namespace.Validate if the designated constraints aren't met. -type NamespaceValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e NamespaceValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e NamespaceValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e NamespaceValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e NamespaceValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e NamespaceValidationError) ErrorName() string { return "NamespaceValidationError" } - -// Error satisfies the builtin error interface -func (e NamespaceValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sNamespace.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = NamespaceValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = NamespaceValidationError{} - -// Validate checks the field values on Schema with the rules defined in the -// proto definition for this message. If any rules are violated, the first -// error encountered is returned, or nil if there are no violations. -func (m *Schema) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on Schema with the rules defined in the -// proto definition for this message. If any rules are violated, the result is -// a list of violation errors wrapped in SchemaMultiError, or nil if none found. -func (m *Schema) ValidateAll() error { - return m.validate(true) -} - -func (m *Schema) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Name - - // no validation rules for Format - - // no validation rules for Authority - - // no validation rules for Compatibility - - if all { - switch v := interface{}(m.GetCreatedAt()).(type) { - case interface{ ValidateAll() error }: - if err := v.ValidateAll(); err != nil { - errors = append(errors, SchemaValidationError{ - field: "CreatedAt", - reason: "embedded message failed validation", - cause: err, - }) - } - case interface{ Validate() error }: - if err := v.Validate(); err != nil { - errors = append(errors, SchemaValidationError{ - field: "CreatedAt", - reason: "embedded message failed validation", - cause: err, - }) - } - } - } else if v, ok := interface{}(m.GetCreatedAt()).(interface{ Validate() error }); ok { - if err := v.Validate(); err != nil { - return SchemaValidationError{ - field: "CreatedAt", - reason: "embedded message failed validation", - cause: err, - } - } - } - - if all { - switch v := interface{}(m.GetUpdatedAt()).(type) { - case interface{ ValidateAll() error }: - if err := v.ValidateAll(); err != nil { - errors = append(errors, SchemaValidationError{ - field: "UpdatedAt", - reason: "embedded message failed validation", - cause: err, - }) - } - case interface{ Validate() error }: - if err := v.Validate(); err != nil { - errors = append(errors, SchemaValidationError{ - field: "UpdatedAt", - reason: "embedded message failed validation", - cause: err, - }) - } - } - } else if v, ok := interface{}(m.GetUpdatedAt()).(interface{ Validate() error }); ok { - if err := v.Validate(); err != nil { - return SchemaValidationError{ - field: "UpdatedAt", - reason: "embedded message failed validation", - cause: err, - } - } - } - - if len(errors) > 0 { - return SchemaMultiError(errors) - } - return nil -} - -// SchemaMultiError is an error wrapping multiple validation errors returned by -// Schema.ValidateAll() if the designated constraints aren't met. -type SchemaMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m SchemaMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m SchemaMultiError) AllErrors() []error { return m } - -// SchemaValidationError is the validation error returned by Schema.Validate if -// the designated constraints aren't met. -type SchemaValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e SchemaValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e SchemaValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e SchemaValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e SchemaValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e SchemaValidationError) ErrorName() string { return "SchemaValidationError" } - -// Error satisfies the builtin error interface -func (e SchemaValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sSchema.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = SchemaValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = SchemaValidationError{} - -// Validate checks the field values on ListNamespacesRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *ListNamespacesRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on ListNamespacesRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// ListNamespacesRequestMultiError, or nil if none found. -func (m *ListNamespacesRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *ListNamespacesRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - if len(errors) > 0 { - return ListNamespacesRequestMultiError(errors) - } - return nil -} - -// ListNamespacesRequestMultiError is an error wrapping multiple validation -// errors returned by ListNamespacesRequest.ValidateAll() if the designated -// constraints aren't met. -type ListNamespacesRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m ListNamespacesRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m ListNamespacesRequestMultiError) AllErrors() []error { return m } - -// ListNamespacesRequestValidationError is the validation error returned by -// ListNamespacesRequest.Validate if the designated constraints aren't met. -type ListNamespacesRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e ListNamespacesRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e ListNamespacesRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e ListNamespacesRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e ListNamespacesRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e ListNamespacesRequestValidationError) ErrorName() string { - return "ListNamespacesRequestValidationError" -} - -// Error satisfies the builtin error interface -func (e ListNamespacesRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sListNamespacesRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = ListNamespacesRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = ListNamespacesRequestValidationError{} - -// Validate checks the field values on ListNamespacesResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *ListNamespacesResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on ListNamespacesResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// ListNamespacesResponseMultiError, or nil if none found. -func (m *ListNamespacesResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *ListNamespacesResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - for idx, item := range m.GetNamespaces() { - _, _ = idx, item - - if all { - switch v := interface{}(item).(type) { - case interface{ ValidateAll() error }: - if err := v.ValidateAll(); err != nil { - errors = append(errors, ListNamespacesResponseValidationError{ - field: fmt.Sprintf("Namespaces[%v]", idx), - reason: "embedded message failed validation", - cause: err, - }) - } - case interface{ Validate() error }: - if err := v.Validate(); err != nil { - errors = append(errors, ListNamespacesResponseValidationError{ - field: fmt.Sprintf("Namespaces[%v]", idx), - reason: "embedded message failed validation", - cause: err, - }) - } - } - } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { - if err := v.Validate(); err != nil { - return ListNamespacesResponseValidationError{ - field: fmt.Sprintf("Namespaces[%v]", idx), - reason: "embedded message failed validation", - cause: err, - } - } - } - - } - - if len(errors) > 0 { - return ListNamespacesResponseMultiError(errors) - } - return nil -} - -// ListNamespacesResponseMultiError is an error wrapping multiple validation -// errors returned by ListNamespacesResponse.ValidateAll() if the designated -// constraints aren't met. -type ListNamespacesResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m ListNamespacesResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m ListNamespacesResponseMultiError) AllErrors() []error { return m } - -// ListNamespacesResponseValidationError is the validation error returned by -// ListNamespacesResponse.Validate if the designated constraints aren't met. -type ListNamespacesResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e ListNamespacesResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e ListNamespacesResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e ListNamespacesResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e ListNamespacesResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e ListNamespacesResponseValidationError) ErrorName() string { - return "ListNamespacesResponseValidationError" -} - -// Error satisfies the builtin error interface -func (e ListNamespacesResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sListNamespacesResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = ListNamespacesResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = ListNamespacesResponseValidationError{} - -// Validate checks the field values on GetNamespaceRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *GetNamespaceRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on GetNamespaceRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// GetNamespaceRequestMultiError, or nil if none found. -func (m *GetNamespaceRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *GetNamespaceRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Id - - if len(errors) > 0 { - return GetNamespaceRequestMultiError(errors) - } - return nil -} - -// GetNamespaceRequestMultiError is an error wrapping multiple validation -// errors returned by GetNamespaceRequest.ValidateAll() if the designated -// constraints aren't met. -type GetNamespaceRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m GetNamespaceRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m GetNamespaceRequestMultiError) AllErrors() []error { return m } - -// GetNamespaceRequestValidationError is the validation error returned by -// GetNamespaceRequest.Validate if the designated constraints aren't met. -type GetNamespaceRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e GetNamespaceRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e GetNamespaceRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e GetNamespaceRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e GetNamespaceRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e GetNamespaceRequestValidationError) ErrorName() string { - return "GetNamespaceRequestValidationError" -} - -// Error satisfies the builtin error interface -func (e GetNamespaceRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sGetNamespaceRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = GetNamespaceRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = GetNamespaceRequestValidationError{} - -// Validate checks the field values on GetNamespaceResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *GetNamespaceResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on GetNamespaceResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// GetNamespaceResponseMultiError, or nil if none found. -func (m *GetNamespaceResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *GetNamespaceResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - if all { - switch v := interface{}(m.GetNamespace()).(type) { - case interface{ ValidateAll() error }: - if err := v.ValidateAll(); err != nil { - errors = append(errors, GetNamespaceResponseValidationError{ - field: "Namespace", - reason: "embedded message failed validation", - cause: err, - }) - } - case interface{ Validate() error }: - if err := v.Validate(); err != nil { - errors = append(errors, GetNamespaceResponseValidationError{ - field: "Namespace", - reason: "embedded message failed validation", - cause: err, - }) - } - } - } else if v, ok := interface{}(m.GetNamespace()).(interface{ Validate() error }); ok { - if err := v.Validate(); err != nil { - return GetNamespaceResponseValidationError{ - field: "Namespace", - reason: "embedded message failed validation", - cause: err, - } - } - } - - if len(errors) > 0 { - return GetNamespaceResponseMultiError(errors) - } - return nil -} - -// GetNamespaceResponseMultiError is an error wrapping multiple validation -// errors returned by GetNamespaceResponse.ValidateAll() if the designated -// constraints aren't met. -type GetNamespaceResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m GetNamespaceResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m GetNamespaceResponseMultiError) AllErrors() []error { return m } - -// GetNamespaceResponseValidationError is the validation error returned by -// GetNamespaceResponse.Validate if the designated constraints aren't met. -type GetNamespaceResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e GetNamespaceResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e GetNamespaceResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e GetNamespaceResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e GetNamespaceResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e GetNamespaceResponseValidationError) ErrorName() string { - return "GetNamespaceResponseValidationError" -} - -// Error satisfies the builtin error interface -func (e GetNamespaceResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sGetNamespaceResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = GetNamespaceResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = GetNamespaceResponseValidationError{} - -// Validate checks the field values on CreateNamespaceRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *CreateNamespaceRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on CreateNamespaceRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// CreateNamespaceRequestMultiError, or nil if none found. -func (m *CreateNamespaceRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *CreateNamespaceRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Id - - // no validation rules for Format - - // no validation rules for Compatibility - - // no validation rules for Description - - if len(errors) > 0 { - return CreateNamespaceRequestMultiError(errors) - } - return nil -} - -// CreateNamespaceRequestMultiError is an error wrapping multiple validation -// errors returned by CreateNamespaceRequest.ValidateAll() if the designated -// constraints aren't met. -type CreateNamespaceRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m CreateNamespaceRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m CreateNamespaceRequestMultiError) AllErrors() []error { return m } - -// CreateNamespaceRequestValidationError is the validation error returned by -// CreateNamespaceRequest.Validate if the designated constraints aren't met. -type CreateNamespaceRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e CreateNamespaceRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e CreateNamespaceRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e CreateNamespaceRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e CreateNamespaceRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e CreateNamespaceRequestValidationError) ErrorName() string { - return "CreateNamespaceRequestValidationError" -} - -// Error satisfies the builtin error interface -func (e CreateNamespaceRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sCreateNamespaceRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = CreateNamespaceRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = CreateNamespaceRequestValidationError{} - -// Validate checks the field values on CreateNamespaceResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *CreateNamespaceResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on CreateNamespaceResponse with the -// rules defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// CreateNamespaceResponseMultiError, or nil if none found. -func (m *CreateNamespaceResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *CreateNamespaceResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - if all { - switch v := interface{}(m.GetNamespace()).(type) { - case interface{ ValidateAll() error }: - if err := v.ValidateAll(); err != nil { - errors = append(errors, CreateNamespaceResponseValidationError{ - field: "Namespace", - reason: "embedded message failed validation", - cause: err, - }) - } - case interface{ Validate() error }: - if err := v.Validate(); err != nil { - errors = append(errors, CreateNamespaceResponseValidationError{ - field: "Namespace", - reason: "embedded message failed validation", - cause: err, - }) - } - } - } else if v, ok := interface{}(m.GetNamespace()).(interface{ Validate() error }); ok { - if err := v.Validate(); err != nil { - return CreateNamespaceResponseValidationError{ - field: "Namespace", - reason: "embedded message failed validation", - cause: err, - } - } - } - - if len(errors) > 0 { - return CreateNamespaceResponseMultiError(errors) - } - return nil -} - -// CreateNamespaceResponseMultiError is an error wrapping multiple validation -// errors returned by CreateNamespaceResponse.ValidateAll() if the designated -// constraints aren't met. -type CreateNamespaceResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m CreateNamespaceResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m CreateNamespaceResponseMultiError) AllErrors() []error { return m } - -// CreateNamespaceResponseValidationError is the validation error returned by -// CreateNamespaceResponse.Validate if the designated constraints aren't met. -type CreateNamespaceResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e CreateNamespaceResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e CreateNamespaceResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e CreateNamespaceResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e CreateNamespaceResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e CreateNamespaceResponseValidationError) ErrorName() string { - return "CreateNamespaceResponseValidationError" -} - -// Error satisfies the builtin error interface -func (e CreateNamespaceResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sCreateNamespaceResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = CreateNamespaceResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = CreateNamespaceResponseValidationError{} - -// Validate checks the field values on UpdateNamespaceRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *UpdateNamespaceRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on UpdateNamespaceRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// UpdateNamespaceRequestMultiError, or nil if none found. -func (m *UpdateNamespaceRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *UpdateNamespaceRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Id - - // no validation rules for Format - - // no validation rules for Compatibility - - // no validation rules for Description - - if len(errors) > 0 { - return UpdateNamespaceRequestMultiError(errors) - } - return nil -} - -// UpdateNamespaceRequestMultiError is an error wrapping multiple validation -// errors returned by UpdateNamespaceRequest.ValidateAll() if the designated -// constraints aren't met. -type UpdateNamespaceRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m UpdateNamespaceRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m UpdateNamespaceRequestMultiError) AllErrors() []error { return m } - -// UpdateNamespaceRequestValidationError is the validation error returned by -// UpdateNamespaceRequest.Validate if the designated constraints aren't met. -type UpdateNamespaceRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e UpdateNamespaceRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e UpdateNamespaceRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e UpdateNamespaceRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e UpdateNamespaceRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e UpdateNamespaceRequestValidationError) ErrorName() string { - return "UpdateNamespaceRequestValidationError" -} - -// Error satisfies the builtin error interface -func (e UpdateNamespaceRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sUpdateNamespaceRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = UpdateNamespaceRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = UpdateNamespaceRequestValidationError{} - -// Validate checks the field values on UpdateNamespaceResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *UpdateNamespaceResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on UpdateNamespaceResponse with the -// rules defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// UpdateNamespaceResponseMultiError, or nil if none found. -func (m *UpdateNamespaceResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *UpdateNamespaceResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - if all { - switch v := interface{}(m.GetNamespace()).(type) { - case interface{ ValidateAll() error }: - if err := v.ValidateAll(); err != nil { - errors = append(errors, UpdateNamespaceResponseValidationError{ - field: "Namespace", - reason: "embedded message failed validation", - cause: err, - }) - } - case interface{ Validate() error }: - if err := v.Validate(); err != nil { - errors = append(errors, UpdateNamespaceResponseValidationError{ - field: "Namespace", - reason: "embedded message failed validation", - cause: err, - }) - } - } - } else if v, ok := interface{}(m.GetNamespace()).(interface{ Validate() error }); ok { - if err := v.Validate(); err != nil { - return UpdateNamespaceResponseValidationError{ - field: "Namespace", - reason: "embedded message failed validation", - cause: err, - } - } - } - - if len(errors) > 0 { - return UpdateNamespaceResponseMultiError(errors) - } - return nil -} - -// UpdateNamespaceResponseMultiError is an error wrapping multiple validation -// errors returned by UpdateNamespaceResponse.ValidateAll() if the designated -// constraints aren't met. -type UpdateNamespaceResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m UpdateNamespaceResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m UpdateNamespaceResponseMultiError) AllErrors() []error { return m } - -// UpdateNamespaceResponseValidationError is the validation error returned by -// UpdateNamespaceResponse.Validate if the designated constraints aren't met. -type UpdateNamespaceResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e UpdateNamespaceResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e UpdateNamespaceResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e UpdateNamespaceResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e UpdateNamespaceResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e UpdateNamespaceResponseValidationError) ErrorName() string { - return "UpdateNamespaceResponseValidationError" -} - -// Error satisfies the builtin error interface -func (e UpdateNamespaceResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sUpdateNamespaceResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = UpdateNamespaceResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = UpdateNamespaceResponseValidationError{} - -// Validate checks the field values on DeleteNamespaceRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *DeleteNamespaceRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on DeleteNamespaceRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// DeleteNamespaceRequestMultiError, or nil if none found. -func (m *DeleteNamespaceRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *DeleteNamespaceRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Id - - if len(errors) > 0 { - return DeleteNamespaceRequestMultiError(errors) - } - return nil -} - -// DeleteNamespaceRequestMultiError is an error wrapping multiple validation -// errors returned by DeleteNamespaceRequest.ValidateAll() if the designated -// constraints aren't met. -type DeleteNamespaceRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m DeleteNamespaceRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m DeleteNamespaceRequestMultiError) AllErrors() []error { return m } - -// DeleteNamespaceRequestValidationError is the validation error returned by -// DeleteNamespaceRequest.Validate if the designated constraints aren't met. -type DeleteNamespaceRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e DeleteNamespaceRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e DeleteNamespaceRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e DeleteNamespaceRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e DeleteNamespaceRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e DeleteNamespaceRequestValidationError) ErrorName() string { - return "DeleteNamespaceRequestValidationError" -} - -// Error satisfies the builtin error interface -func (e DeleteNamespaceRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sDeleteNamespaceRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = DeleteNamespaceRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = DeleteNamespaceRequestValidationError{} - -// Validate checks the field values on DeleteNamespaceResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *DeleteNamespaceResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on DeleteNamespaceResponse with the -// rules defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// DeleteNamespaceResponseMultiError, or nil if none found. -func (m *DeleteNamespaceResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *DeleteNamespaceResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Message - - if len(errors) > 0 { - return DeleteNamespaceResponseMultiError(errors) - } - return nil -} - -// DeleteNamespaceResponseMultiError is an error wrapping multiple validation -// errors returned by DeleteNamespaceResponse.ValidateAll() if the designated -// constraints aren't met. -type DeleteNamespaceResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m DeleteNamespaceResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m DeleteNamespaceResponseMultiError) AllErrors() []error { return m } - -// DeleteNamespaceResponseValidationError is the validation error returned by -// DeleteNamespaceResponse.Validate if the designated constraints aren't met. -type DeleteNamespaceResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e DeleteNamespaceResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e DeleteNamespaceResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e DeleteNamespaceResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e DeleteNamespaceResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e DeleteNamespaceResponseValidationError) ErrorName() string { - return "DeleteNamespaceResponseValidationError" -} - -// Error satisfies the builtin error interface -func (e DeleteNamespaceResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sDeleteNamespaceResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = DeleteNamespaceResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = DeleteNamespaceResponseValidationError{} - -// Validate checks the field values on ListSchemasRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *ListSchemasRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on ListSchemasRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// ListSchemasRequestMultiError, or nil if none found. -func (m *ListSchemasRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *ListSchemasRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Id - - if len(errors) > 0 { - return ListSchemasRequestMultiError(errors) - } - return nil -} - -// ListSchemasRequestMultiError is an error wrapping multiple validation errors -// returned by ListSchemasRequest.ValidateAll() if the designated constraints -// aren't met. -type ListSchemasRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m ListSchemasRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m ListSchemasRequestMultiError) AllErrors() []error { return m } - -// ListSchemasRequestValidationError is the validation error returned by -// ListSchemasRequest.Validate if the designated constraints aren't met. -type ListSchemasRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e ListSchemasRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e ListSchemasRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e ListSchemasRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e ListSchemasRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e ListSchemasRequestValidationError) ErrorName() string { - return "ListSchemasRequestValidationError" -} - -// Error satisfies the builtin error interface -func (e ListSchemasRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sListSchemasRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = ListSchemasRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = ListSchemasRequestValidationError{} - -// Validate checks the field values on ListSchemasResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *ListSchemasResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on ListSchemasResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// ListSchemasResponseMultiError, or nil if none found. -func (m *ListSchemasResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *ListSchemasResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - for idx, item := range m.GetSchemas() { - _, _ = idx, item - - if all { - switch v := interface{}(item).(type) { - case interface{ ValidateAll() error }: - if err := v.ValidateAll(); err != nil { - errors = append(errors, ListSchemasResponseValidationError{ - field: fmt.Sprintf("Schemas[%v]", idx), - reason: "embedded message failed validation", - cause: err, - }) - } - case interface{ Validate() error }: - if err := v.Validate(); err != nil { - errors = append(errors, ListSchemasResponseValidationError{ - field: fmt.Sprintf("Schemas[%v]", idx), - reason: "embedded message failed validation", - cause: err, - }) - } - } - } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { - if err := v.Validate(); err != nil { - return ListSchemasResponseValidationError{ - field: fmt.Sprintf("Schemas[%v]", idx), - reason: "embedded message failed validation", - cause: err, - } - } - } - - } - - if len(errors) > 0 { - return ListSchemasResponseMultiError(errors) - } - return nil -} - -// ListSchemasResponseMultiError is an error wrapping multiple validation -// errors returned by ListSchemasResponse.ValidateAll() if the designated -// constraints aren't met. -type ListSchemasResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m ListSchemasResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m ListSchemasResponseMultiError) AllErrors() []error { return m } - -// ListSchemasResponseValidationError is the validation error returned by -// ListSchemasResponse.Validate if the designated constraints aren't met. -type ListSchemasResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e ListSchemasResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e ListSchemasResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e ListSchemasResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e ListSchemasResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e ListSchemasResponseValidationError) ErrorName() string { - return "ListSchemasResponseValidationError" -} - -// Error satisfies the builtin error interface -func (e ListSchemasResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sListSchemasResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = ListSchemasResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = ListSchemasResponseValidationError{} - -// Validate checks the field values on GetLatestSchemaRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *GetLatestSchemaRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on GetLatestSchemaRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// GetLatestSchemaRequestMultiError, or nil if none found. -func (m *GetLatestSchemaRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *GetLatestSchemaRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for NamespaceId - - // no validation rules for SchemaId - - if len(errors) > 0 { - return GetLatestSchemaRequestMultiError(errors) - } - return nil -} - -// GetLatestSchemaRequestMultiError is an error wrapping multiple validation -// errors returned by GetLatestSchemaRequest.ValidateAll() if the designated -// constraints aren't met. -type GetLatestSchemaRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m GetLatestSchemaRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m GetLatestSchemaRequestMultiError) AllErrors() []error { return m } - -// GetLatestSchemaRequestValidationError is the validation error returned by -// GetLatestSchemaRequest.Validate if the designated constraints aren't met. -type GetLatestSchemaRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e GetLatestSchemaRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e GetLatestSchemaRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e GetLatestSchemaRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e GetLatestSchemaRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e GetLatestSchemaRequestValidationError) ErrorName() string { - return "GetLatestSchemaRequestValidationError" -} - -// Error satisfies the builtin error interface -func (e GetLatestSchemaRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sGetLatestSchemaRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = GetLatestSchemaRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = GetLatestSchemaRequestValidationError{} - -// Validate checks the field values on GetLatestSchemaResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *GetLatestSchemaResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on GetLatestSchemaResponse with the -// rules defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// GetLatestSchemaResponseMultiError, or nil if none found. -func (m *GetLatestSchemaResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *GetLatestSchemaResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Data - - if len(errors) > 0 { - return GetLatestSchemaResponseMultiError(errors) - } - return nil -} - -// GetLatestSchemaResponseMultiError is an error wrapping multiple validation -// errors returned by GetLatestSchemaResponse.ValidateAll() if the designated -// constraints aren't met. -type GetLatestSchemaResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m GetLatestSchemaResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m GetLatestSchemaResponseMultiError) AllErrors() []error { return m } - -// GetLatestSchemaResponseValidationError is the validation error returned by -// GetLatestSchemaResponse.Validate if the designated constraints aren't met. -type GetLatestSchemaResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e GetLatestSchemaResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e GetLatestSchemaResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e GetLatestSchemaResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e GetLatestSchemaResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e GetLatestSchemaResponseValidationError) ErrorName() string { - return "GetLatestSchemaResponseValidationError" -} - -// Error satisfies the builtin error interface -func (e GetLatestSchemaResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sGetLatestSchemaResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = GetLatestSchemaResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = GetLatestSchemaResponseValidationError{} - -// Validate checks the field values on CreateSchemaRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *CreateSchemaRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on CreateSchemaRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// CreateSchemaRequestMultiError, or nil if none found. -func (m *CreateSchemaRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *CreateSchemaRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for NamespaceId - - // no validation rules for SchemaId - - // no validation rules for Data - - // no validation rules for Format - - // no validation rules for Compatibility - - if len(errors) > 0 { - return CreateSchemaRequestMultiError(errors) - } - return nil -} - -// CreateSchemaRequestMultiError is an error wrapping multiple validation -// errors returned by CreateSchemaRequest.ValidateAll() if the designated -// constraints aren't met. -type CreateSchemaRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m CreateSchemaRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m CreateSchemaRequestMultiError) AllErrors() []error { return m } - -// CreateSchemaRequestValidationError is the validation error returned by -// CreateSchemaRequest.Validate if the designated constraints aren't met. -type CreateSchemaRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e CreateSchemaRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e CreateSchemaRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e CreateSchemaRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e CreateSchemaRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e CreateSchemaRequestValidationError) ErrorName() string { - return "CreateSchemaRequestValidationError" -} - -// Error satisfies the builtin error interface -func (e CreateSchemaRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sCreateSchemaRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = CreateSchemaRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = CreateSchemaRequestValidationError{} - -// Validate checks the field values on CreateSchemaResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *CreateSchemaResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on CreateSchemaResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// CreateSchemaResponseMultiError, or nil if none found. -func (m *CreateSchemaResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *CreateSchemaResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Version - - // no validation rules for Id - - // no validation rules for Location - - if len(errors) > 0 { - return CreateSchemaResponseMultiError(errors) - } - return nil -} - -// CreateSchemaResponseMultiError is an error wrapping multiple validation -// errors returned by CreateSchemaResponse.ValidateAll() if the designated -// constraints aren't met. -type CreateSchemaResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m CreateSchemaResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m CreateSchemaResponseMultiError) AllErrors() []error { return m } - -// CreateSchemaResponseValidationError is the validation error returned by -// CreateSchemaResponse.Validate if the designated constraints aren't met. -type CreateSchemaResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e CreateSchemaResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e CreateSchemaResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e CreateSchemaResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e CreateSchemaResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e CreateSchemaResponseValidationError) ErrorName() string { - return "CreateSchemaResponseValidationError" -} - -// Error satisfies the builtin error interface -func (e CreateSchemaResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sCreateSchemaResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = CreateSchemaResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = CreateSchemaResponseValidationError{} - -// Validate checks the field values on CheckCompatibilityRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *CheckCompatibilityRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on CheckCompatibilityRequest with the -// rules defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// CheckCompatibilityRequestMultiError, or nil if none found. -func (m *CheckCompatibilityRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *CheckCompatibilityRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for NamespaceId - - // no validation rules for SchemaId - - // no validation rules for Data - - // no validation rules for Compatibility - - if len(errors) > 0 { - return CheckCompatibilityRequestMultiError(errors) - } - return nil -} - -// CheckCompatibilityRequestMultiError is an error wrapping multiple validation -// errors returned by CheckCompatibilityRequest.ValidateAll() if the -// designated constraints aren't met. -type CheckCompatibilityRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m CheckCompatibilityRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m CheckCompatibilityRequestMultiError) AllErrors() []error { return m } - -// CheckCompatibilityRequestValidationError is the validation error returned by -// CheckCompatibilityRequest.Validate if the designated constraints aren't met. -type CheckCompatibilityRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e CheckCompatibilityRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e CheckCompatibilityRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e CheckCompatibilityRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e CheckCompatibilityRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e CheckCompatibilityRequestValidationError) ErrorName() string { - return "CheckCompatibilityRequestValidationError" -} - -// Error satisfies the builtin error interface -func (e CheckCompatibilityRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sCheckCompatibilityRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = CheckCompatibilityRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = CheckCompatibilityRequestValidationError{} - -// Validate checks the field values on CheckCompatibilityResponse with the -// rules defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *CheckCompatibilityResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on CheckCompatibilityResponse with the -// rules defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// CheckCompatibilityResponseMultiError, or nil if none found. -func (m *CheckCompatibilityResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *CheckCompatibilityResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - if len(errors) > 0 { - return CheckCompatibilityResponseMultiError(errors) - } - return nil -} - -// CheckCompatibilityResponseMultiError is an error wrapping multiple -// validation errors returned by CheckCompatibilityResponse.ValidateAll() if -// the designated constraints aren't met. -type CheckCompatibilityResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m CheckCompatibilityResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m CheckCompatibilityResponseMultiError) AllErrors() []error { return m } - -// CheckCompatibilityResponseValidationError is the validation error returned -// by CheckCompatibilityResponse.Validate if the designated constraints aren't met. -type CheckCompatibilityResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e CheckCompatibilityResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e CheckCompatibilityResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e CheckCompatibilityResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e CheckCompatibilityResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e CheckCompatibilityResponseValidationError) ErrorName() string { - return "CheckCompatibilityResponseValidationError" -} - -// Error satisfies the builtin error interface -func (e CheckCompatibilityResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sCheckCompatibilityResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = CheckCompatibilityResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = CheckCompatibilityResponseValidationError{} - -// Validate checks the field values on GetSchemaMetadataRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *GetSchemaMetadataRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on GetSchemaMetadataRequest with the -// rules defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// GetSchemaMetadataRequestMultiError, or nil if none found. -func (m *GetSchemaMetadataRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *GetSchemaMetadataRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for NamespaceId - - // no validation rules for SchemaId - - if len(errors) > 0 { - return GetSchemaMetadataRequestMultiError(errors) - } - return nil -} - -// GetSchemaMetadataRequestMultiError is an error wrapping multiple validation -// errors returned by GetSchemaMetadataRequest.ValidateAll() if the designated -// constraints aren't met. -type GetSchemaMetadataRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m GetSchemaMetadataRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m GetSchemaMetadataRequestMultiError) AllErrors() []error { return m } - -// GetSchemaMetadataRequestValidationError is the validation error returned by -// GetSchemaMetadataRequest.Validate if the designated constraints aren't met. -type GetSchemaMetadataRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e GetSchemaMetadataRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e GetSchemaMetadataRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e GetSchemaMetadataRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e GetSchemaMetadataRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e GetSchemaMetadataRequestValidationError) ErrorName() string { - return "GetSchemaMetadataRequestValidationError" -} - -// Error satisfies the builtin error interface -func (e GetSchemaMetadataRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sGetSchemaMetadataRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = GetSchemaMetadataRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = GetSchemaMetadataRequestValidationError{} - -// Validate checks the field values on GetSchemaMetadataResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *GetSchemaMetadataResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on GetSchemaMetadataResponse with the -// rules defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// GetSchemaMetadataResponseMultiError, or nil if none found. -func (m *GetSchemaMetadataResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *GetSchemaMetadataResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Format - - // no validation rules for Compatibility - - // no validation rules for Authority - - // no validation rules for Name - - if all { - switch v := interface{}(m.GetCreatedAt()).(type) { - case interface{ ValidateAll() error }: - if err := v.ValidateAll(); err != nil { - errors = append(errors, GetSchemaMetadataResponseValidationError{ - field: "CreatedAt", - reason: "embedded message failed validation", - cause: err, - }) - } - case interface{ Validate() error }: - if err := v.Validate(); err != nil { - errors = append(errors, GetSchemaMetadataResponseValidationError{ - field: "CreatedAt", - reason: "embedded message failed validation", - cause: err, - }) - } - } - } else if v, ok := interface{}(m.GetCreatedAt()).(interface{ Validate() error }); ok { - if err := v.Validate(); err != nil { - return GetSchemaMetadataResponseValidationError{ - field: "CreatedAt", - reason: "embedded message failed validation", - cause: err, - } - } - } - - if all { - switch v := interface{}(m.GetUpdatedAt()).(type) { - case interface{ ValidateAll() error }: - if err := v.ValidateAll(); err != nil { - errors = append(errors, GetSchemaMetadataResponseValidationError{ - field: "UpdatedAt", - reason: "embedded message failed validation", - cause: err, - }) - } - case interface{ Validate() error }: - if err := v.Validate(); err != nil { - errors = append(errors, GetSchemaMetadataResponseValidationError{ - field: "UpdatedAt", - reason: "embedded message failed validation", - cause: err, - }) - } - } - } else if v, ok := interface{}(m.GetUpdatedAt()).(interface{ Validate() error }); ok { - if err := v.Validate(); err != nil { - return GetSchemaMetadataResponseValidationError{ - field: "UpdatedAt", - reason: "embedded message failed validation", - cause: err, - } - } - } - - if len(errors) > 0 { - return GetSchemaMetadataResponseMultiError(errors) - } - return nil -} - -// GetSchemaMetadataResponseMultiError is an error wrapping multiple validation -// errors returned by GetSchemaMetadataResponse.ValidateAll() if the -// designated constraints aren't met. -type GetSchemaMetadataResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m GetSchemaMetadataResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m GetSchemaMetadataResponseMultiError) AllErrors() []error { return m } - -// GetSchemaMetadataResponseValidationError is the validation error returned by -// GetSchemaMetadataResponse.Validate if the designated constraints aren't met. -type GetSchemaMetadataResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e GetSchemaMetadataResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e GetSchemaMetadataResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e GetSchemaMetadataResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e GetSchemaMetadataResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e GetSchemaMetadataResponseValidationError) ErrorName() string { - return "GetSchemaMetadataResponseValidationError" -} - -// Error satisfies the builtin error interface -func (e GetSchemaMetadataResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sGetSchemaMetadataResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = GetSchemaMetadataResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = GetSchemaMetadataResponseValidationError{} - -// Validate checks the field values on UpdateSchemaMetadataRequest with the -// rules defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *UpdateSchemaMetadataRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on UpdateSchemaMetadataRequest with the -// rules defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// UpdateSchemaMetadataRequestMultiError, or nil if none found. -func (m *UpdateSchemaMetadataRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *UpdateSchemaMetadataRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for NamespaceId - - // no validation rules for SchemaId - - // no validation rules for Compatibility - - if len(errors) > 0 { - return UpdateSchemaMetadataRequestMultiError(errors) - } - return nil -} - -// UpdateSchemaMetadataRequestMultiError is an error wrapping multiple -// validation errors returned by UpdateSchemaMetadataRequest.ValidateAll() if -// the designated constraints aren't met. -type UpdateSchemaMetadataRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m UpdateSchemaMetadataRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m UpdateSchemaMetadataRequestMultiError) AllErrors() []error { return m } - -// UpdateSchemaMetadataRequestValidationError is the validation error returned -// by UpdateSchemaMetadataRequest.Validate if the designated constraints -// aren't met. -type UpdateSchemaMetadataRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e UpdateSchemaMetadataRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e UpdateSchemaMetadataRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e UpdateSchemaMetadataRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e UpdateSchemaMetadataRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e UpdateSchemaMetadataRequestValidationError) ErrorName() string { - return "UpdateSchemaMetadataRequestValidationError" -} - -// Error satisfies the builtin error interface -func (e UpdateSchemaMetadataRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sUpdateSchemaMetadataRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = UpdateSchemaMetadataRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = UpdateSchemaMetadataRequestValidationError{} - -// Validate checks the field values on UpdateSchemaMetadataResponse with the -// rules defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *UpdateSchemaMetadataResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on UpdateSchemaMetadataResponse with the -// rules defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// UpdateSchemaMetadataResponseMultiError, or nil if none found. -func (m *UpdateSchemaMetadataResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *UpdateSchemaMetadataResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Format - - // no validation rules for Compatibility - - // no validation rules for Authority - - if len(errors) > 0 { - return UpdateSchemaMetadataResponseMultiError(errors) - } - return nil -} - -// UpdateSchemaMetadataResponseMultiError is an error wrapping multiple -// validation errors returned by UpdateSchemaMetadataResponse.ValidateAll() if -// the designated constraints aren't met. -type UpdateSchemaMetadataResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m UpdateSchemaMetadataResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m UpdateSchemaMetadataResponseMultiError) AllErrors() []error { return m } - -// UpdateSchemaMetadataResponseValidationError is the validation error returned -// by UpdateSchemaMetadataResponse.Validate if the designated constraints -// aren't met. -type UpdateSchemaMetadataResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e UpdateSchemaMetadataResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e UpdateSchemaMetadataResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e UpdateSchemaMetadataResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e UpdateSchemaMetadataResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e UpdateSchemaMetadataResponseValidationError) ErrorName() string { - return "UpdateSchemaMetadataResponseValidationError" -} - -// Error satisfies the builtin error interface -func (e UpdateSchemaMetadataResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sUpdateSchemaMetadataResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = UpdateSchemaMetadataResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = UpdateSchemaMetadataResponseValidationError{} - -// Validate checks the field values on DeleteSchemaRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *DeleteSchemaRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on DeleteSchemaRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// DeleteSchemaRequestMultiError, or nil if none found. -func (m *DeleteSchemaRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *DeleteSchemaRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for NamespaceId - - // no validation rules for SchemaId - - if len(errors) > 0 { - return DeleteSchemaRequestMultiError(errors) - } - return nil -} - -// DeleteSchemaRequestMultiError is an error wrapping multiple validation -// errors returned by DeleteSchemaRequest.ValidateAll() if the designated -// constraints aren't met. -type DeleteSchemaRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m DeleteSchemaRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m DeleteSchemaRequestMultiError) AllErrors() []error { return m } - -// DeleteSchemaRequestValidationError is the validation error returned by -// DeleteSchemaRequest.Validate if the designated constraints aren't met. -type DeleteSchemaRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e DeleteSchemaRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e DeleteSchemaRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e DeleteSchemaRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e DeleteSchemaRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e DeleteSchemaRequestValidationError) ErrorName() string { - return "DeleteSchemaRequestValidationError" -} - -// Error satisfies the builtin error interface -func (e DeleteSchemaRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sDeleteSchemaRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = DeleteSchemaRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = DeleteSchemaRequestValidationError{} - -// Validate checks the field values on DeleteSchemaResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *DeleteSchemaResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on DeleteSchemaResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// DeleteSchemaResponseMultiError, or nil if none found. -func (m *DeleteSchemaResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *DeleteSchemaResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Message - - if len(errors) > 0 { - return DeleteSchemaResponseMultiError(errors) - } - return nil -} - -// DeleteSchemaResponseMultiError is an error wrapping multiple validation -// errors returned by DeleteSchemaResponse.ValidateAll() if the designated -// constraints aren't met. -type DeleteSchemaResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m DeleteSchemaResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m DeleteSchemaResponseMultiError) AllErrors() []error { return m } - -// DeleteSchemaResponseValidationError is the validation error returned by -// DeleteSchemaResponse.Validate if the designated constraints aren't met. -type DeleteSchemaResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e DeleteSchemaResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e DeleteSchemaResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e DeleteSchemaResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e DeleteSchemaResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e DeleteSchemaResponseValidationError) ErrorName() string { - return "DeleteSchemaResponseValidationError" -} - -// Error satisfies the builtin error interface -func (e DeleteSchemaResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sDeleteSchemaResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = DeleteSchemaResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = DeleteSchemaResponseValidationError{} - -// Validate checks the field values on ListVersionsRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *ListVersionsRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on ListVersionsRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// ListVersionsRequestMultiError, or nil if none found. -func (m *ListVersionsRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *ListVersionsRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for NamespaceId - - // no validation rules for SchemaId - - if len(errors) > 0 { - return ListVersionsRequestMultiError(errors) - } - return nil -} - -// ListVersionsRequestMultiError is an error wrapping multiple validation -// errors returned by ListVersionsRequest.ValidateAll() if the designated -// constraints aren't met. -type ListVersionsRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m ListVersionsRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m ListVersionsRequestMultiError) AllErrors() []error { return m } - -// ListVersionsRequestValidationError is the validation error returned by -// ListVersionsRequest.Validate if the designated constraints aren't met. -type ListVersionsRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e ListVersionsRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e ListVersionsRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e ListVersionsRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e ListVersionsRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e ListVersionsRequestValidationError) ErrorName() string { - return "ListVersionsRequestValidationError" -} - -// Error satisfies the builtin error interface -func (e ListVersionsRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sListVersionsRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = ListVersionsRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = ListVersionsRequestValidationError{} - -// Validate checks the field values on ListVersionsResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *ListVersionsResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on ListVersionsResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// ListVersionsResponseMultiError, or nil if none found. -func (m *ListVersionsResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *ListVersionsResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - if len(errors) > 0 { - return ListVersionsResponseMultiError(errors) - } - return nil -} - -// ListVersionsResponseMultiError is an error wrapping multiple validation -// errors returned by ListVersionsResponse.ValidateAll() if the designated -// constraints aren't met. -type ListVersionsResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m ListVersionsResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m ListVersionsResponseMultiError) AllErrors() []error { return m } - -// ListVersionsResponseValidationError is the validation error returned by -// ListVersionsResponse.Validate if the designated constraints aren't met. -type ListVersionsResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e ListVersionsResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e ListVersionsResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e ListVersionsResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e ListVersionsResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e ListVersionsResponseValidationError) ErrorName() string { - return "ListVersionsResponseValidationError" -} - -// Error satisfies the builtin error interface -func (e ListVersionsResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sListVersionsResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = ListVersionsResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = ListVersionsResponseValidationError{} - -// Validate checks the field values on GetSchemaRequest with the rules defined -// in the proto definition for this message. If any rules are violated, the -// first error encountered is returned, or nil if there are no violations. -func (m *GetSchemaRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on GetSchemaRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// GetSchemaRequestMultiError, or nil if none found. -func (m *GetSchemaRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *GetSchemaRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for NamespaceId - - // no validation rules for SchemaId - - // no validation rules for VersionId - - if len(errors) > 0 { - return GetSchemaRequestMultiError(errors) - } - return nil -} - -// GetSchemaRequestMultiError is an error wrapping multiple validation errors -// returned by GetSchemaRequest.ValidateAll() if the designated constraints -// aren't met. -type GetSchemaRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m GetSchemaRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m GetSchemaRequestMultiError) AllErrors() []error { return m } - -// GetSchemaRequestValidationError is the validation error returned by -// GetSchemaRequest.Validate if the designated constraints aren't met. -type GetSchemaRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e GetSchemaRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e GetSchemaRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e GetSchemaRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e GetSchemaRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e GetSchemaRequestValidationError) ErrorName() string { return "GetSchemaRequestValidationError" } - -// Error satisfies the builtin error interface -func (e GetSchemaRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sGetSchemaRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = GetSchemaRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = GetSchemaRequestValidationError{} - -// Validate checks the field values on GetSchemaResponse with the rules defined -// in the proto definition for this message. If any rules are violated, the -// first error encountered is returned, or nil if there are no violations. -func (m *GetSchemaResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on GetSchemaResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// GetSchemaResponseMultiError, or nil if none found. -func (m *GetSchemaResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *GetSchemaResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Data - - if len(errors) > 0 { - return GetSchemaResponseMultiError(errors) - } - return nil -} - -// GetSchemaResponseMultiError is an error wrapping multiple validation errors -// returned by GetSchemaResponse.ValidateAll() if the designated constraints -// aren't met. -type GetSchemaResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m GetSchemaResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m GetSchemaResponseMultiError) AllErrors() []error { return m } - -// GetSchemaResponseValidationError is the validation error returned by -// GetSchemaResponse.Validate if the designated constraints aren't met. -type GetSchemaResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e GetSchemaResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e GetSchemaResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e GetSchemaResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e GetSchemaResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e GetSchemaResponseValidationError) ErrorName() string { - return "GetSchemaResponseValidationError" -} - -// Error satisfies the builtin error interface -func (e GetSchemaResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sGetSchemaResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = GetSchemaResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = GetSchemaResponseValidationError{} - -// Validate checks the field values on DeleteVersionRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *DeleteVersionRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on DeleteVersionRequest with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// DeleteVersionRequestMultiError, or nil if none found. -func (m *DeleteVersionRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *DeleteVersionRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for NamespaceId - - // no validation rules for SchemaId - - // no validation rules for VersionId - - if len(errors) > 0 { - return DeleteVersionRequestMultiError(errors) - } - return nil -} - -// DeleteVersionRequestMultiError is an error wrapping multiple validation -// errors returned by DeleteVersionRequest.ValidateAll() if the designated -// constraints aren't met. -type DeleteVersionRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m DeleteVersionRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m DeleteVersionRequestMultiError) AllErrors() []error { return m } - -// DeleteVersionRequestValidationError is the validation error returned by -// DeleteVersionRequest.Validate if the designated constraints aren't met. -type DeleteVersionRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e DeleteVersionRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e DeleteVersionRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e DeleteVersionRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e DeleteVersionRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e DeleteVersionRequestValidationError) ErrorName() string { - return "DeleteVersionRequestValidationError" -} - -// Error satisfies the builtin error interface -func (e DeleteVersionRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sDeleteVersionRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = DeleteVersionRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = DeleteVersionRequestValidationError{} - -// Validate checks the field values on DeleteVersionResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the first error encountered is returned, or nil if there are no violations. -func (m *DeleteVersionResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on DeleteVersionResponse with the rules -// defined in the proto definition for this message. If any rules are -// violated, the result is a list of violation errors wrapped in -// DeleteVersionResponseMultiError, or nil if none found. -func (m *DeleteVersionResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *DeleteVersionResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Message - - if len(errors) > 0 { - return DeleteVersionResponseMultiError(errors) - } - return nil -} - -// DeleteVersionResponseMultiError is an error wrapping multiple validation -// errors returned by DeleteVersionResponse.ValidateAll() if the designated -// constraints aren't met. -type DeleteVersionResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m DeleteVersionResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m DeleteVersionResponseMultiError) AllErrors() []error { return m } - -// DeleteVersionResponseValidationError is the validation error returned by -// DeleteVersionResponse.Validate if the designated constraints aren't met. -type DeleteVersionResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e DeleteVersionResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e DeleteVersionResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e DeleteVersionResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e DeleteVersionResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e DeleteVersionResponseValidationError) ErrorName() string { - return "DeleteVersionResponseValidationError" -} - -// Error satisfies the builtin error interface -func (e DeleteVersionResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sDeleteVersionResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = DeleteVersionResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = DeleteVersionResponseValidationError{} - -// Validate checks the field values on SearchRequest with the rules defined in -// the proto definition for this message. If any rules are violated, the first -// error encountered is returned, or nil if there are no violations. -func (m *SearchRequest) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on SearchRequest with the rules defined -// in the proto definition for this message. If any rules are violated, the -// result is a list of violation errors wrapped in SearchRequestMultiError, or -// nil if none found. -func (m *SearchRequest) ValidateAll() error { - return m.validate(true) -} - -func (m *SearchRequest) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for NamespaceId - - // no validation rules for SchemaId - - // no validation rules for Query - - switch m.Version.(type) { - - case *SearchRequest_History: - // no validation rules for History - - case *SearchRequest_VersionId: - // no validation rules for VersionId - - } - - if len(errors) > 0 { - return SearchRequestMultiError(errors) - } - return nil -} - -// SearchRequestMultiError is an error wrapping multiple validation errors -// returned by SearchRequest.ValidateAll() if the designated constraints -// aren't met. -type SearchRequestMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m SearchRequestMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m SearchRequestMultiError) AllErrors() []error { return m } - -// SearchRequestValidationError is the validation error returned by -// SearchRequest.Validate if the designated constraints aren't met. -type SearchRequestValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e SearchRequestValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e SearchRequestValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e SearchRequestValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e SearchRequestValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e SearchRequestValidationError) ErrorName() string { return "SearchRequestValidationError" } - -// Error satisfies the builtin error interface -func (e SearchRequestValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sSearchRequest.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = SearchRequestValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = SearchRequestValidationError{} - -// Validate checks the field values on SearchResponse with the rules defined in -// the proto definition for this message. If any rules are violated, the first -// error encountered is returned, or nil if there are no violations. -func (m *SearchResponse) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on SearchResponse with the rules defined -// in the proto definition for this message. If any rules are violated, the -// result is a list of violation errors wrapped in SearchResponseMultiError, -// or nil if none found. -func (m *SearchResponse) ValidateAll() error { - return m.validate(true) -} - -func (m *SearchResponse) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - for idx, item := range m.GetHits() { - _, _ = idx, item - - if all { - switch v := interface{}(item).(type) { - case interface{ ValidateAll() error }: - if err := v.ValidateAll(); err != nil { - errors = append(errors, SearchResponseValidationError{ - field: fmt.Sprintf("Hits[%v]", idx), - reason: "embedded message failed validation", - cause: err, - }) - } - case interface{ Validate() error }: - if err := v.Validate(); err != nil { - errors = append(errors, SearchResponseValidationError{ - field: fmt.Sprintf("Hits[%v]", idx), - reason: "embedded message failed validation", - cause: err, - }) - } - } - } else if v, ok := interface{}(item).(interface{ Validate() error }); ok { - if err := v.Validate(); err != nil { - return SearchResponseValidationError{ - field: fmt.Sprintf("Hits[%v]", idx), - reason: "embedded message failed validation", - cause: err, - } - } - } - - } - - if all { - switch v := interface{}(m.GetMeta()).(type) { - case interface{ ValidateAll() error }: - if err := v.ValidateAll(); err != nil { - errors = append(errors, SearchResponseValidationError{ - field: "Meta", - reason: "embedded message failed validation", - cause: err, - }) - } - case interface{ Validate() error }: - if err := v.Validate(); err != nil { - errors = append(errors, SearchResponseValidationError{ - field: "Meta", - reason: "embedded message failed validation", - cause: err, - }) - } - } - } else if v, ok := interface{}(m.GetMeta()).(interface{ Validate() error }); ok { - if err := v.Validate(); err != nil { - return SearchResponseValidationError{ - field: "Meta", - reason: "embedded message failed validation", - cause: err, - } - } - } - - if len(errors) > 0 { - return SearchResponseMultiError(errors) - } - return nil -} - -// SearchResponseMultiError is an error wrapping multiple validation errors -// returned by SearchResponse.ValidateAll() if the designated constraints -// aren't met. -type SearchResponseMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m SearchResponseMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m SearchResponseMultiError) AllErrors() []error { return m } - -// SearchResponseValidationError is the validation error returned by -// SearchResponse.Validate if the designated constraints aren't met. -type SearchResponseValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e SearchResponseValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e SearchResponseValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e SearchResponseValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e SearchResponseValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e SearchResponseValidationError) ErrorName() string { return "SearchResponseValidationError" } - -// Error satisfies the builtin error interface -func (e SearchResponseValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sSearchResponse.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = SearchResponseValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = SearchResponseValidationError{} - -// Validate checks the field values on SearchHits with the rules defined in the -// proto definition for this message. If any rules are violated, the first -// error encountered is returned, or nil if there are no violations. -func (m *SearchHits) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on SearchHits with the rules defined in -// the proto definition for this message. If any rules are violated, the -// result is a list of violation errors wrapped in SearchHitsMultiError, or -// nil if none found. -func (m *SearchHits) ValidateAll() error { - return m.validate(true) -} - -func (m *SearchHits) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for NamespaceId - - // no validation rules for SchemaId - - // no validation rules for VersionId - - // no validation rules for Path - - if len(errors) > 0 { - return SearchHitsMultiError(errors) - } - return nil -} - -// SearchHitsMultiError is an error wrapping multiple validation errors -// returned by SearchHits.ValidateAll() if the designated constraints aren't met. -type SearchHitsMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m SearchHitsMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m SearchHitsMultiError) AllErrors() []error { return m } - -// SearchHitsValidationError is the validation error returned by -// SearchHits.Validate if the designated constraints aren't met. -type SearchHitsValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e SearchHitsValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e SearchHitsValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e SearchHitsValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e SearchHitsValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e SearchHitsValidationError) ErrorName() string { return "SearchHitsValidationError" } - -// Error satisfies the builtin error interface -func (e SearchHitsValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sSearchHits.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = SearchHitsValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = SearchHitsValidationError{} - -// Validate checks the field values on SearchMeta with the rules defined in the -// proto definition for this message. If any rules are violated, the first -// error encountered is returned, or nil if there are no violations. -func (m *SearchMeta) Validate() error { - return m.validate(false) -} - -// ValidateAll checks the field values on SearchMeta with the rules defined in -// the proto definition for this message. If any rules are violated, the -// result is a list of violation errors wrapped in SearchMetaMultiError, or -// nil if none found. -func (m *SearchMeta) ValidateAll() error { - return m.validate(true) -} - -func (m *SearchMeta) validate(all bool) error { - if m == nil { - return nil - } - - var errors []error - - // no validation rules for Total - - if len(errors) > 0 { - return SearchMetaMultiError(errors) - } - return nil -} - -// SearchMetaMultiError is an error wrapping multiple validation errors -// returned by SearchMeta.ValidateAll() if the designated constraints aren't met. -type SearchMetaMultiError []error - -// Error returns a concatenation of all the error messages it wraps. -func (m SearchMetaMultiError) Error() string { - var msgs []string - for _, err := range m { - msgs = append(msgs, err.Error()) - } - return strings.Join(msgs, "; ") -} - -// AllErrors returns a list of validation violation errors. -func (m SearchMetaMultiError) AllErrors() []error { return m } - -// SearchMetaValidationError is the validation error returned by -// SearchMeta.Validate if the designated constraints aren't met. -type SearchMetaValidationError struct { - field string - reason string - cause error - key bool -} - -// Field function returns field value. -func (e SearchMetaValidationError) Field() string { return e.field } - -// Reason function returns reason value. -func (e SearchMetaValidationError) Reason() string { return e.reason } - -// Cause function returns cause value. -func (e SearchMetaValidationError) Cause() error { return e.cause } - -// Key function returns key value. -func (e SearchMetaValidationError) Key() bool { return e.key } - -// ErrorName returns error name. -func (e SearchMetaValidationError) ErrorName() string { return "SearchMetaValidationError" } - -// Error satisfies the builtin error interface -func (e SearchMetaValidationError) Error() string { - cause := "" - if e.cause != nil { - cause = fmt.Sprintf(" | caused by: %v", e.cause) - } - - key := "" - if e.key { - key = "key for " - } - - return fmt.Sprintf( - "invalid %sSearchMeta.%s: %s%s", - key, - e.field, - e.reason, - cause) -} - -var _ error = SearchMetaValidationError{} - -var _ interface { - Field() string - Reason() string - Key() bool - Cause() error - ErrorName() string -} = SearchMetaValidationError{} diff --git a/proto/raystack/stencil/v1beta1/stencil.swagger.json b/proto/raystack/stencil/v1beta1/stencil.swagger.json deleted file mode 100644 index 70cad1d5..00000000 --- a/proto/raystack/stencil/v1beta1/stencil.swagger.json +++ /dev/null @@ -1,744 +0,0 @@ -{ - "swagger": "2.0", - "info": { - "title": "raystack/stencil/v1beta1/stencil.proto", - "version": "0.1.4" - }, - "tags": [ - { - "name": "StencilService" - } - ], - "schemes": ["http"], - "consumes": ["application/json"], - "produces": ["application/json"], - "paths": { - "/v1beta1/namespaces": { - "get": { - "summary": "List names of namespaces", - "operationId": "StencilService_ListNamespaces", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1ListNamespacesResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "tags": ["namespace"] - }, - "post": { - "summary": "Create namespace entry", - "operationId": "StencilService_CreateNamespace", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1CreateNamespaceResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "body", - "in": "body", - "required": true, - "schema": { - "$ref": "#/definitions/v1beta1CreateNamespaceRequest" - } - } - ], - "tags": ["namespace"] - } - }, - "/v1beta1/namespaces/{id}": { - "get": { - "summary": "Get namespace by id", - "operationId": "StencilService_GetNamespace", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1GetNamespaceResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "id", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": ["namespace"] - }, - "delete": { - "summary": "Delete namespace by id", - "description": "Ensure all schemas under this namespace is deleted, otherwise it will throw error", - "operationId": "StencilService_DeleteNamespace", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1DeleteNamespaceResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "id", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": ["namespace"] - }, - "put": { - "summary": "Update namespace entity by id", - "operationId": "StencilService_UpdateNamespace", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1UpdateNamespaceResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "id", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "body", - "in": "body", - "required": true, - "schema": { - "type": "object", - "properties": { - "format": { - "$ref": "#/definitions/SchemaFormat" - }, - "compatibility": { - "$ref": "#/definitions/SchemaCompatibility" - }, - "description": { - "type": "string" - } - } - } - } - ], - "tags": ["namespace"] - } - }, - "/v1beta1/namespaces/{id}/schemas": { - "get": { - "summary": "List schemas under the namespace", - "operationId": "StencilService_ListSchemas", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1ListSchemasResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "id", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": ["schema"] - } - }, - "/v1beta1/namespaces/{namespaceId}/schemas/{schemaId}": { - "delete": { - "summary": "Delete specified schema", - "operationId": "StencilService_DeleteSchema", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1DeleteSchemaResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "namespaceId", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "schemaId", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": ["schema"] - }, - "patch": { - "summary": "Update only schema metadata", - "operationId": "StencilService_UpdateSchemaMetadata", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1UpdateSchemaMetadataResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "namespaceId", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "schemaId", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "body", - "in": "body", - "required": true, - "schema": { - "type": "object", - "properties": { - "compatibility": { - "$ref": "#/definitions/SchemaCompatibility" - } - } - } - } - ], - "tags": ["schema"] - } - }, - "/v1beta1/namespaces/{namespaceId}/schemas/{schemaId}/meta": { - "get": { - "summary": "Create schema under the namespace. Returns version number, unique ID and location", - "operationId": "StencilService_GetSchemaMetadata", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1GetSchemaMetadataResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "namespaceId", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "schemaId", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": ["schema"] - } - }, - "/v1beta1/namespaces/{namespaceId}/schemas/{schemaId}/versions": { - "get": { - "summary": "List all version numbers for schema", - "operationId": "StencilService_ListVersions", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1ListVersionsResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "namespaceId", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "schemaId", - "in": "path", - "required": true, - "type": "string" - } - ], - "tags": ["schema", "version"] - } - }, - "/v1beta1/namespaces/{namespaceId}/schemas/{schemaId}/versions/{versionId}": { - "delete": { - "summary": "Delete specified version of the schema", - "operationId": "StencilService_DeleteVersion", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1DeleteVersionResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "namespaceId", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "schemaId", - "in": "path", - "required": true, - "type": "string" - }, - { - "name": "versionId", - "in": "path", - "required": true, - "type": "integer", - "format": "int32" - } - ], - "tags": ["schema", "version"] - } - }, - "/v1beta1/search": { - "get": { - "summary": "Global Search API", - "operationId": "StencilService_Search", - "responses": { - "200": { - "description": "A successful response.", - "schema": { - "$ref": "#/definitions/v1beta1SearchResponse" - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/rpcStatus" - } - } - }, - "parameters": [ - { - "name": "namespaceId", - "in": "query", - "required": false, - "type": "string" - }, - { - "name": "schemaId", - "in": "query", - "required": false, - "type": "string" - }, - { - "name": "query", - "in": "query", - "required": true, - "type": "string" - }, - { - "name": "history", - "in": "query", - "required": false, - "type": "boolean" - }, - { - "name": "versionId", - "in": "query", - "required": false, - "type": "integer", - "format": "int32" - } - ], - "tags": ["schema"] - } - } - }, - "definitions": { - "SchemaCompatibility": { - "type": "string", - "enum": [ - "COMPATIBILITY_UNSPECIFIED", - "COMPATIBILITY_BACKWARD", - "COMPATIBILITY_BACKWARD_TRANSITIVE", - "COMPATIBILITY_FORWARD", - "COMPATIBILITY_FORWARD_TRANSITIVE", - "COMPATIBILITY_FULL", - "COMPATIBILITY_FULL_TRANSITIVE" - ], - "default": "COMPATIBILITY_UNSPECIFIED" - }, - "SchemaFormat": { - "type": "string", - "enum": [ - "FORMAT_UNSPECIFIED", - "FORMAT_PROTOBUF", - "FORMAT_AVRO", - "FORMAT_JSON" - ], - "default": "FORMAT_UNSPECIFIED" - }, - "protobufAny": { - "type": "object", - "properties": { - "typeUrl": { - "type": "string" - }, - "value": { - "type": "string", - "format": "byte" - } - } - }, - "rpcStatus": { - "type": "object", - "properties": { - "code": { - "type": "integer", - "format": "int32" - }, - "message": { - "type": "string" - }, - "details": { - "type": "array", - "items": { - "$ref": "#/definitions/protobufAny" - } - } - } - }, - "v1beta1CheckCompatibilityResponse": { - "type": "object" - }, - "v1beta1CreateNamespaceRequest": { - "type": "object", - "properties": { - "id": { - "type": "string", - "required": ["id"] - }, - "format": { - "$ref": "#/definitions/SchemaFormat" - }, - "compatibility": { - "$ref": "#/definitions/SchemaCompatibility" - }, - "description": { - "type": "string" - } - }, - "required": ["id"] - }, - "v1beta1CreateNamespaceResponse": { - "type": "object", - "properties": { - "namespace": { - "$ref": "#/definitions/v1beta1Namespace" - } - } - }, - "v1beta1CreateSchemaResponse": { - "type": "object", - "properties": { - "version": { - "type": "integer", - "format": "int32" - }, - "id": { - "type": "string" - }, - "location": { - "type": "string" - } - } - }, - "v1beta1DeleteNamespaceResponse": { - "type": "object", - "properties": { - "message": { - "type": "string" - } - } - }, - "v1beta1DeleteSchemaResponse": { - "type": "object", - "properties": { - "message": { - "type": "string" - } - } - }, - "v1beta1DeleteVersionResponse": { - "type": "object", - "properties": { - "message": { - "type": "string" - } - } - }, - "v1beta1GetLatestSchemaResponse": { - "type": "object", - "properties": { - "data": { - "type": "string", - "format": "byte" - } - } - }, - "v1beta1GetNamespaceResponse": { - "type": "object", - "properties": { - "namespace": { - "$ref": "#/definitions/v1beta1Namespace" - } - } - }, - "v1beta1GetSchemaMetadataResponse": { - "type": "object", - "properties": { - "format": { - "$ref": "#/definitions/SchemaFormat" - }, - "compatibility": { - "$ref": "#/definitions/SchemaCompatibility" - }, - "authority": { - "type": "string" - } - } - }, - "v1beta1GetSchemaResponse": { - "type": "object", - "properties": { - "data": { - "type": "string", - "format": "byte" - } - } - }, - "v1beta1ListNamespacesResponse": { - "type": "object", - "properties": { - "namespaces": { - "type": "array", - "items": { - "type": "string" - } - } - } - }, - "v1beta1ListSchemasResponse": { - "type": "object", - "properties": { - "schemas": { - "type": "array", - "items": { - "type": "string" - } - } - } - }, - "v1beta1ListVersionsResponse": { - "type": "object", - "properties": { - "versions": { - "type": "array", - "items": { - "type": "integer", - "format": "int32" - } - } - } - }, - "v1beta1Namespace": { - "type": "object", - "properties": { - "id": { - "type": "string" - }, - "format": { - "$ref": "#/definitions/SchemaFormat" - }, - "Compatibility": { - "$ref": "#/definitions/SchemaCompatibility" - }, - "description": { - "type": "string" - }, - "createdAt": { - "type": "string", - "format": "date-time" - }, - "updatedAt": { - "type": "string", - "format": "date-time" - } - } - }, - "v1beta1SearchHits": { - "type": "object", - "properties": { - "namespaceId": { - "type": "string" - }, - "schemaId": { - "type": "string" - }, - "versionId": { - "type": "integer", - "format": "int32" - }, - "fields": { - "type": "array", - "items": { - "type": "string" - } - }, - "types": { - "type": "array", - "items": { - "type": "string" - } - }, - "path": { - "type": "string" - } - } - }, - "v1beta1SearchMeta": { - "type": "object", - "properties": { - "total": { - "type": "integer", - "format": "int64" - } - } - }, - "v1beta1SearchResponse": { - "type": "object", - "properties": { - "hits": { - "type": "array", - "items": { - "$ref": "#/definitions/v1beta1SearchHits" - } - }, - "meta": { - "$ref": "#/definitions/v1beta1SearchMeta" - } - } - }, - "v1beta1UpdateNamespaceResponse": { - "type": "object", - "properties": { - "namespace": { - "$ref": "#/definitions/v1beta1Namespace" - } - } - }, - "v1beta1UpdateSchemaMetadataResponse": { - "type": "object", - "properties": { - "format": { - "$ref": "#/definitions/SchemaFormat" - }, - "compatibility": { - "$ref": "#/definitions/SchemaCompatibility" - }, - "authority": { - "type": "string" - } - } - } - } -} diff --git a/proto/raystack/stencil/v1beta1/stencil.swagger.md b/proto/raystack/stencil/v1beta1/stencil.swagger.md deleted file mode 100644 index c73ba760..00000000 --- a/proto/raystack/stencil/v1beta1/stencil.swagger.md +++ /dev/null @@ -1,371 +0,0 @@ -# raystack/stencil/v1beta1/stencil.proto - -## Version: 0.1.4 - -### /v1beta1/namespaces - -#### GET - -##### Summary - -List names of namespaces - -##### Responses - -| Code | Description | Schema | -| ------- | ----------------------------- | --------------------------------------------------------------- | -| 200 | A successful response. | [v1beta1ListNamespacesResponse](#v1beta1listnamespacesresponse) | -| default | An unexpected error response. | [rpcStatus](#rpcstatus) | - -#### POST - -##### Summary - -Create namespace entry - -##### Parameters - -| Name | Located in | Description | Required | Schema | -| ---- | ---------- | ----------- | -------- | --------------------------------------------------------------- | -| body | body | | Yes | [v1beta1CreateNamespaceRequest](#v1beta1createnamespacerequest) | - -##### Responses - -| Code | Description | Schema | -| ------- | ----------------------------- | ----------------------------------------------------------------- | -| 200 | A successful response. | [v1beta1CreateNamespaceResponse](#v1beta1createnamespaceresponse) | -| default | An unexpected error response. | [rpcStatus](#rpcstatus) | - -### /v1beta1/namespaces/{id} - -#### GET - -##### Summary - -Get namespace by id - -##### Parameters - -| Name | Located in | Description | Required | Schema | -| ---- | ---------- | ----------- | -------- | ------ | -| id | path | | Yes | string | - -##### Responses - -| Code | Description | Schema | -| ------- | ----------------------------- | ----------------------------------------------------------- | -| 200 | A successful response. | [v1beta1GetNamespaceResponse](#v1beta1getnamespaceresponse) | -| default | An unexpected error response. | [rpcStatus](#rpcstatus) | - -#### DELETE - -##### Summary - -Delete namespace by id - -##### Description - -Ensure all schemas under this namespace is deleted, otherwise it will throw error - -##### Parameters - -| Name | Located in | Description | Required | Schema | -| ---- | ---------- | ----------- | -------- | ------ | -| id | path | | Yes | string | - -##### Responses - -| Code | Description | Schema | -| ------- | ----------------------------- | ----------------------------------------------------------------- | -| 200 | A successful response. | [v1beta1DeleteNamespaceResponse](#v1beta1deletenamespaceresponse) | -| default | An unexpected error response. | [rpcStatus](#rpcstatus) | - -#### PUT - -##### Summary - -Update namespace entity by id - -##### Parameters - -| Name | Located in | Description | Required | Schema | -| ---- | ---------- | ----------- | -------- | ------ | -| id | path | | Yes | string | -| body | body | | Yes | object | - -##### Responses - -| Code | Description | Schema | -| ------- | ----------------------------- | ----------------------------------------------------------------- | -| 200 | A successful response. | [v1beta1UpdateNamespaceResponse](#v1beta1updatenamespaceresponse) | -| default | An unexpected error response. | [rpcStatus](#rpcstatus) | - -### /v1beta1/namespaces/{id}/schemas - -#### GET - -##### Summary - -List schemas under the namespace - -##### Parameters - -| Name | Located in | Description | Required | Schema | -| ---- | ---------- | ----------- | -------- | ------ | -| id | path | | Yes | string | - -##### Responses - -| Code | Description | Schema | -| ------- | ----------------------------- | --------------------------------------------------------- | -| 200 | A successful response. | [v1beta1ListSchemasResponse](#v1beta1listschemasresponse) | -| default | An unexpected error response. | [rpcStatus](#rpcstatus) | - -### /v1beta1/namespaces/{namespaceId}/schemas/{schemaId} - -#### DELETE - -##### Summary - -Delete specified schema - -##### Parameters - -| Name | Located in | Description | Required | Schema | -| ----------- | ---------- | ----------- | -------- | ------ | -| namespaceId | path | | Yes | string | -| schemaId | path | | Yes | string | - -##### Responses - -| Code | Description | Schema | -| ------- | ----------------------------- | ----------------------------------------------------------- | -| 200 | A successful response. | [v1beta1DeleteSchemaResponse](#v1beta1deleteschemaresponse) | -| default | An unexpected error response. | [rpcStatus](#rpcstatus) | - -#### PATCH - -##### Summary - -Update only schema metadata - -##### Parameters - -| Name | Located in | Description | Required | Schema | -| ----------- | ---------- | ----------- | -------- | ------ | -| namespaceId | path | | Yes | string | -| schemaId | path | | Yes | string | -| body | body | | Yes | object | - -##### Responses - -| Code | Description | Schema | -| ------- | ----------------------------- | --------------------------------------------------------------------------- | -| 200 | A successful response. | [v1beta1UpdateSchemaMetadataResponse](#v1beta1updateschemametadataresponse) | -| default | An unexpected error response. | [rpcStatus](#rpcstatus) | - -### /v1beta1/namespaces/{namespaceId}/schemas/{schemaId}/meta - -#### GET - -##### Summary - -Create schema under the namespace. Returns version number, unique ID and location - -##### Parameters - -| Name | Located in | Description | Required | Schema | -| ----------- | ---------- | ----------- | -------- | ------ | -| namespaceId | path | | Yes | string | -| schemaId | path | | Yes | string | - -##### Responses - -| Code | Description | Schema | -| ------- | ----------------------------- | --------------------------------------------------------------------- | -| 200 | A successful response. | [v1beta1GetSchemaMetadataResponse](#v1beta1getschemametadataresponse) | -| default | An unexpected error response. | [rpcStatus](#rpcstatus) | - -### /v1beta1/namespaces/{namespaceId}/schemas/{schemaId}/versions - -#### GET - -##### Summary - -List all version numbers for schema - -##### Parameters - -| Name | Located in | Description | Required | Schema | -| ----------- | ---------- | ----------- | -------- | ------ | -| namespaceId | path | | Yes | string | -| schemaId | path | | Yes | string | - -##### Responses - -| Code | Description | Schema | -| ------- | ----------------------------- | ----------------------------------------------------------- | -| 200 | A successful response. | [v1beta1ListVersionsResponse](#v1beta1listversionsresponse) | -| default | An unexpected error response. | [rpcStatus](#rpcstatus) | - -### /v1beta1/namespaces/{namespaceId}/schemas/{schemaId}/versions/{versionId} - -#### DELETE - -##### Summary - -Delete specified version of the schema - -##### Parameters - -| Name | Located in | Description | Required | Schema | -| ----------- | ---------- | ----------- | -------- | ------- | -| namespaceId | path | | Yes | string | -| schemaId | path | | Yes | string | -| versionId | path | | Yes | integer | - -##### Responses - -| Code | Description | Schema | -| ------- | ----------------------------- | ------------------------------------------------------------- | -| 200 | A successful response. | [v1beta1DeleteVersionResponse](#v1beta1deleteversionresponse) | -| default | An unexpected error response. | [rpcStatus](#rpcstatus) | - -### Models - -#### SchemaCompatibility - -| Name | Type | Description | Required | -| ------------------- | ------ | ----------- | -------- | -| SchemaCompatibility | string | | | - -#### SchemaFormat - -| Name | Type | Description | Required | -| ------------ | ------ | ----------- | -------- | -| SchemaFormat | string | | | - -#### protobufAny - -| Name | Type | Description | Required | -| ------- | ------ | ----------- | -------- | -| typeUrl | string | | No | -| value | byte | | No | - -#### rpcStatus - -| Name | Type | Description | Required | -| ------- | ------------------------------- | ----------- | -------- | -| code | integer | | No | -| message | string | | No | -| details | [ [protobufAny](#protobufany) ] | | No | - -#### v1beta1CreateNamespaceRequest - -| Name | Type | Description | Required | -| ------------- | ------------------------------------------- | ----------- | -------- | -| id | string | | Yes | -| format | [SchemaFormat](#schemaformat) | | No | -| compatibility | [SchemaCompatibility](#schemacompatibility) | | No | -| description | string | | No | - -#### v1beta1CreateNamespaceResponse - -| Name | Type | Description | Required | -| --------- | ------------------------------------- | ----------- | -------- | -| namespace | [v1beta1Namespace](#v1beta1namespace) | | No | - -#### v1beta1CreateSchemaResponse - -| Name | Type | Description | Required | -| -------- | ------- | ----------- | -------- | -| version | integer | | No | -| id | string | | No | -| location | string | | No | - -#### v1beta1DeleteNamespaceResponse - -| Name | Type | Description | Required | -| ------- | ------ | ----------- | -------- | -| message | string | | No | - -#### v1beta1DeleteSchemaResponse - -| Name | Type | Description | Required | -| ------- | ------ | ----------- | -------- | -| message | string | | No | - -#### v1beta1DeleteVersionResponse - -| Name | Type | Description | Required | -| ------- | ------ | ----------- | -------- | -| message | string | | No | - -#### v1beta1GetLatestSchemaResponse - -| Name | Type | Description | Required | -| ---- | ---- | ----------- | -------- | -| data | byte | | No | - -#### v1beta1GetNamespaceResponse - -| Name | Type | Description | Required | -| --------- | ------------------------------------- | ----------- | -------- | -| namespace | [v1beta1Namespace](#v1beta1namespace) | | No | - -#### v1beta1GetSchemaMetadataResponse - -| Name | Type | Description | Required | -| ------------- | ------------------------------------------- | ----------- | -------- | -| format | [SchemaFormat](#schemaformat) | | No | -| compatibility | [SchemaCompatibility](#schemacompatibility) | | No | -| authority | string | | No | - -#### v1beta1GetSchemaResponse - -| Name | Type | Description | Required | -| ---- | ---- | ----------- | -------- | -| data | byte | | No | - -#### v1beta1ListNamespacesResponse - -| Name | Type | Description | Required | -| ---------- | ---------- | ----------- | -------- | -| namespaces | [ string ] | | No | - -#### v1beta1ListSchemasResponse - -| Name | Type | Description | Required | -| ------- | ---------- | ----------- | -------- | -| schemas | [ string ] | | No | - -#### v1beta1ListVersionsResponse - -| Name | Type | Description | Required | -| -------- | ----------- | ----------- | -------- | -| versions | [ integer ] | | No | - -#### v1beta1Namespace - -| Name | Type | Description | Required | -| ------------- | ------------------------------------------- | ----------- | -------- | -| id | string | | No | -| format | [SchemaFormat](#schemaformat) | | No | -| Compatibility | [SchemaCompatibility](#schemacompatibility) | | No | -| description | string | | No | -| createdAt | dateTime | | No | -| updatedAt | dateTime | | No | - -#### v1beta1UpdateNamespaceResponse - -| Name | Type | Description | Required | -| --------- | ------------------------------------- | ----------- | -------- | -| namespace | [v1beta1Namespace](#v1beta1namespace) | | No | - -#### v1beta1UpdateSchemaMetadataResponse - -| Name | Type | Description | Required | -| ------------- | ------------------------------------------- | ----------- | -------- | -| format | [SchemaFormat](#schemaformat) | | No | -| compatibility | [SchemaCompatibility](#schemacompatibility) | | No | -| authority | string | | No | diff --git a/proto/raystack/stencil/v1beta1/stencil_grpc.pb.go b/proto/raystack/stencil/v1beta1/stencil_grpc.pb.go deleted file mode 100644 index 6d6c06ba..00000000 --- a/proto/raystack/stencil/v1beta1/stencil_grpc.pb.go +++ /dev/null @@ -1,645 +0,0 @@ -// Code generated by protoc-gen-go-grpc. DO NOT EDIT. -// versions: -// - protoc-gen-go-grpc v1.2.0 -// - protoc (unknown) -// source: raystack/stencil/v1beta1/stencil.proto - -package stencilv1beta1 - -import ( - context "context" - grpc "google.golang.org/grpc" - codes "google.golang.org/grpc/codes" - status "google.golang.org/grpc/status" -) - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the grpc package it is being compiled against. -// Requires gRPC-Go v1.32.0 or later. -const _ = grpc.SupportPackageIsVersion7 - -// StencilServiceClient is the client API for StencilService service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. -type StencilServiceClient interface { - ListNamespaces(ctx context.Context, in *ListNamespacesRequest, opts ...grpc.CallOption) (*ListNamespacesResponse, error) - GetNamespace(ctx context.Context, in *GetNamespaceRequest, opts ...grpc.CallOption) (*GetNamespaceResponse, error) - CreateNamespace(ctx context.Context, in *CreateNamespaceRequest, opts ...grpc.CallOption) (*CreateNamespaceResponse, error) - UpdateNamespace(ctx context.Context, in *UpdateNamespaceRequest, opts ...grpc.CallOption) (*UpdateNamespaceResponse, error) - DeleteNamespace(ctx context.Context, in *DeleteNamespaceRequest, opts ...grpc.CallOption) (*DeleteNamespaceResponse, error) - ListSchemas(ctx context.Context, in *ListSchemasRequest, opts ...grpc.CallOption) (*ListSchemasResponse, error) - CreateSchema(ctx context.Context, in *CreateSchemaRequest, opts ...grpc.CallOption) (*CreateSchemaResponse, error) - CheckCompatibility(ctx context.Context, in *CheckCompatibilityRequest, opts ...grpc.CallOption) (*CheckCompatibilityResponse, error) - GetSchemaMetadata(ctx context.Context, in *GetSchemaMetadataRequest, opts ...grpc.CallOption) (*GetSchemaMetadataResponse, error) - UpdateSchemaMetadata(ctx context.Context, in *UpdateSchemaMetadataRequest, opts ...grpc.CallOption) (*UpdateSchemaMetadataResponse, error) - GetLatestSchema(ctx context.Context, in *GetLatestSchemaRequest, opts ...grpc.CallOption) (*GetLatestSchemaResponse, error) - DeleteSchema(ctx context.Context, in *DeleteSchemaRequest, opts ...grpc.CallOption) (*DeleteSchemaResponse, error) - GetSchema(ctx context.Context, in *GetSchemaRequest, opts ...grpc.CallOption) (*GetSchemaResponse, error) - ListVersions(ctx context.Context, in *ListVersionsRequest, opts ...grpc.CallOption) (*ListVersionsResponse, error) - DeleteVersion(ctx context.Context, in *DeleteVersionRequest, opts ...grpc.CallOption) (*DeleteVersionResponse, error) - Search(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*SearchResponse, error) -} - -type stencilServiceClient struct { - cc grpc.ClientConnInterface -} - -func NewStencilServiceClient(cc grpc.ClientConnInterface) StencilServiceClient { - return &stencilServiceClient{cc} -} - -func (c *stencilServiceClient) ListNamespaces(ctx context.Context, in *ListNamespacesRequest, opts ...grpc.CallOption) (*ListNamespacesResponse, error) { - out := new(ListNamespacesResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/ListNamespaces", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *stencilServiceClient) GetNamespace(ctx context.Context, in *GetNamespaceRequest, opts ...grpc.CallOption) (*GetNamespaceResponse, error) { - out := new(GetNamespaceResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/GetNamespace", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *stencilServiceClient) CreateNamespace(ctx context.Context, in *CreateNamespaceRequest, opts ...grpc.CallOption) (*CreateNamespaceResponse, error) { - out := new(CreateNamespaceResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/CreateNamespace", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *stencilServiceClient) UpdateNamespace(ctx context.Context, in *UpdateNamespaceRequest, opts ...grpc.CallOption) (*UpdateNamespaceResponse, error) { - out := new(UpdateNamespaceResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/UpdateNamespace", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *stencilServiceClient) DeleteNamespace(ctx context.Context, in *DeleteNamespaceRequest, opts ...grpc.CallOption) (*DeleteNamespaceResponse, error) { - out := new(DeleteNamespaceResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/DeleteNamespace", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *stencilServiceClient) ListSchemas(ctx context.Context, in *ListSchemasRequest, opts ...grpc.CallOption) (*ListSchemasResponse, error) { - out := new(ListSchemasResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/ListSchemas", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *stencilServiceClient) CreateSchema(ctx context.Context, in *CreateSchemaRequest, opts ...grpc.CallOption) (*CreateSchemaResponse, error) { - out := new(CreateSchemaResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/CreateSchema", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *stencilServiceClient) CheckCompatibility(ctx context.Context, in *CheckCompatibilityRequest, opts ...grpc.CallOption) (*CheckCompatibilityResponse, error) { - out := new(CheckCompatibilityResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/CheckCompatibility", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *stencilServiceClient) GetSchemaMetadata(ctx context.Context, in *GetSchemaMetadataRequest, opts ...grpc.CallOption) (*GetSchemaMetadataResponse, error) { - out := new(GetSchemaMetadataResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/GetSchemaMetadata", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *stencilServiceClient) UpdateSchemaMetadata(ctx context.Context, in *UpdateSchemaMetadataRequest, opts ...grpc.CallOption) (*UpdateSchemaMetadataResponse, error) { - out := new(UpdateSchemaMetadataResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/UpdateSchemaMetadata", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *stencilServiceClient) GetLatestSchema(ctx context.Context, in *GetLatestSchemaRequest, opts ...grpc.CallOption) (*GetLatestSchemaResponse, error) { - out := new(GetLatestSchemaResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/GetLatestSchema", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *stencilServiceClient) DeleteSchema(ctx context.Context, in *DeleteSchemaRequest, opts ...grpc.CallOption) (*DeleteSchemaResponse, error) { - out := new(DeleteSchemaResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/DeleteSchema", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *stencilServiceClient) GetSchema(ctx context.Context, in *GetSchemaRequest, opts ...grpc.CallOption) (*GetSchemaResponse, error) { - out := new(GetSchemaResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/GetSchema", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *stencilServiceClient) ListVersions(ctx context.Context, in *ListVersionsRequest, opts ...grpc.CallOption) (*ListVersionsResponse, error) { - out := new(ListVersionsResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/ListVersions", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *stencilServiceClient) DeleteVersion(ctx context.Context, in *DeleteVersionRequest, opts ...grpc.CallOption) (*DeleteVersionResponse, error) { - out := new(DeleteVersionResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/DeleteVersion", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *stencilServiceClient) Search(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*SearchResponse, error) { - out := new(SearchResponse) - err := c.cc.Invoke(ctx, "/raystack.stencil.v1beta1.StencilService/Search", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -// StencilServiceServer is the server API for StencilService service. -// All implementations must embed UnimplementedStencilServiceServer -// for forward compatibility -type StencilServiceServer interface { - ListNamespaces(context.Context, *ListNamespacesRequest) (*ListNamespacesResponse, error) - GetNamespace(context.Context, *GetNamespaceRequest) (*GetNamespaceResponse, error) - CreateNamespace(context.Context, *CreateNamespaceRequest) (*CreateNamespaceResponse, error) - UpdateNamespace(context.Context, *UpdateNamespaceRequest) (*UpdateNamespaceResponse, error) - DeleteNamespace(context.Context, *DeleteNamespaceRequest) (*DeleteNamespaceResponse, error) - ListSchemas(context.Context, *ListSchemasRequest) (*ListSchemasResponse, error) - CreateSchema(context.Context, *CreateSchemaRequest) (*CreateSchemaResponse, error) - CheckCompatibility(context.Context, *CheckCompatibilityRequest) (*CheckCompatibilityResponse, error) - GetSchemaMetadata(context.Context, *GetSchemaMetadataRequest) (*GetSchemaMetadataResponse, error) - UpdateSchemaMetadata(context.Context, *UpdateSchemaMetadataRequest) (*UpdateSchemaMetadataResponse, error) - GetLatestSchema(context.Context, *GetLatestSchemaRequest) (*GetLatestSchemaResponse, error) - DeleteSchema(context.Context, *DeleteSchemaRequest) (*DeleteSchemaResponse, error) - GetSchema(context.Context, *GetSchemaRequest) (*GetSchemaResponse, error) - ListVersions(context.Context, *ListVersionsRequest) (*ListVersionsResponse, error) - DeleteVersion(context.Context, *DeleteVersionRequest) (*DeleteVersionResponse, error) - Search(context.Context, *SearchRequest) (*SearchResponse, error) - mustEmbedUnimplementedStencilServiceServer() -} - -// UnimplementedStencilServiceServer must be embedded to have forward compatible implementations. -type UnimplementedStencilServiceServer struct { -} - -func (UnimplementedStencilServiceServer) ListNamespaces(context.Context, *ListNamespacesRequest) (*ListNamespacesResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ListNamespaces not implemented") -} -func (UnimplementedStencilServiceServer) GetNamespace(context.Context, *GetNamespaceRequest) (*GetNamespaceResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetNamespace not implemented") -} -func (UnimplementedStencilServiceServer) CreateNamespace(context.Context, *CreateNamespaceRequest) (*CreateNamespaceResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method CreateNamespace not implemented") -} -func (UnimplementedStencilServiceServer) UpdateNamespace(context.Context, *UpdateNamespaceRequest) (*UpdateNamespaceResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method UpdateNamespace not implemented") -} -func (UnimplementedStencilServiceServer) DeleteNamespace(context.Context, *DeleteNamespaceRequest) (*DeleteNamespaceResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method DeleteNamespace not implemented") -} -func (UnimplementedStencilServiceServer) ListSchemas(context.Context, *ListSchemasRequest) (*ListSchemasResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ListSchemas not implemented") -} -func (UnimplementedStencilServiceServer) CreateSchema(context.Context, *CreateSchemaRequest) (*CreateSchemaResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method CreateSchema not implemented") -} -func (UnimplementedStencilServiceServer) CheckCompatibility(context.Context, *CheckCompatibilityRequest) (*CheckCompatibilityResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method CheckCompatibility not implemented") -} -func (UnimplementedStencilServiceServer) GetSchemaMetadata(context.Context, *GetSchemaMetadataRequest) (*GetSchemaMetadataResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetSchemaMetadata not implemented") -} -func (UnimplementedStencilServiceServer) UpdateSchemaMetadata(context.Context, *UpdateSchemaMetadataRequest) (*UpdateSchemaMetadataResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method UpdateSchemaMetadata not implemented") -} -func (UnimplementedStencilServiceServer) GetLatestSchema(context.Context, *GetLatestSchemaRequest) (*GetLatestSchemaResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetLatestSchema not implemented") -} -func (UnimplementedStencilServiceServer) DeleteSchema(context.Context, *DeleteSchemaRequest) (*DeleteSchemaResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method DeleteSchema not implemented") -} -func (UnimplementedStencilServiceServer) GetSchema(context.Context, *GetSchemaRequest) (*GetSchemaResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetSchema not implemented") -} -func (UnimplementedStencilServiceServer) ListVersions(context.Context, *ListVersionsRequest) (*ListVersionsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ListVersions not implemented") -} -func (UnimplementedStencilServiceServer) DeleteVersion(context.Context, *DeleteVersionRequest) (*DeleteVersionResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method DeleteVersion not implemented") -} -func (UnimplementedStencilServiceServer) Search(context.Context, *SearchRequest) (*SearchResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Search not implemented") -} -func (UnimplementedStencilServiceServer) mustEmbedUnimplementedStencilServiceServer() {} - -// UnsafeStencilServiceServer may be embedded to opt out of forward compatibility for this service. -// Use of this interface is not recommended, as added methods to StencilServiceServer will -// result in compilation errors. -type UnsafeStencilServiceServer interface { - mustEmbedUnimplementedStencilServiceServer() -} - -func RegisterStencilServiceServer(s grpc.ServiceRegistrar, srv StencilServiceServer) { - s.RegisterService(&StencilService_ServiceDesc, srv) -} - -func _StencilService_ListNamespaces_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ListNamespacesRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).ListNamespaces(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/ListNamespaces", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).ListNamespaces(ctx, req.(*ListNamespacesRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _StencilService_GetNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetNamespaceRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).GetNamespace(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/GetNamespace", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).GetNamespace(ctx, req.(*GetNamespaceRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _StencilService_CreateNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(CreateNamespaceRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).CreateNamespace(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/CreateNamespace", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).CreateNamespace(ctx, req.(*CreateNamespaceRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _StencilService_UpdateNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(UpdateNamespaceRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).UpdateNamespace(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/UpdateNamespace", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).UpdateNamespace(ctx, req.(*UpdateNamespaceRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _StencilService_DeleteNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(DeleteNamespaceRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).DeleteNamespace(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/DeleteNamespace", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).DeleteNamespace(ctx, req.(*DeleteNamespaceRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _StencilService_ListSchemas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ListSchemasRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).ListSchemas(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/ListSchemas", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).ListSchemas(ctx, req.(*ListSchemasRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _StencilService_CreateSchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(CreateSchemaRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).CreateSchema(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/CreateSchema", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).CreateSchema(ctx, req.(*CreateSchemaRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _StencilService_CheckCompatibility_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(CheckCompatibilityRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).CheckCompatibility(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/CheckCompatibility", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).CheckCompatibility(ctx, req.(*CheckCompatibilityRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _StencilService_GetSchemaMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetSchemaMetadataRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).GetSchemaMetadata(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/GetSchemaMetadata", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).GetSchemaMetadata(ctx, req.(*GetSchemaMetadataRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _StencilService_UpdateSchemaMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(UpdateSchemaMetadataRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).UpdateSchemaMetadata(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/UpdateSchemaMetadata", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).UpdateSchemaMetadata(ctx, req.(*UpdateSchemaMetadataRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _StencilService_GetLatestSchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetLatestSchemaRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).GetLatestSchema(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/GetLatestSchema", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).GetLatestSchema(ctx, req.(*GetLatestSchemaRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _StencilService_DeleteSchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(DeleteSchemaRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).DeleteSchema(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/DeleteSchema", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).DeleteSchema(ctx, req.(*DeleteSchemaRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _StencilService_GetSchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetSchemaRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).GetSchema(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/GetSchema", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).GetSchema(ctx, req.(*GetSchemaRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _StencilService_ListVersions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ListVersionsRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).ListVersions(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/ListVersions", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).ListVersions(ctx, req.(*ListVersionsRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _StencilService_DeleteVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(DeleteVersionRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).DeleteVersion(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/DeleteVersion", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).DeleteVersion(ctx, req.(*DeleteVersionRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _StencilService_Search_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(SearchRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(StencilServiceServer).Search(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/raystack.stencil.v1beta1.StencilService/Search", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(StencilServiceServer).Search(ctx, req.(*SearchRequest)) - } - return interceptor(ctx, in, info, handler) -} - -// StencilService_ServiceDesc is the grpc.ServiceDesc for StencilService service. -// It's only intended for direct use with grpc.RegisterService, -// and not to be introspected or modified (even as a copy) -var StencilService_ServiceDesc = grpc.ServiceDesc{ - ServiceName: "raystack.stencil.v1beta1.StencilService", - HandlerType: (*StencilServiceServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "ListNamespaces", - Handler: _StencilService_ListNamespaces_Handler, - }, - { - MethodName: "GetNamespace", - Handler: _StencilService_GetNamespace_Handler, - }, - { - MethodName: "CreateNamespace", - Handler: _StencilService_CreateNamespace_Handler, - }, - { - MethodName: "UpdateNamespace", - Handler: _StencilService_UpdateNamespace_Handler, - }, - { - MethodName: "DeleteNamespace", - Handler: _StencilService_DeleteNamespace_Handler, - }, - { - MethodName: "ListSchemas", - Handler: _StencilService_ListSchemas_Handler, - }, - { - MethodName: "CreateSchema", - Handler: _StencilService_CreateSchema_Handler, - }, - { - MethodName: "CheckCompatibility", - Handler: _StencilService_CheckCompatibility_Handler, - }, - { - MethodName: "GetSchemaMetadata", - Handler: _StencilService_GetSchemaMetadata_Handler, - }, - { - MethodName: "UpdateSchemaMetadata", - Handler: _StencilService_UpdateSchemaMetadata_Handler, - }, - { - MethodName: "GetLatestSchema", - Handler: _StencilService_GetLatestSchema_Handler, - }, - { - MethodName: "DeleteSchema", - Handler: _StencilService_DeleteSchema_Handler, - }, - { - MethodName: "GetSchema", - Handler: _StencilService_GetSchema_Handler, - }, - { - MethodName: "ListVersions", - Handler: _StencilService_ListVersions_Handler, - }, - { - MethodName: "DeleteVersion", - Handler: _StencilService_DeleteVersion_Handler, - }, - { - MethodName: "Search", - Handler: _StencilService_Search_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "raystack/stencil/v1beta1/stencil.proto", -}