diff --git a/Makefile b/Makefile index 5864f161..29abb755 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,7 @@ .PHONY: build release test fmt fmt-check clippy check clean docker-build docker-run \ release-patch release-minor release-major github-release \ publish publish-dry-run bench bench-core bench-protocol bench-compare bench-quick \ - helm-lint helm-template proto-gen + helm-lint helm-template proto-gen proto-go # extract the workspace version from the root Cargo.toml VERSION = $(shell sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml) @@ -135,6 +135,9 @@ publish: proto-gen: cargo build -p ember-server --features grpc +proto-go: + cd clients/ember-go && $(MAKE) proto-gen + # --- helm --- helm-lint: diff --git a/clients/ember-go/Makefile b/clients/ember-go/Makefile new file mode 100644 index 00000000..d1bf9b3e --- /dev/null +++ b/clients/ember-go/Makefile @@ -0,0 +1,10 @@ +.PHONY: proto-gen test + +proto-gen: + protoc --go_out=. --go_opt=module=github.com/kacy/ember-go \ + --go-grpc_out=. --go-grpc_opt=module=github.com/kacy/ember-go \ + --proto_path=../../proto \ + ember/v1/ember.proto + +test: + go test -v ./... diff --git a/clients/ember-go/ember.go b/clients/ember-go/ember.go new file mode 100644 index 00000000..7c5ec4dd --- /dev/null +++ b/clients/ember-go/ember.go @@ -0,0 +1,457 @@ +// Package ember provides a Go client for the ember cache server over gRPC. +// +// The client wraps the generated gRPC stubs with an idiomatic Go API, +// handling connection management and type conversions. +package ember + +import ( + "context" + "fmt" + + pb "github.com/kacy/ember-go/proto/ember/v1" + "google.golang.org/grpc" + "google.golang.org/grpc/credentials/insecure" + "google.golang.org/grpc/metadata" +) + +// Client is a gRPC client for ember. +type Client struct { + conn *grpc.ClientConn + rpc pb.EmberCacheClient + opts clientOptions +} + +type clientOptions struct { + password string +} + +// Option configures the client. +type Option func(*clientOptions) + +// WithPassword sets the authentication password. +func WithPassword(password string) Option { + return func(o *clientOptions) { + o.password = password + } +} + +// Dial connects to an ember server at the given address. +func Dial(addr string, opts ...Option) (*Client, error) { + var o clientOptions + for _, opt := range opts { + opt(&o) + } + + conn, err := grpc.NewClient(addr, + grpc.WithTransportCredentials(insecure.NewCredentials()), + ) + if err != nil { + return nil, fmt.Errorf("ember: dial %s: %w", addr, err) + } + + return &Client{ + conn: conn, + rpc: pb.NewEmberCacheClient(conn), + opts: o, + }, nil +} + +// Close releases the underlying gRPC connection. +func (c *Client) Close() error { + return c.conn.Close() +} + +// ctx adds auth metadata if a password is configured. +func (c *Client) ctx(parent context.Context) context.Context { + if c.opts.password == "" { + return parent + } + return metadata.AppendToOutgoingContext(parent, "authorization", c.opts.password) +} + +// --- strings --- + +// Get returns the value for a key, or nil if the key does not exist. +func (c *Client) Get(ctx context.Context, key string) ([]byte, error) { + resp, err := c.rpc.Get(c.ctx(ctx), &pb.GetRequest{Key: key}) + if err != nil { + return nil, err + } + return resp.Value, nil +} + +// SetOption configures a SET command. +type SetOption func(*pb.SetRequest) + +// WithEX sets the expiration in seconds. +func WithEX(seconds uint64) SetOption { + return func(r *pb.SetRequest) { + r.ExpireSeconds = seconds + } +} + +// WithPX sets the expiration in milliseconds. +func WithPX(millis uint64) SetOption { + return func(r *pb.SetRequest) { + r.ExpireMillis = millis + } +} + +// WithNX only sets the key if it does not already exist. +func WithNX() SetOption { + return func(r *pb.SetRequest) { + r.Nx = true + } +} + +// WithXX only sets the key if it already exists. +func WithXX() SetOption { + return func(r *pb.SetRequest) { + r.Xx = true + } +} + +// Set stores a key-value pair. Returns true if the key was set. +func (c *Client) Set(ctx context.Context, key string, value []byte, opts ...SetOption) (bool, error) { + req := &pb.SetRequest{Key: key, Value: value} + for _, opt := range opts { + opt(req) + } + resp, err := c.rpc.Set(c.ctx(ctx), req) + if err != nil { + return false, err + } + return resp.Ok, nil +} + +// Del removes the specified keys and returns the number deleted. +func (c *Client) Del(ctx context.Context, keys ...string) (int64, error) { + resp, err := c.rpc.Del(c.ctx(ctx), &pb.DelRequest{Keys: keys}) + if err != nil { + return 0, err + } + return resp.Deleted, nil +} + +// Exists returns the number of keys that exist. +func (c *Client) Exists(ctx context.Context, keys ...string) (int64, error) { + resp, err := c.rpc.Exists(c.ctx(ctx), &pb.ExistsRequest{Keys: keys}) + if err != nil { + return 0, err + } + return resp.Value, nil +} + +// Incr increments a key by 1 and returns the new value. +func (c *Client) Incr(ctx context.Context, key string) (int64, error) { + resp, err := c.rpc.Incr(c.ctx(ctx), &pb.IncrRequest{Key: key}) + if err != nil { + return 0, err + } + return resp.Value, nil +} + +// IncrBy increments a key by delta and returns the new value. +func (c *Client) IncrBy(ctx context.Context, key string, delta int64) (int64, error) { + resp, err := c.rpc.IncrBy(c.ctx(ctx), &pb.IncrByRequest{Key: key, Delta: delta}) + if err != nil { + return 0, err + } + return resp.Value, nil +} + +// Expire sets a timeout on a key in seconds. Returns true if the timeout was set. +func (c *Client) Expire(ctx context.Context, key string, seconds uint64) (bool, error) { + resp, err := c.rpc.Expire(c.ctx(ctx), &pb.ExpireRequest{Key: key, Seconds: seconds}) + if err != nil { + return false, err + } + return resp.Value, nil +} + +// TTL returns the remaining time to live in seconds. Returns -1 if the key +// has no expiry, -2 if the key does not exist. +func (c *Client) TTL(ctx context.Context, key string) (int64, error) { + resp, err := c.rpc.Ttl(c.ctx(ctx), &pb.TtlRequest{Key: key}) + if err != nil { + return 0, err + } + return resp.Value, nil +} + +// --- lists --- + +// LPush prepends values to a list and returns the new length. +func (c *Client) LPush(ctx context.Context, key string, values ...[]byte) (int64, error) { + resp, err := c.rpc.LPush(c.ctx(ctx), &pb.LPushRequest{Key: key, Values: values}) + if err != nil { + return 0, err + } + return resp.Value, nil +} + +// RPush appends values to a list and returns the new length. +func (c *Client) RPush(ctx context.Context, key string, values ...[]byte) (int64, error) { + resp, err := c.rpc.RPush(c.ctx(ctx), &pb.RPushRequest{Key: key, Values: values}) + if err != nil { + return 0, err + } + return resp.Value, nil +} + +// LPop removes and returns the first element of a list, or nil if empty. +func (c *Client) LPop(ctx context.Context, key string) ([]byte, error) { + resp, err := c.rpc.LPop(c.ctx(ctx), &pb.LPopRequest{Key: key}) + if err != nil { + return nil, err + } + return resp.Value, nil +} + +// RPop removes and returns the last element of a list, or nil if empty. +func (c *Client) RPop(ctx context.Context, key string) ([]byte, error) { + resp, err := c.rpc.RPop(c.ctx(ctx), &pb.RPopRequest{Key: key}) + if err != nil { + return nil, err + } + return resp.Value, nil +} + +// LRange returns elements from a list in the given range. +func (c *Client) LRange(ctx context.Context, key string, start, stop int64) ([][]byte, error) { + resp, err := c.rpc.LRange(c.ctx(ctx), &pb.LRangeRequest{Key: key, Start: start, Stop: stop}) + if err != nil { + return nil, err + } + return resp.Values, nil +} + +// LLen returns the length of a list. +func (c *Client) LLen(ctx context.Context, key string) (int64, error) { + resp, err := c.rpc.LLen(c.ctx(ctx), &pb.LLenRequest{Key: key}) + if err != nil { + return 0, err + } + return resp.Value, nil +} + +// --- hashes --- + +// HSet sets fields in a hash. Returns the number of new fields added. +func (c *Client) HSet(ctx context.Context, key string, fields map[string][]byte) (int64, error) { + fvs := make([]*pb.FieldValue, 0, len(fields)) + for f, v := range fields { + fvs = append(fvs, &pb.FieldValue{Field: f, Value: v}) + } + resp, err := c.rpc.HSet(c.ctx(ctx), &pb.HSetRequest{Key: key, Fields: fvs}) + if err != nil { + return 0, err + } + return resp.Value, nil +} + +// HGet returns the value for a field in a hash, or nil if it doesn't exist. +func (c *Client) HGet(ctx context.Context, key, field string) ([]byte, error) { + resp, err := c.rpc.HGet(c.ctx(ctx), &pb.HGetRequest{Key: key, Field: field}) + if err != nil { + return nil, err + } + return resp.Value, nil +} + +// HGetAll returns all fields and values in a hash. +func (c *Client) HGetAll(ctx context.Context, key string) (map[string][]byte, error) { + resp, err := c.rpc.HGetAll(c.ctx(ctx), &pb.HGetAllRequest{Key: key}) + if err != nil { + return nil, err + } + result := make(map[string][]byte, len(resp.Fields)) + for _, fv := range resp.Fields { + result[fv.Field] = fv.Value + } + return result, nil +} + +// HDel removes fields from a hash. Returns the number of fields removed. +func (c *Client) HDel(ctx context.Context, key string, fields ...string) (int64, error) { + resp, err := c.rpc.HDel(c.ctx(ctx), &pb.HDelRequest{Key: key, Fields: fields}) + if err != nil { + return 0, err + } + return resp.Value, nil +} + +// --- sets --- + +// SAdd adds members to a set. Returns the number of new members added. +func (c *Client) SAdd(ctx context.Context, key string, members ...string) (int64, error) { + resp, err := c.rpc.SAdd(c.ctx(ctx), &pb.SAddRequest{Key: key, Members: members}) + if err != nil { + return 0, err + } + return resp.Value, nil +} + +// SMembers returns all members of a set. +func (c *Client) SMembers(ctx context.Context, key string) ([]string, error) { + resp, err := c.rpc.SMembers(c.ctx(ctx), &pb.SMembersRequest{Key: key}) + if err != nil { + return nil, err + } + return resp.Keys, nil +} + +// SCard returns the number of members in a set. +func (c *Client) SCard(ctx context.Context, key string) (int64, error) { + resp, err := c.rpc.SCard(c.ctx(ctx), &pb.SCardRequest{Key: key}) + if err != nil { + return 0, err + } + return resp.Value, nil +} + +// --- sorted sets --- + +// ScoreMember is a member with its score for sorted set operations. +type ScoreMember struct { + Member string + Score float64 +} + +// ZAdd adds members to a sorted set. Returns the number added. +func (c *Client) ZAdd(ctx context.Context, key string, members ...ScoreMember) (int64, error) { + pbMembers := make([]*pb.ScoreMember, len(members)) + for i, m := range members { + pbMembers[i] = &pb.ScoreMember{Score: m.Score, Member: m.Member} + } + resp, err := c.rpc.ZAdd(c.ctx(ctx), &pb.ZAddRequest{Key: key, Members: pbMembers}) + if err != nil { + return 0, err + } + return resp.Value, nil +} + +// ZRange returns members in a sorted set within the given rank range. +func (c *Client) ZRange(ctx context.Context, key string, start, stop int64, withScores bool) ([]ScoreMember, error) { + resp, err := c.rpc.ZRange(c.ctx(ctx), &pb.ZRangeRequest{ + Key: key, + Start: start, + Stop: stop, + WithScores: withScores, + }) + if err != nil { + return nil, err + } + result := make([]ScoreMember, len(resp.Members)) + for i, m := range resp.Members { + result[i] = ScoreMember{Member: m.Member, Score: m.Score} + } + return result, nil +} + +// --- vectors --- + +// VSimResult holds a vector similarity search result. +type VSimResult struct { + Element string + Distance float32 +} + +// VAddOption configures a VADD command. +type VAddOption func(*pb.VAddRequest) + +// WithMetric sets the distance metric for the vector set. +func WithMetric(metric pb.VectorMetric) VAddOption { + return func(r *pb.VAddRequest) { + r.Metric = metric + } +} + +// WithConnectivity sets the HNSW M parameter. +func WithConnectivity(m uint32) VAddOption { + return func(r *pb.VAddRequest) { + r.Connectivity = &m + } +} + +// WithEfConstruction sets the HNSW ef_construction parameter. +func WithEfConstruction(ef uint32) VAddOption { + return func(r *pb.VAddRequest) { + r.EfConstruction = &ef + } +} + +// VAdd adds a vector to a vector set. The vector is passed as raw float32 +// values — no string parsing overhead. +func (c *Client) VAdd(ctx context.Context, key, element string, vector []float32, opts ...VAddOption) (bool, error) { + req := &pb.VAddRequest{ + Key: key, + Element: element, + Vector: vector, + } + for _, opt := range opts { + opt(req) + } + resp, err := c.rpc.VAdd(c.ctx(ctx), req) + if err != nil { + return false, err + } + return resp.Value, nil +} + +// VSimOption configures a VSIM command. +type VSimOption func(*pb.VSimRequest) + +// WithEfSearch sets the ef_search parameter for the query. +func WithEfSearch(ef uint32) VSimOption { + return func(r *pb.VSimRequest) { + r.EfSearch = &ef + } +} + +// VSim searches for the nearest neighbors to a query vector. +func (c *Client) VSim(ctx context.Context, key string, query []float32, count uint32, opts ...VSimOption) ([]VSimResult, error) { + req := &pb.VSimRequest{ + Key: key, + Query: query, + Count: count, + } + for _, opt := range opts { + opt(req) + } + resp, err := c.rpc.VSim(c.ctx(ctx), req) + if err != nil { + return nil, err + } + results := make([]VSimResult, len(resp.Results)) + for i, r := range resp.Results { + results[i] = VSimResult{Element: r.Element, Distance: r.Distance} + } + return results, nil +} + +// --- server --- + +// Ping sends a PING and returns the response. +func (c *Client) Ping(ctx context.Context) (string, error) { + resp, err := c.rpc.Ping(c.ctx(ctx), &pb.PingRequest{}) + if err != nil { + return "", err + } + return resp.Message, nil +} + +// FlushDB removes all keys from the database. +func (c *Client) FlushDB(ctx context.Context) error { + _, err := c.rpc.FlushDb(c.ctx(ctx), &pb.FlushDbRequest{}) + return err +} + +// DBSize returns the total number of keys across all shards. +func (c *Client) DBSize(ctx context.Context) (int64, error) { + resp, err := c.rpc.DbSize(c.ctx(ctx), &pb.DbSizeRequest{}) + if err != nil { + return 0, err + } + return resp.Value, nil +} diff --git a/clients/ember-go/ember_test.go b/clients/ember-go/ember_test.go new file mode 100644 index 00000000..86f8fcac --- /dev/null +++ b/clients/ember-go/ember_test.go @@ -0,0 +1,27 @@ +package ember + +import ( + "testing" +) + +// These are build-only tests to verify the client compiles correctly. +// Integration tests require a running ember server and are in a separate +// test suite (see CI configuration). + +func TestDialInvalidAddress(t *testing.T) { + // Dial with gRPC lazy connections won't fail immediately, + // but we can verify the client is created without panic. + c, err := Dial("localhost:0") + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + defer c.Close() +} + +func TestDialWithPassword(t *testing.T) { + c, err := Dial("localhost:0", WithPassword("secret")) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + defer c.Close() +} diff --git a/clients/ember-go/go.mod b/clients/ember-go/go.mod new file mode 100644 index 00000000..7773d3e7 --- /dev/null +++ b/clients/ember-go/go.mod @@ -0,0 +1,15 @@ +module github.com/kacy/ember-go + +go 1.25.6 + +require ( + google.golang.org/grpc v1.79.1 + google.golang.org/protobuf v1.36.11 +) + +require ( + golang.org/x/net v0.48.0 // indirect + golang.org/x/sys v0.39.0 // indirect + golang.org/x/text v0.32.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217 // indirect +) diff --git a/clients/ember-go/go.sum b/clients/ember-go/go.sum new file mode 100644 index 00000000..513ba623 --- /dev/null +++ b/clients/ember-go/go.sum @@ -0,0 +1,38 @@ +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/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= +github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +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/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= +go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= +go.opentelemetry.io/otel v1.39.0 h1:8yPrr/S0ND9QEfTfdP9V+SiwT4E0G7Y5MO7p85nis48= +go.opentelemetry.io/otel v1.39.0/go.mod h1:kLlFTywNWrFyEdH0oj2xK0bFYZtHRYUdv1NklR/tgc8= +go.opentelemetry.io/otel/metric v1.39.0 h1:d1UzonvEZriVfpNKEVmHXbdf909uGTOQjA0HF0Ls5Q0= +go.opentelemetry.io/otel/metric v1.39.0/go.mod h1:jrZSWL33sD7bBxg1xjrqyDjnuzTUB0x1nBERXd7Ftcs= +go.opentelemetry.io/otel/sdk v1.39.0 h1:nMLYcjVsvdui1B/4FRkwjzoRVsMK8uL/cj0OyhKzt18= +go.opentelemetry.io/otel/sdk v1.39.0/go.mod h1:vDojkC4/jsTJsE+kh+LXYQlbL8CgrEcwmt1ENZszdJE= +go.opentelemetry.io/otel/sdk/metric v1.39.0 h1:cXMVVFVgsIf2YL6QkRF4Urbr/aMInf+2WKg+sEJTtB8= +go.opentelemetry.io/otel/sdk/metric v1.39.0/go.mod h1:xq9HEVH7qeX69/JnwEfp6fVq5wosJsY1mt4lLfYdVew= +go.opentelemetry.io/otel/trace v1.39.0 h1:2d2vfpEDmCJ5zVYz7ijaJdOF59xLomrvj7bjt6/qCJI= +go.opentelemetry.io/otel/trace v1.39.0/go.mod h1:88w4/PnZSazkGzz/w84VHpQafiU4EtqqlVdxWy+rNOA= +golang.org/x/net v0.48.0 h1:zyQRTTrjc33Lhh0fBgT/H3oZq9WuvRR5gPC70xpDiQU= +golang.org/x/net v0.48.0/go.mod h1:+ndRgGjkh8FGtu1w1FGbEC31if4VrNVMuKTgcAAnQRY= +golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk= +golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= +golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU= +golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY= +gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk= +gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E= +google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217 h1:gRkg/vSppuSQoDjxyiGfN4Upv/h/DQmIR10ZU8dh4Ww= +google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk= +google.golang.org/grpc v1.79.1 h1:zGhSi45ODB9/p3VAawt9a+O/MULLl9dpizzNNpq7flY= +google.golang.org/grpc v1.79.1/go.mod h1:KmT0Kjez+0dde/v2j9vzwoAScgEPx/Bw1CYChhHLrHQ= +google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= +google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= diff --git a/clients/ember-go/proto/ember/v1/ember.pb.go b/clients/ember-go/proto/ember/v1/ember.pb.go new file mode 100644 index 00000000..55f2dcc0 --- /dev/null +++ b/clients/ember-go/proto/ember/v1/ember.pb.go @@ -0,0 +1,6886 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.11 +// protoc v6.33.4 +// source: ember/v1/ember.proto + +package emberv1 + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + 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 VectorMetric int32 + +const ( + VectorMetric_VECTOR_METRIC_COSINE VectorMetric = 0 + VectorMetric_VECTOR_METRIC_EUCLIDEAN VectorMetric = 1 + VectorMetric_VECTOR_METRIC_INNER_PRODUCT VectorMetric = 2 +) + +// Enum value maps for VectorMetric. +var ( + VectorMetric_name = map[int32]string{ + 0: "VECTOR_METRIC_COSINE", + 1: "VECTOR_METRIC_EUCLIDEAN", + 2: "VECTOR_METRIC_INNER_PRODUCT", + } + VectorMetric_value = map[string]int32{ + "VECTOR_METRIC_COSINE": 0, + "VECTOR_METRIC_EUCLIDEAN": 1, + "VECTOR_METRIC_INNER_PRODUCT": 2, + } +) + +func (x VectorMetric) Enum() *VectorMetric { + p := new(VectorMetric) + *p = x + return p +} + +func (x VectorMetric) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (VectorMetric) Descriptor() protoreflect.EnumDescriptor { + return file_ember_v1_ember_proto_enumTypes[0].Descriptor() +} + +func (VectorMetric) Type() protoreflect.EnumType { + return &file_ember_v1_ember_proto_enumTypes[0] +} + +func (x VectorMetric) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use VectorMetric.Descriptor instead. +func (VectorMetric) EnumDescriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{0} +} + +type VectorQuantization int32 + +const ( + VectorQuantization_VECTOR_QUANTIZATION_NONE VectorQuantization = 0 + VectorQuantization_VECTOR_QUANTIZATION_F16 VectorQuantization = 1 + VectorQuantization_VECTOR_QUANTIZATION_I8 VectorQuantization = 2 +) + +// Enum value maps for VectorQuantization. +var ( + VectorQuantization_name = map[int32]string{ + 0: "VECTOR_QUANTIZATION_NONE", + 1: "VECTOR_QUANTIZATION_F16", + 2: "VECTOR_QUANTIZATION_I8", + } + VectorQuantization_value = map[string]int32{ + "VECTOR_QUANTIZATION_NONE": 0, + "VECTOR_QUANTIZATION_F16": 1, + "VECTOR_QUANTIZATION_I8": 2, + } +) + +func (x VectorQuantization) Enum() *VectorQuantization { + p := new(VectorQuantization) + *p = x + return p +} + +func (x VectorQuantization) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (VectorQuantization) Descriptor() protoreflect.EnumDescriptor { + return file_ember_v1_ember_proto_enumTypes[1].Descriptor() +} + +func (VectorQuantization) Type() protoreflect.EnumType { + return &file_ember_v1_ember_proto_enumTypes[1] +} + +func (x VectorQuantization) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use VectorQuantization.Descriptor instead. +func (VectorQuantization) EnumDescriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{1} +} + +type ErrorKind int32 + +const ( + ErrorKind_ERROR_KIND_UNSPECIFIED ErrorKind = 0 + ErrorKind_ERROR_KIND_WRONG_TYPE ErrorKind = 1 + ErrorKind_ERROR_KIND_OUT_OF_MEMORY ErrorKind = 2 + ErrorKind_ERROR_KIND_INTERNAL ErrorKind = 3 + ErrorKind_ERROR_KIND_INVALID_ARGUMENT ErrorKind = 4 +) + +// Enum value maps for ErrorKind. +var ( + ErrorKind_name = map[int32]string{ + 0: "ERROR_KIND_UNSPECIFIED", + 1: "ERROR_KIND_WRONG_TYPE", + 2: "ERROR_KIND_OUT_OF_MEMORY", + 3: "ERROR_KIND_INTERNAL", + 4: "ERROR_KIND_INVALID_ARGUMENT", + } + ErrorKind_value = map[string]int32{ + "ERROR_KIND_UNSPECIFIED": 0, + "ERROR_KIND_WRONG_TYPE": 1, + "ERROR_KIND_OUT_OF_MEMORY": 2, + "ERROR_KIND_INTERNAL": 3, + "ERROR_KIND_INVALID_ARGUMENT": 4, + } +) + +func (x ErrorKind) Enum() *ErrorKind { + p := new(ErrorKind) + *p = x + return p +} + +func (x ErrorKind) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ErrorKind) Descriptor() protoreflect.EnumDescriptor { + return file_ember_v1_ember_proto_enumTypes[2].Descriptor() +} + +func (ErrorKind) Type() protoreflect.EnumType { + return &file_ember_v1_ember_proto_enumTypes[2] +} + +func (x ErrorKind) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ErrorKind.Descriptor instead. +func (ErrorKind) EnumDescriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{2} +} + +type IntResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *IntResponse) Reset() { + *x = IntResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *IntResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IntResponse) ProtoMessage() {} + +func (x *IntResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 IntResponse.ProtoReflect.Descriptor instead. +func (*IntResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{0} +} + +func (x *IntResponse) GetValue() int64 { + if x != nil { + return x.Value + } + return 0 +} + +type BoolResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Value bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BoolResponse) Reset() { + *x = BoolResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BoolResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BoolResponse) ProtoMessage() {} + +func (x *BoolResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 BoolResponse.ProtoReflect.Descriptor instead. +func (*BoolResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{1} +} + +func (x *BoolResponse) GetValue() bool { + if x != nil { + return x.Value + } + return false +} + +type FloatResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FloatResponse) Reset() { + *x = FloatResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FloatResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FloatResponse) ProtoMessage() {} + +func (x *FloatResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 FloatResponse.ProtoReflect.Descriptor instead. +func (*FloatResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{2} +} + +func (x *FloatResponse) GetValue() string { + if x != nil { + return x.Value + } + return "" +} + +type StatusResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StatusResponse) Reset() { + *x = StatusResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StatusResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StatusResponse) ProtoMessage() {} + +func (x *StatusResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 StatusResponse.ProtoReflect.Descriptor instead. +func (*StatusResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{3} +} + +func (x *StatusResponse) GetStatus() string { + if x != nil { + return x.Status + } + return "" +} + +type GetRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetRequest) Reset() { + *x = GetRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetRequest) ProtoMessage() {} + +func (x *GetRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 GetRequest.ProtoReflect.Descriptor instead. +func (*GetRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{4} +} + +func (x *GetRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type GetResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Value []byte `protobuf:"bytes,1,opt,name=value,proto3,oneof" json:"value,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetResponse) Reset() { + *x = GetResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetResponse) ProtoMessage() {} + +func (x *GetResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 GetResponse.ProtoReflect.Descriptor instead. +func (*GetResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{5} +} + +func (x *GetResponse) GetValue() []byte { + if x != nil { + return x.Value + } + return nil +} + +type SetRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + // expire time in seconds. 0 means no expiration. + ExpireSeconds uint64 `protobuf:"varint,3,opt,name=expire_seconds,json=expireSeconds,proto3" json:"expire_seconds,omitempty"` + // expire time in milliseconds. takes precedence over expire_seconds. + ExpireMillis uint64 `protobuf:"varint,4,opt,name=expire_millis,json=expireMillis,proto3" json:"expire_millis,omitempty"` + // NX: only set if key does not exist. + Nx bool `protobuf:"varint,5,opt,name=nx,proto3" json:"nx,omitempty"` + // XX: only set if key already exists. + Xx bool `protobuf:"varint,6,opt,name=xx,proto3" json:"xx,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SetRequest) Reset() { + *x = SetRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetRequest) ProtoMessage() {} + +func (x *SetRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 SetRequest.ProtoReflect.Descriptor instead. +func (*SetRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{6} +} + +func (x *SetRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *SetRequest) GetValue() []byte { + if x != nil { + return x.Value + } + return nil +} + +func (x *SetRequest) GetExpireSeconds() uint64 { + if x != nil { + return x.ExpireSeconds + } + return 0 +} + +func (x *SetRequest) GetExpireMillis() uint64 { + if x != nil { + return x.ExpireMillis + } + return 0 +} + +func (x *SetRequest) GetNx() bool { + if x != nil { + return x.Nx + } + return false +} + +func (x *SetRequest) GetXx() bool { + if x != nil { + return x.Xx + } + return false +} + +type SetResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // true if the key was set, false if NX/XX condition prevented it. + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SetResponse) Reset() { + *x = SetResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SetResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetResponse) ProtoMessage() {} + +func (x *SetResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 SetResponse.ProtoReflect.Descriptor instead. +func (*SetResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{7} +} + +func (x *SetResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +type DelRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Keys []string `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DelRequest) Reset() { + *x = DelRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DelRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DelRequest) ProtoMessage() {} + +func (x *DelRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 DelRequest.ProtoReflect.Descriptor instead. +func (*DelRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{8} +} + +func (x *DelRequest) GetKeys() []string { + if x != nil { + return x.Keys + } + return nil +} + +type DelResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Deleted int64 `protobuf:"varint,1,opt,name=deleted,proto3" json:"deleted,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DelResponse) Reset() { + *x = DelResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DelResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DelResponse) ProtoMessage() {} + +func (x *DelResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 DelResponse.ProtoReflect.Descriptor instead. +func (*DelResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{9} +} + +func (x *DelResponse) GetDeleted() int64 { + if x != nil { + return x.Deleted + } + return 0 +} + +type MGetRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Keys []string `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *MGetRequest) Reset() { + *x = MGetRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *MGetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MGetRequest) ProtoMessage() {} + +func (x *MGetRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 MGetRequest.ProtoReflect.Descriptor instead. +func (*MGetRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{10} +} + +func (x *MGetRequest) GetKeys() []string { + if x != nil { + return x.Keys + } + return nil +} + +type MGetResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // one entry per requested key. missing keys have value unset. + Values []*OptionalValue `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *MGetResponse) Reset() { + *x = MGetResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *MGetResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MGetResponse) ProtoMessage() {} + +func (x *MGetResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 MGetResponse.ProtoReflect.Descriptor instead. +func (*MGetResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{11} +} + +func (x *MGetResponse) GetValues() []*OptionalValue { + if x != nil { + return x.Values + } + return nil +} + +type OptionalValue struct { + state protoimpl.MessageState `protogen:"open.v1"` + Value []byte `protobuf:"bytes,1,opt,name=value,proto3,oneof" json:"value,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *OptionalValue) Reset() { + *x = OptionalValue{} + mi := &file_ember_v1_ember_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *OptionalValue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OptionalValue) ProtoMessage() {} + +func (x *OptionalValue) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 OptionalValue.ProtoReflect.Descriptor instead. +func (*OptionalValue) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{12} +} + +func (x *OptionalValue) GetValue() []byte { + if x != nil { + return x.Value + } + return nil +} + +type MSetRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Pairs []*KeyValue `protobuf:"bytes,1,rep,name=pairs,proto3" json:"pairs,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *MSetRequest) Reset() { + *x = MSetRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *MSetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MSetRequest) ProtoMessage() {} + +func (x *MSetRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 MSetRequest.ProtoReflect.Descriptor instead. +func (*MSetRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{13} +} + +func (x *MSetRequest) GetPairs() []*KeyValue { + if x != nil { + return x.Pairs + } + return nil +} + +type KeyValue struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *KeyValue) Reset() { + *x = KeyValue{} + mi := &file_ember_v1_ember_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *KeyValue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*KeyValue) ProtoMessage() {} + +func (x *KeyValue) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 KeyValue.ProtoReflect.Descriptor instead. +func (*KeyValue) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{14} +} + +func (x *KeyValue) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *KeyValue) GetValue() []byte { + if x != nil { + return x.Value + } + return nil +} + +type MSetResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *MSetResponse) Reset() { + *x = MSetResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *MSetResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MSetResponse) ProtoMessage() {} + +func (x *MSetResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 MSetResponse.ProtoReflect.Descriptor instead. +func (*MSetResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{15} +} + +type IncrRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *IncrRequest) Reset() { + *x = IncrRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *IncrRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IncrRequest) ProtoMessage() {} + +func (x *IncrRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 IncrRequest.ProtoReflect.Descriptor instead. +func (*IncrRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{16} +} + +func (x *IncrRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type IncrByRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Delta int64 `protobuf:"varint,2,opt,name=delta,proto3" json:"delta,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *IncrByRequest) Reset() { + *x = IncrByRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *IncrByRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IncrByRequest) ProtoMessage() {} + +func (x *IncrByRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 IncrByRequest.ProtoReflect.Descriptor instead. +func (*IncrByRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{17} +} + +func (x *IncrByRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *IncrByRequest) GetDelta() int64 { + if x != nil { + return x.Delta + } + return 0 +} + +type DecrByRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Delta int64 `protobuf:"varint,2,opt,name=delta,proto3" json:"delta,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DecrByRequest) Reset() { + *x = DecrByRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DecrByRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DecrByRequest) ProtoMessage() {} + +func (x *DecrByRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 DecrByRequest.ProtoReflect.Descriptor instead. +func (*DecrByRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{18} +} + +func (x *DecrByRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *DecrByRequest) GetDelta() int64 { + if x != nil { + return x.Delta + } + return 0 +} + +type IncrByFloatRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Delta float64 `protobuf:"fixed64,2,opt,name=delta,proto3" json:"delta,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *IncrByFloatRequest) Reset() { + *x = IncrByFloatRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *IncrByFloatRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IncrByFloatRequest) ProtoMessage() {} + +func (x *IncrByFloatRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 IncrByFloatRequest.ProtoReflect.Descriptor instead. +func (*IncrByFloatRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{19} +} + +func (x *IncrByFloatRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *IncrByFloatRequest) GetDelta() float64 { + if x != nil { + return x.Delta + } + return 0 +} + +type AppendRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AppendRequest) Reset() { + *x = AppendRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AppendRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AppendRequest) ProtoMessage() {} + +func (x *AppendRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 AppendRequest.ProtoReflect.Descriptor instead. +func (*AppendRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{20} +} + +func (x *AppendRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *AppendRequest) GetValue() []byte { + if x != nil { + return x.Value + } + return nil +} + +type StrlenRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StrlenRequest) Reset() { + *x = StrlenRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StrlenRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StrlenRequest) ProtoMessage() {} + +func (x *StrlenRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 StrlenRequest.ProtoReflect.Descriptor instead. +func (*StrlenRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{21} +} + +func (x *StrlenRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type ExistsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Keys []string `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ExistsRequest) Reset() { + *x = ExistsRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ExistsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExistsRequest) ProtoMessage() {} + +func (x *ExistsRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 ExistsRequest.ProtoReflect.Descriptor instead. +func (*ExistsRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{22} +} + +func (x *ExistsRequest) GetKeys() []string { + if x != nil { + return x.Keys + } + return nil +} + +type ExpireRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Seconds uint64 `protobuf:"varint,2,opt,name=seconds,proto3" json:"seconds,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ExpireRequest) Reset() { + *x = ExpireRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ExpireRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExpireRequest) ProtoMessage() {} + +func (x *ExpireRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 ExpireRequest.ProtoReflect.Descriptor instead. +func (*ExpireRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{23} +} + +func (x *ExpireRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *ExpireRequest) GetSeconds() uint64 { + if x != nil { + return x.Seconds + } + return 0 +} + +type PExpireRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Milliseconds uint64 `protobuf:"varint,2,opt,name=milliseconds,proto3" json:"milliseconds,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PExpireRequest) Reset() { + *x = PExpireRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PExpireRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PExpireRequest) ProtoMessage() {} + +func (x *PExpireRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 PExpireRequest.ProtoReflect.Descriptor instead. +func (*PExpireRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{24} +} + +func (x *PExpireRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *PExpireRequest) GetMilliseconds() uint64 { + if x != nil { + return x.Milliseconds + } + return 0 +} + +type PersistRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PersistRequest) Reset() { + *x = PersistRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PersistRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PersistRequest) ProtoMessage() {} + +func (x *PersistRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 PersistRequest.ProtoReflect.Descriptor instead. +func (*PersistRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{25} +} + +func (x *PersistRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type TtlRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TtlRequest) Reset() { + *x = TtlRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TtlRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TtlRequest) ProtoMessage() {} + +func (x *TtlRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 TtlRequest.ProtoReflect.Descriptor instead. +func (*TtlRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{26} +} + +func (x *TtlRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type PTtlRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PTtlRequest) Reset() { + *x = PTtlRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PTtlRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PTtlRequest) ProtoMessage() {} + +func (x *PTtlRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 PTtlRequest.ProtoReflect.Descriptor instead. +func (*PTtlRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{27} +} + +func (x *PTtlRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type TtlResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // -2 = key does not exist, -1 = no expiry, >= 0 = remaining time. + Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TtlResponse) Reset() { + *x = TtlResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TtlResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TtlResponse) ProtoMessage() {} + +func (x *TtlResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 TtlResponse.ProtoReflect.Descriptor instead. +func (*TtlResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{28} +} + +func (x *TtlResponse) GetValue() int64 { + if x != nil { + return x.Value + } + return 0 +} + +type TypeRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TypeRequest) Reset() { + *x = TypeRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TypeRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TypeRequest) ProtoMessage() {} + +func (x *TypeRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 TypeRequest.ProtoReflect.Descriptor instead. +func (*TypeRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{29} +} + +func (x *TypeRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type TypeResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + TypeName string `protobuf:"bytes,1,opt,name=type_name,json=typeName,proto3" json:"type_name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TypeResponse) Reset() { + *x = TypeResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TypeResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TypeResponse) ProtoMessage() {} + +func (x *TypeResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 TypeResponse.ProtoReflect.Descriptor instead. +func (*TypeResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{30} +} + +func (x *TypeResponse) GetTypeName() string { + if x != nil { + return x.TypeName + } + return "" +} + +type KeysRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Pattern string `protobuf:"bytes,1,opt,name=pattern,proto3" json:"pattern,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *KeysRequest) Reset() { + *x = KeysRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *KeysRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*KeysRequest) ProtoMessage() {} + +func (x *KeysRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 KeysRequest.ProtoReflect.Descriptor instead. +func (*KeysRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{31} +} + +func (x *KeysRequest) GetPattern() string { + if x != nil { + return x.Pattern + } + return "" +} + +type KeysResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Keys []string `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *KeysResponse) Reset() { + *x = KeysResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *KeysResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*KeysResponse) ProtoMessage() {} + +func (x *KeysResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 KeysResponse.ProtoReflect.Descriptor instead. +func (*KeysResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{32} +} + +func (x *KeysResponse) GetKeys() []string { + if x != nil { + return x.Keys + } + return nil +} + +type RenameRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + NewKey string `protobuf:"bytes,2,opt,name=new_key,json=newKey,proto3" json:"new_key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RenameRequest) Reset() { + *x = RenameRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[33] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RenameRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RenameRequest) ProtoMessage() {} + +func (x *RenameRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 RenameRequest.ProtoReflect.Descriptor instead. +func (*RenameRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{33} +} + +func (x *RenameRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *RenameRequest) GetNewKey() string { + if x != nil { + return x.NewKey + } + return "" +} + +type ScanRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Cursor uint64 `protobuf:"varint,1,opt,name=cursor,proto3" json:"cursor,omitempty"` + Count uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` + Pattern *string `protobuf:"bytes,3,opt,name=pattern,proto3,oneof" json:"pattern,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ScanRequest) Reset() { + *x = ScanRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ScanRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ScanRequest) ProtoMessage() {} + +func (x *ScanRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 ScanRequest.ProtoReflect.Descriptor instead. +func (*ScanRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{34} +} + +func (x *ScanRequest) GetCursor() uint64 { + if x != nil { + return x.Cursor + } + return 0 +} + +func (x *ScanRequest) GetCount() uint32 { + if x != nil { + return x.Count + } + return 0 +} + +func (x *ScanRequest) GetPattern() string { + if x != nil && x.Pattern != nil { + return *x.Pattern + } + return "" +} + +type ScanResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Cursor uint64 `protobuf:"varint,1,opt,name=cursor,proto3" json:"cursor,omitempty"` + Keys []string `protobuf:"bytes,2,rep,name=keys,proto3" json:"keys,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ScanResponse) Reset() { + *x = ScanResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[35] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ScanResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ScanResponse) ProtoMessage() {} + +func (x *ScanResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_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 ScanResponse.ProtoReflect.Descriptor instead. +func (*ScanResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{35} +} + +func (x *ScanResponse) GetCursor() uint64 { + if x != nil { + return x.Cursor + } + return 0 +} + +func (x *ScanResponse) GetKeys() []string { + if x != nil { + return x.Keys + } + return nil +} + +type LPushRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Values [][]byte `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *LPushRequest) Reset() { + *x = LPushRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[36] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *LPushRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LPushRequest) ProtoMessage() {} + +func (x *LPushRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[36] + 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 LPushRequest.ProtoReflect.Descriptor instead. +func (*LPushRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{36} +} + +func (x *LPushRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *LPushRequest) GetValues() [][]byte { + if x != nil { + return x.Values + } + return nil +} + +type RPushRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Values [][]byte `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RPushRequest) Reset() { + *x = RPushRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[37] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RPushRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RPushRequest) ProtoMessage() {} + +func (x *RPushRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[37] + 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 RPushRequest.ProtoReflect.Descriptor instead. +func (*RPushRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{37} +} + +func (x *RPushRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *RPushRequest) GetValues() [][]byte { + if x != nil { + return x.Values + } + return nil +} + +type LPopRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *LPopRequest) Reset() { + *x = LPopRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[38] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *LPopRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LPopRequest) ProtoMessage() {} + +func (x *LPopRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[38] + 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 LPopRequest.ProtoReflect.Descriptor instead. +func (*LPopRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{38} +} + +func (x *LPopRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type RPopRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RPopRequest) Reset() { + *x = RPopRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[39] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RPopRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RPopRequest) ProtoMessage() {} + +func (x *RPopRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[39] + 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 RPopRequest.ProtoReflect.Descriptor instead. +func (*RPopRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{39} +} + +func (x *RPopRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type LRangeRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Start int64 `protobuf:"varint,2,opt,name=start,proto3" json:"start,omitempty"` + Stop int64 `protobuf:"varint,3,opt,name=stop,proto3" json:"stop,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *LRangeRequest) Reset() { + *x = LRangeRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[40] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *LRangeRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LRangeRequest) ProtoMessage() {} + +func (x *LRangeRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[40] + 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 LRangeRequest.ProtoReflect.Descriptor instead. +func (*LRangeRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{40} +} + +func (x *LRangeRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *LRangeRequest) GetStart() int64 { + if x != nil { + return x.Start + } + return 0 +} + +func (x *LRangeRequest) GetStop() int64 { + if x != nil { + return x.Stop + } + return 0 +} + +type ArrayResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Values [][]byte `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ArrayResponse) Reset() { + *x = ArrayResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[41] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ArrayResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ArrayResponse) ProtoMessage() {} + +func (x *ArrayResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[41] + 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 ArrayResponse.ProtoReflect.Descriptor instead. +func (*ArrayResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{41} +} + +func (x *ArrayResponse) GetValues() [][]byte { + if x != nil { + return x.Values + } + return nil +} + +type LLenRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *LLenRequest) Reset() { + *x = LLenRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[42] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *LLenRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LLenRequest) ProtoMessage() {} + +func (x *LLenRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[42] + 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 LLenRequest.ProtoReflect.Descriptor instead. +func (*LLenRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{42} +} + +func (x *LLenRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type HSetRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields []*FieldValue `protobuf:"bytes,2,rep,name=fields,proto3" json:"fields,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *HSetRequest) Reset() { + *x = HSetRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[43] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HSetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HSetRequest) ProtoMessage() {} + +func (x *HSetRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[43] + 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 HSetRequest.ProtoReflect.Descriptor instead. +func (*HSetRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{43} +} + +func (x *HSetRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *HSetRequest) GetFields() []*FieldValue { + if x != nil { + return x.Fields + } + return nil +} + +type FieldValue struct { + state protoimpl.MessageState `protogen:"open.v1"` + Field string `protobuf:"bytes,1,opt,name=field,proto3" json:"field,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FieldValue) Reset() { + *x = FieldValue{} + mi := &file_ember_v1_ember_proto_msgTypes[44] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FieldValue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FieldValue) ProtoMessage() {} + +func (x *FieldValue) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[44] + 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 FieldValue.ProtoReflect.Descriptor instead. +func (*FieldValue) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{44} +} + +func (x *FieldValue) GetField() string { + if x != nil { + return x.Field + } + return "" +} + +func (x *FieldValue) GetValue() []byte { + if x != nil { + return x.Value + } + return nil +} + +type HGetRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Field string `protobuf:"bytes,2,opt,name=field,proto3" json:"field,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *HGetRequest) Reset() { + *x = HGetRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[45] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HGetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HGetRequest) ProtoMessage() {} + +func (x *HGetRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[45] + 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 HGetRequest.ProtoReflect.Descriptor instead. +func (*HGetRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{45} +} + +func (x *HGetRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *HGetRequest) GetField() string { + if x != nil { + return x.Field + } + return "" +} + +type HGetAllRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *HGetAllRequest) Reset() { + *x = HGetAllRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[46] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HGetAllRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HGetAllRequest) ProtoMessage() {} + +func (x *HGetAllRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[46] + 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 HGetAllRequest.ProtoReflect.Descriptor instead. +func (*HGetAllRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{46} +} + +func (x *HGetAllRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type HashResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Fields []*FieldValue `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *HashResponse) Reset() { + *x = HashResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[47] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HashResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HashResponse) ProtoMessage() {} + +func (x *HashResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[47] + 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 HashResponse.ProtoReflect.Descriptor instead. +func (*HashResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{47} +} + +func (x *HashResponse) GetFields() []*FieldValue { + if x != nil { + return x.Fields + } + return nil +} + +type HDelRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields []string `protobuf:"bytes,2,rep,name=fields,proto3" json:"fields,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *HDelRequest) Reset() { + *x = HDelRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[48] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HDelRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HDelRequest) ProtoMessage() {} + +func (x *HDelRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[48] + 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 HDelRequest.ProtoReflect.Descriptor instead. +func (*HDelRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{48} +} + +func (x *HDelRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *HDelRequest) GetFields() []string { + if x != nil { + return x.Fields + } + return nil +} + +type HExistsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Field string `protobuf:"bytes,2,opt,name=field,proto3" json:"field,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *HExistsRequest) Reset() { + *x = HExistsRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[49] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HExistsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HExistsRequest) ProtoMessage() {} + +func (x *HExistsRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[49] + 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 HExistsRequest.ProtoReflect.Descriptor instead. +func (*HExistsRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{49} +} + +func (x *HExistsRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *HExistsRequest) GetField() string { + if x != nil { + return x.Field + } + return "" +} + +type HLenRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *HLenRequest) Reset() { + *x = HLenRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[50] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HLenRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HLenRequest) ProtoMessage() {} + +func (x *HLenRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[50] + 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 HLenRequest.ProtoReflect.Descriptor instead. +func (*HLenRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{50} +} + +func (x *HLenRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type HIncrByRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Field string `protobuf:"bytes,2,opt,name=field,proto3" json:"field,omitempty"` + Delta int64 `protobuf:"varint,3,opt,name=delta,proto3" json:"delta,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *HIncrByRequest) Reset() { + *x = HIncrByRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[51] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HIncrByRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HIncrByRequest) ProtoMessage() {} + +func (x *HIncrByRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[51] + 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 HIncrByRequest.ProtoReflect.Descriptor instead. +func (*HIncrByRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{51} +} + +func (x *HIncrByRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *HIncrByRequest) GetField() string { + if x != nil { + return x.Field + } + return "" +} + +func (x *HIncrByRequest) GetDelta() int64 { + if x != nil { + return x.Delta + } + return 0 +} + +type HKeysRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *HKeysRequest) Reset() { + *x = HKeysRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[52] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HKeysRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HKeysRequest) ProtoMessage() {} + +func (x *HKeysRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[52] + 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 HKeysRequest.ProtoReflect.Descriptor instead. +func (*HKeysRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{52} +} + +func (x *HKeysRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type HValsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *HValsRequest) Reset() { + *x = HValsRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[53] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HValsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HValsRequest) ProtoMessage() {} + +func (x *HValsRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[53] + 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 HValsRequest.ProtoReflect.Descriptor instead. +func (*HValsRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{53} +} + +func (x *HValsRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type HMGetRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Fields []string `protobuf:"bytes,2,rep,name=fields,proto3" json:"fields,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *HMGetRequest) Reset() { + *x = HMGetRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[54] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HMGetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HMGetRequest) ProtoMessage() {} + +func (x *HMGetRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[54] + 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 HMGetRequest.ProtoReflect.Descriptor instead. +func (*HMGetRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{54} +} + +func (x *HMGetRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *HMGetRequest) GetFields() []string { + if x != nil { + return x.Fields + } + return nil +} + +type OptionalArrayResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Values []*OptionalValue `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *OptionalArrayResponse) Reset() { + *x = OptionalArrayResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[55] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *OptionalArrayResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OptionalArrayResponse) ProtoMessage() {} + +func (x *OptionalArrayResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[55] + 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 OptionalArrayResponse.ProtoReflect.Descriptor instead. +func (*OptionalArrayResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{55} +} + +func (x *OptionalArrayResponse) GetValues() []*OptionalValue { + if x != nil { + return x.Values + } + return nil +} + +type SAddRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Members []string `protobuf:"bytes,2,rep,name=members,proto3" json:"members,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SAddRequest) Reset() { + *x = SAddRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[56] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SAddRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SAddRequest) ProtoMessage() {} + +func (x *SAddRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[56] + 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 SAddRequest.ProtoReflect.Descriptor instead. +func (*SAddRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{56} +} + +func (x *SAddRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *SAddRequest) GetMembers() []string { + if x != nil { + return x.Members + } + return nil +} + +type SRemRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Members []string `protobuf:"bytes,2,rep,name=members,proto3" json:"members,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SRemRequest) Reset() { + *x = SRemRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[57] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SRemRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SRemRequest) ProtoMessage() {} + +func (x *SRemRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[57] + 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 SRemRequest.ProtoReflect.Descriptor instead. +func (*SRemRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{57} +} + +func (x *SRemRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *SRemRequest) GetMembers() []string { + if x != nil { + return x.Members + } + return nil +} + +type SMembersRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SMembersRequest) Reset() { + *x = SMembersRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[58] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SMembersRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SMembersRequest) ProtoMessage() {} + +func (x *SMembersRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[58] + 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 SMembersRequest.ProtoReflect.Descriptor instead. +func (*SMembersRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{58} +} + +func (x *SMembersRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type SIsMemberRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Member string `protobuf:"bytes,2,opt,name=member,proto3" json:"member,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SIsMemberRequest) Reset() { + *x = SIsMemberRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[59] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SIsMemberRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SIsMemberRequest) ProtoMessage() {} + +func (x *SIsMemberRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[59] + 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 SIsMemberRequest.ProtoReflect.Descriptor instead. +func (*SIsMemberRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{59} +} + +func (x *SIsMemberRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *SIsMemberRequest) GetMember() string { + if x != nil { + return x.Member + } + return "" +} + +type SCardRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SCardRequest) Reset() { + *x = SCardRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[60] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SCardRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SCardRequest) ProtoMessage() {} + +func (x *SCardRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[60] + 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 SCardRequest.ProtoReflect.Descriptor instead. +func (*SCardRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{60} +} + +func (x *SCardRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type ZAddRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Members []*ScoreMember `protobuf:"bytes,2,rep,name=members,proto3" json:"members,omitempty"` + Nx bool `protobuf:"varint,3,opt,name=nx,proto3" json:"nx,omitempty"` + Xx bool `protobuf:"varint,4,opt,name=xx,proto3" json:"xx,omitempty"` + Gt bool `protobuf:"varint,5,opt,name=gt,proto3" json:"gt,omitempty"` + Lt bool `protobuf:"varint,6,opt,name=lt,proto3" json:"lt,omitempty"` + Ch bool `protobuf:"varint,7,opt,name=ch,proto3" json:"ch,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ZAddRequest) Reset() { + *x = ZAddRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[61] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ZAddRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ZAddRequest) ProtoMessage() {} + +func (x *ZAddRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[61] + 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 ZAddRequest.ProtoReflect.Descriptor instead. +func (*ZAddRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{61} +} + +func (x *ZAddRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *ZAddRequest) GetMembers() []*ScoreMember { + if x != nil { + return x.Members + } + return nil +} + +func (x *ZAddRequest) GetNx() bool { + if x != nil { + return x.Nx + } + return false +} + +func (x *ZAddRequest) GetXx() bool { + if x != nil { + return x.Xx + } + return false +} + +func (x *ZAddRequest) GetGt() bool { + if x != nil { + return x.Gt + } + return false +} + +func (x *ZAddRequest) GetLt() bool { + if x != nil { + return x.Lt + } + return false +} + +func (x *ZAddRequest) GetCh() bool { + if x != nil { + return x.Ch + } + return false +} + +type ScoreMember struct { + state protoimpl.MessageState `protogen:"open.v1"` + Score float64 `protobuf:"fixed64,1,opt,name=score,proto3" json:"score,omitempty"` + Member string `protobuf:"bytes,2,opt,name=member,proto3" json:"member,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ScoreMember) Reset() { + *x = ScoreMember{} + mi := &file_ember_v1_ember_proto_msgTypes[62] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ScoreMember) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ScoreMember) ProtoMessage() {} + +func (x *ScoreMember) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[62] + 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 ScoreMember.ProtoReflect.Descriptor instead. +func (*ScoreMember) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{62} +} + +func (x *ScoreMember) GetScore() float64 { + if x != nil { + return x.Score + } + return 0 +} + +func (x *ScoreMember) GetMember() string { + if x != nil { + return x.Member + } + return "" +} + +type ZRemRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Members []string `protobuf:"bytes,2,rep,name=members,proto3" json:"members,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ZRemRequest) Reset() { + *x = ZRemRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[63] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ZRemRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ZRemRequest) ProtoMessage() {} + +func (x *ZRemRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[63] + 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 ZRemRequest.ProtoReflect.Descriptor instead. +func (*ZRemRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{63} +} + +func (x *ZRemRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *ZRemRequest) GetMembers() []string { + if x != nil { + return x.Members + } + return nil +} + +type ZScoreRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Member string `protobuf:"bytes,2,opt,name=member,proto3" json:"member,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ZScoreRequest) Reset() { + *x = ZScoreRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[64] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ZScoreRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ZScoreRequest) ProtoMessage() {} + +func (x *ZScoreRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[64] + 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 ZScoreRequest.ProtoReflect.Descriptor instead. +func (*ZScoreRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{64} +} + +func (x *ZScoreRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *ZScoreRequest) GetMember() string { + if x != nil { + return x.Member + } + return "" +} + +type OptionalFloatResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Value *float64 `protobuf:"fixed64,1,opt,name=value,proto3,oneof" json:"value,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *OptionalFloatResponse) Reset() { + *x = OptionalFloatResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[65] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *OptionalFloatResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OptionalFloatResponse) ProtoMessage() {} + +func (x *OptionalFloatResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[65] + 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 OptionalFloatResponse.ProtoReflect.Descriptor instead. +func (*OptionalFloatResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{65} +} + +func (x *OptionalFloatResponse) GetValue() float64 { + if x != nil && x.Value != nil { + return *x.Value + } + return 0 +} + +type ZRankRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Member string `protobuf:"bytes,2,opt,name=member,proto3" json:"member,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ZRankRequest) Reset() { + *x = ZRankRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[66] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ZRankRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ZRankRequest) ProtoMessage() {} + +func (x *ZRankRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[66] + 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 ZRankRequest.ProtoReflect.Descriptor instead. +func (*ZRankRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{66} +} + +func (x *ZRankRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *ZRankRequest) GetMember() string { + if x != nil { + return x.Member + } + return "" +} + +type OptionalIntResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Value *int64 `protobuf:"varint,1,opt,name=value,proto3,oneof" json:"value,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *OptionalIntResponse) Reset() { + *x = OptionalIntResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[67] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *OptionalIntResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OptionalIntResponse) ProtoMessage() {} + +func (x *OptionalIntResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[67] + 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 OptionalIntResponse.ProtoReflect.Descriptor instead. +func (*OptionalIntResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{67} +} + +func (x *OptionalIntResponse) GetValue() int64 { + if x != nil && x.Value != nil { + return *x.Value + } + return 0 +} + +type ZCardRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ZCardRequest) Reset() { + *x = ZCardRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[68] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ZCardRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ZCardRequest) ProtoMessage() {} + +func (x *ZCardRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[68] + 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 ZCardRequest.ProtoReflect.Descriptor instead. +func (*ZCardRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{68} +} + +func (x *ZCardRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type ZRangeRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Start int64 `protobuf:"varint,2,opt,name=start,proto3" json:"start,omitempty"` + Stop int64 `protobuf:"varint,3,opt,name=stop,proto3" json:"stop,omitempty"` + WithScores bool `protobuf:"varint,4,opt,name=with_scores,json=withScores,proto3" json:"with_scores,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ZRangeRequest) Reset() { + *x = ZRangeRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[69] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ZRangeRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ZRangeRequest) ProtoMessage() {} + +func (x *ZRangeRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[69] + 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 ZRangeRequest.ProtoReflect.Descriptor instead. +func (*ZRangeRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{69} +} + +func (x *ZRangeRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *ZRangeRequest) GetStart() int64 { + if x != nil { + return x.Start + } + return 0 +} + +func (x *ZRangeRequest) GetStop() int64 { + if x != nil { + return x.Stop + } + return 0 +} + +func (x *ZRangeRequest) GetWithScores() bool { + if x != nil { + return x.WithScores + } + return false +} + +type ZRangeResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // when with_scores is false, only member is populated. + Members []*ScoreMember `protobuf:"bytes,1,rep,name=members,proto3" json:"members,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ZRangeResponse) Reset() { + *x = ZRangeResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[70] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ZRangeResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ZRangeResponse) ProtoMessage() {} + +func (x *ZRangeResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[70] + 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 ZRangeResponse.ProtoReflect.Descriptor instead. +func (*ZRangeResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{70} +} + +func (x *ZRangeResponse) GetMembers() []*ScoreMember { + if x != nil { + return x.Members + } + return nil +} + +type VAddRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Element string `protobuf:"bytes,2,opt,name=element,proto3" json:"element,omitempty"` + // packed IEEE 754 floats — no parsing overhead. + Vector []float32 `protobuf:"fixed32,3,rep,packed,name=vector,proto3" json:"vector,omitempty"` + Metric VectorMetric `protobuf:"varint,4,opt,name=metric,proto3,enum=ember.v1.VectorMetric" json:"metric,omitempty"` + Quantization VectorQuantization `protobuf:"varint,5,opt,name=quantization,proto3,enum=ember.v1.VectorQuantization" json:"quantization,omitempty"` + Connectivity *uint32 `protobuf:"varint,6,opt,name=connectivity,proto3,oneof" json:"connectivity,omitempty"` + EfConstruction *uint32 `protobuf:"varint,7,opt,name=ef_construction,json=efConstruction,proto3,oneof" json:"ef_construction,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *VAddRequest) Reset() { + *x = VAddRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[71] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *VAddRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VAddRequest) ProtoMessage() {} + +func (x *VAddRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[71] + 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 VAddRequest.ProtoReflect.Descriptor instead. +func (*VAddRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{71} +} + +func (x *VAddRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *VAddRequest) GetElement() string { + if x != nil { + return x.Element + } + return "" +} + +func (x *VAddRequest) GetVector() []float32 { + if x != nil { + return x.Vector + } + return nil +} + +func (x *VAddRequest) GetMetric() VectorMetric { + if x != nil { + return x.Metric + } + return VectorMetric_VECTOR_METRIC_COSINE +} + +func (x *VAddRequest) GetQuantization() VectorQuantization { + if x != nil { + return x.Quantization + } + return VectorQuantization_VECTOR_QUANTIZATION_NONE +} + +func (x *VAddRequest) GetConnectivity() uint32 { + if x != nil && x.Connectivity != nil { + return *x.Connectivity + } + return 0 +} + +func (x *VAddRequest) GetEfConstruction() uint32 { + if x != nil && x.EfConstruction != nil { + return *x.EfConstruction + } + return 0 +} + +type VSimRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Query []float32 `protobuf:"fixed32,2,rep,packed,name=query,proto3" json:"query,omitempty"` + Count uint32 `protobuf:"varint,3,opt,name=count,proto3" json:"count,omitempty"` + EfSearch *uint32 `protobuf:"varint,4,opt,name=ef_search,json=efSearch,proto3,oneof" json:"ef_search,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *VSimRequest) Reset() { + *x = VSimRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[72] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *VSimRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VSimRequest) ProtoMessage() {} + +func (x *VSimRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[72] + 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 VSimRequest.ProtoReflect.Descriptor instead. +func (*VSimRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{72} +} + +func (x *VSimRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *VSimRequest) GetQuery() []float32 { + if x != nil { + return x.Query + } + return nil +} + +func (x *VSimRequest) GetCount() uint32 { + if x != nil { + return x.Count + } + return 0 +} + +func (x *VSimRequest) GetEfSearch() uint32 { + if x != nil && x.EfSearch != nil { + return *x.EfSearch + } + return 0 +} + +type VSimResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Results []*VSimResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *VSimResponse) Reset() { + *x = VSimResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[73] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *VSimResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VSimResponse) ProtoMessage() {} + +func (x *VSimResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[73] + 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 VSimResponse.ProtoReflect.Descriptor instead. +func (*VSimResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{73} +} + +func (x *VSimResponse) GetResults() []*VSimResult { + if x != nil { + return x.Results + } + return nil +} + +type VSimResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + Element string `protobuf:"bytes,1,opt,name=element,proto3" json:"element,omitempty"` + Distance float32 `protobuf:"fixed32,2,opt,name=distance,proto3" json:"distance,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *VSimResult) Reset() { + *x = VSimResult{} + mi := &file_ember_v1_ember_proto_msgTypes[74] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *VSimResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VSimResult) ProtoMessage() {} + +func (x *VSimResult) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[74] + 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 VSimResult.ProtoReflect.Descriptor instead. +func (*VSimResult) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{74} +} + +func (x *VSimResult) GetElement() string { + if x != nil { + return x.Element + } + return "" +} + +func (x *VSimResult) GetDistance() float32 { + if x != nil { + return x.Distance + } + return 0 +} + +type VRemRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Element string `protobuf:"bytes,2,opt,name=element,proto3" json:"element,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *VRemRequest) Reset() { + *x = VRemRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[75] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *VRemRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VRemRequest) ProtoMessage() {} + +func (x *VRemRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[75] + 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 VRemRequest.ProtoReflect.Descriptor instead. +func (*VRemRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{75} +} + +func (x *VRemRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *VRemRequest) GetElement() string { + if x != nil { + return x.Element + } + return "" +} + +type VGetRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Element string `protobuf:"bytes,2,opt,name=element,proto3" json:"element,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *VGetRequest) Reset() { + *x = VGetRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[76] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *VGetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VGetRequest) ProtoMessage() {} + +func (x *VGetRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[76] + 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 VGetRequest.ProtoReflect.Descriptor instead. +func (*VGetRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{76} +} + +func (x *VGetRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *VGetRequest) GetElement() string { + if x != nil { + return x.Element + } + return "" +} + +type VGetResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Exists *bool `protobuf:"varint,1,opt,name=exists,proto3,oneof" json:"exists,omitempty"` + Vector []float32 `protobuf:"fixed32,2,rep,packed,name=vector,proto3" json:"vector,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *VGetResponse) Reset() { + *x = VGetResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[77] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *VGetResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VGetResponse) ProtoMessage() {} + +func (x *VGetResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[77] + 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 VGetResponse.ProtoReflect.Descriptor instead. +func (*VGetResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{77} +} + +func (x *VGetResponse) GetExists() bool { + if x != nil && x.Exists != nil { + return *x.Exists + } + return false +} + +func (x *VGetResponse) GetVector() []float32 { + if x != nil { + return x.Vector + } + return nil +} + +type VCardRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *VCardRequest) Reset() { + *x = VCardRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[78] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *VCardRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VCardRequest) ProtoMessage() {} + +func (x *VCardRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[78] + 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 VCardRequest.ProtoReflect.Descriptor instead. +func (*VCardRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{78} +} + +func (x *VCardRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type VDimRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *VDimRequest) Reset() { + *x = VDimRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[79] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *VDimRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VDimRequest) ProtoMessage() {} + +func (x *VDimRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[79] + 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 VDimRequest.ProtoReflect.Descriptor instead. +func (*VDimRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{79} +} + +func (x *VDimRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type VInfoRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *VInfoRequest) Reset() { + *x = VInfoRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[80] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *VInfoRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VInfoRequest) ProtoMessage() {} + +func (x *VInfoRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[80] + 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 VInfoRequest.ProtoReflect.Descriptor instead. +func (*VInfoRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{80} +} + +func (x *VInfoRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type VInfoResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Exists bool `protobuf:"varint,1,opt,name=exists,proto3" json:"exists,omitempty"` + Info []*FieldValue `protobuf:"bytes,2,rep,name=info,proto3" json:"info,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *VInfoResponse) Reset() { + *x = VInfoResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[81] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *VInfoResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VInfoResponse) ProtoMessage() {} + +func (x *VInfoResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[81] + 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 VInfoResponse.ProtoReflect.Descriptor instead. +func (*VInfoResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{81} +} + +func (x *VInfoResponse) GetExists() bool { + if x != nil { + return x.Exists + } + return false +} + +func (x *VInfoResponse) GetInfo() []*FieldValue { + if x != nil { + return x.Info + } + return nil +} + +type PingRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Message *string `protobuf:"bytes,1,opt,name=message,proto3,oneof" json:"message,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PingRequest) Reset() { + *x = PingRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[82] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PingRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PingRequest) ProtoMessage() {} + +func (x *PingRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[82] + 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 PingRequest.ProtoReflect.Descriptor instead. +func (*PingRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{82} +} + +func (x *PingRequest) GetMessage() string { + if x != nil && x.Message != nil { + return *x.Message + } + return "" +} + +type PingResponse 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 *PingResponse) Reset() { + *x = PingResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[83] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PingResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PingResponse) ProtoMessage() {} + +func (x *PingResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[83] + 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 PingResponse.ProtoReflect.Descriptor instead. +func (*PingResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{83} +} + +func (x *PingResponse) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +type FlushDbRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Async bool `protobuf:"varint,1,opt,name=async,proto3" json:"async,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FlushDbRequest) Reset() { + *x = FlushDbRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[84] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FlushDbRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FlushDbRequest) ProtoMessage() {} + +func (x *FlushDbRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[84] + 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 FlushDbRequest.ProtoReflect.Descriptor instead. +func (*FlushDbRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{84} +} + +func (x *FlushDbRequest) GetAsync() bool { + if x != nil { + return x.Async + } + return false +} + +type DbSizeRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DbSizeRequest) Reset() { + *x = DbSizeRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[85] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DbSizeRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DbSizeRequest) ProtoMessage() {} + +func (x *DbSizeRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[85] + 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 DbSizeRequest.ProtoReflect.Descriptor instead. +func (*DbSizeRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{85} +} + +type InfoRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Section *string `protobuf:"bytes,1,opt,name=section,proto3,oneof" json:"section,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *InfoRequest) Reset() { + *x = InfoRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[86] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *InfoRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InfoRequest) ProtoMessage() {} + +func (x *InfoRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[86] + 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 InfoRequest.ProtoReflect.Descriptor instead. +func (*InfoRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{86} +} + +func (x *InfoRequest) GetSection() string { + if x != nil && x.Section != nil { + return *x.Section + } + return "" +} + +type InfoResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Info string `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *InfoResponse) Reset() { + *x = InfoResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[87] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *InfoResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InfoResponse) ProtoMessage() {} + +func (x *InfoResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[87] + 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 InfoResponse.ProtoReflect.Descriptor instead. +func (*InfoResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{87} +} + +func (x *InfoResponse) GetInfo() string { + if x != nil { + return x.Info + } + return "" +} + +type PipelineRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + // Types that are valid to be assigned to Command: + // + // *PipelineRequest_Get + // *PipelineRequest_Set + // *PipelineRequest_Del + // *PipelineRequest_Exists + // *PipelineRequest_Incr + // *PipelineRequest_IncrBy + // *PipelineRequest_DecrBy + // *PipelineRequest_IncrByFloat + // *PipelineRequest_Append + // *PipelineRequest_Strlen + // *PipelineRequest_Expire + // *PipelineRequest_Pexpire + // *PipelineRequest_Persist + // *PipelineRequest_Ttl + // *PipelineRequest_Pttl + // *PipelineRequest_Type + // *PipelineRequest_Lpush + // *PipelineRequest_Rpush + // *PipelineRequest_Lpop + // *PipelineRequest_Rpop + // *PipelineRequest_Lrange + // *PipelineRequest_Llen + // *PipelineRequest_Hset + // *PipelineRequest_Hget + // *PipelineRequest_Hgetall + // *PipelineRequest_Hdel + // *PipelineRequest_Hexists + // *PipelineRequest_Hlen + // *PipelineRequest_HincrBy + // *PipelineRequest_Hkeys + // *PipelineRequest_Hvals + // *PipelineRequest_Hmget + // *PipelineRequest_Sadd + // *PipelineRequest_Srem + // *PipelineRequest_Smembers + // *PipelineRequest_Sismember + // *PipelineRequest_Scard + // *PipelineRequest_Zadd + // *PipelineRequest_Zrem + // *PipelineRequest_Zscore + // *PipelineRequest_Zrank + // *PipelineRequest_Zcard + // *PipelineRequest_Zrange + // *PipelineRequest_Vadd + // *PipelineRequest_Vsim + // *PipelineRequest_Vrem + // *PipelineRequest_Vget + // *PipelineRequest_Vcard + // *PipelineRequest_Vdim + // *PipelineRequest_Vinfo + // *PipelineRequest_Ping + // *PipelineRequest_Flushdb + // *PipelineRequest_Dbsize + // *PipelineRequest_Mget + // *PipelineRequest_Mset + // *PipelineRequest_Keys + // *PipelineRequest_Rename + // *PipelineRequest_Scan + Command isPipelineRequest_Command `protobuf_oneof:"command"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PipelineRequest) Reset() { + *x = PipelineRequest{} + mi := &file_ember_v1_ember_proto_msgTypes[88] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PipelineRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PipelineRequest) ProtoMessage() {} + +func (x *PipelineRequest) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[88] + 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 PipelineRequest.ProtoReflect.Descriptor instead. +func (*PipelineRequest) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{88} +} + +func (x *PipelineRequest) GetId() uint64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *PipelineRequest) GetCommand() isPipelineRequest_Command { + if x != nil { + return x.Command + } + return nil +} + +func (x *PipelineRequest) GetGet() *GetRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Get); ok { + return x.Get + } + } + return nil +} + +func (x *PipelineRequest) GetSet() *SetRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Set); ok { + return x.Set + } + } + return nil +} + +func (x *PipelineRequest) GetDel() *DelRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Del); ok { + return x.Del + } + } + return nil +} + +func (x *PipelineRequest) GetExists() *ExistsRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Exists); ok { + return x.Exists + } + } + return nil +} + +func (x *PipelineRequest) GetIncr() *IncrRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Incr); ok { + return x.Incr + } + } + return nil +} + +func (x *PipelineRequest) GetIncrBy() *IncrByRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_IncrBy); ok { + return x.IncrBy + } + } + return nil +} + +func (x *PipelineRequest) GetDecrBy() *DecrByRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_DecrBy); ok { + return x.DecrBy + } + } + return nil +} + +func (x *PipelineRequest) GetIncrByFloat() *IncrByFloatRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_IncrByFloat); ok { + return x.IncrByFloat + } + } + return nil +} + +func (x *PipelineRequest) GetAppend() *AppendRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Append); ok { + return x.Append + } + } + return nil +} + +func (x *PipelineRequest) GetStrlen() *StrlenRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Strlen); ok { + return x.Strlen + } + } + return nil +} + +func (x *PipelineRequest) GetExpire() *ExpireRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Expire); ok { + return x.Expire + } + } + return nil +} + +func (x *PipelineRequest) GetPexpire() *PExpireRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Pexpire); ok { + return x.Pexpire + } + } + return nil +} + +func (x *PipelineRequest) GetPersist() *PersistRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Persist); ok { + return x.Persist + } + } + return nil +} + +func (x *PipelineRequest) GetTtl() *TtlRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Ttl); ok { + return x.Ttl + } + } + return nil +} + +func (x *PipelineRequest) GetPttl() *PTtlRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Pttl); ok { + return x.Pttl + } + } + return nil +} + +func (x *PipelineRequest) GetType() *TypeRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Type); ok { + return x.Type + } + } + return nil +} + +func (x *PipelineRequest) GetLpush() *LPushRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Lpush); ok { + return x.Lpush + } + } + return nil +} + +func (x *PipelineRequest) GetRpush() *RPushRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Rpush); ok { + return x.Rpush + } + } + return nil +} + +func (x *PipelineRequest) GetLpop() *LPopRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Lpop); ok { + return x.Lpop + } + } + return nil +} + +func (x *PipelineRequest) GetRpop() *RPopRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Rpop); ok { + return x.Rpop + } + } + return nil +} + +func (x *PipelineRequest) GetLrange() *LRangeRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Lrange); ok { + return x.Lrange + } + } + return nil +} + +func (x *PipelineRequest) GetLlen() *LLenRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Llen); ok { + return x.Llen + } + } + return nil +} + +func (x *PipelineRequest) GetHset() *HSetRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Hset); ok { + return x.Hset + } + } + return nil +} + +func (x *PipelineRequest) GetHget() *HGetRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Hget); ok { + return x.Hget + } + } + return nil +} + +func (x *PipelineRequest) GetHgetall() *HGetAllRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Hgetall); ok { + return x.Hgetall + } + } + return nil +} + +func (x *PipelineRequest) GetHdel() *HDelRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Hdel); ok { + return x.Hdel + } + } + return nil +} + +func (x *PipelineRequest) GetHexists() *HExistsRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Hexists); ok { + return x.Hexists + } + } + return nil +} + +func (x *PipelineRequest) GetHlen() *HLenRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Hlen); ok { + return x.Hlen + } + } + return nil +} + +func (x *PipelineRequest) GetHincrBy() *HIncrByRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_HincrBy); ok { + return x.HincrBy + } + } + return nil +} + +func (x *PipelineRequest) GetHkeys() *HKeysRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Hkeys); ok { + return x.Hkeys + } + } + return nil +} + +func (x *PipelineRequest) GetHvals() *HValsRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Hvals); ok { + return x.Hvals + } + } + return nil +} + +func (x *PipelineRequest) GetHmget() *HMGetRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Hmget); ok { + return x.Hmget + } + } + return nil +} + +func (x *PipelineRequest) GetSadd() *SAddRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Sadd); ok { + return x.Sadd + } + } + return nil +} + +func (x *PipelineRequest) GetSrem() *SRemRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Srem); ok { + return x.Srem + } + } + return nil +} + +func (x *PipelineRequest) GetSmembers() *SMembersRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Smembers); ok { + return x.Smembers + } + } + return nil +} + +func (x *PipelineRequest) GetSismember() *SIsMemberRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Sismember); ok { + return x.Sismember + } + } + return nil +} + +func (x *PipelineRequest) GetScard() *SCardRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Scard); ok { + return x.Scard + } + } + return nil +} + +func (x *PipelineRequest) GetZadd() *ZAddRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Zadd); ok { + return x.Zadd + } + } + return nil +} + +func (x *PipelineRequest) GetZrem() *ZRemRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Zrem); ok { + return x.Zrem + } + } + return nil +} + +func (x *PipelineRequest) GetZscore() *ZScoreRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Zscore); ok { + return x.Zscore + } + } + return nil +} + +func (x *PipelineRequest) GetZrank() *ZRankRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Zrank); ok { + return x.Zrank + } + } + return nil +} + +func (x *PipelineRequest) GetZcard() *ZCardRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Zcard); ok { + return x.Zcard + } + } + return nil +} + +func (x *PipelineRequest) GetZrange() *ZRangeRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Zrange); ok { + return x.Zrange + } + } + return nil +} + +func (x *PipelineRequest) GetVadd() *VAddRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Vadd); ok { + return x.Vadd + } + } + return nil +} + +func (x *PipelineRequest) GetVsim() *VSimRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Vsim); ok { + return x.Vsim + } + } + return nil +} + +func (x *PipelineRequest) GetVrem() *VRemRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Vrem); ok { + return x.Vrem + } + } + return nil +} + +func (x *PipelineRequest) GetVget() *VGetRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Vget); ok { + return x.Vget + } + } + return nil +} + +func (x *PipelineRequest) GetVcard() *VCardRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Vcard); ok { + return x.Vcard + } + } + return nil +} + +func (x *PipelineRequest) GetVdim() *VDimRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Vdim); ok { + return x.Vdim + } + } + return nil +} + +func (x *PipelineRequest) GetVinfo() *VInfoRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Vinfo); ok { + return x.Vinfo + } + } + return nil +} + +func (x *PipelineRequest) GetPing() *PingRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Ping); ok { + return x.Ping + } + } + return nil +} + +func (x *PipelineRequest) GetFlushdb() *FlushDbRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Flushdb); ok { + return x.Flushdb + } + } + return nil +} + +func (x *PipelineRequest) GetDbsize() *DbSizeRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Dbsize); ok { + return x.Dbsize + } + } + return nil +} + +func (x *PipelineRequest) GetMget() *MGetRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Mget); ok { + return x.Mget + } + } + return nil +} + +func (x *PipelineRequest) GetMset() *MSetRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Mset); ok { + return x.Mset + } + } + return nil +} + +func (x *PipelineRequest) GetKeys() *KeysRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Keys); ok { + return x.Keys + } + } + return nil +} + +func (x *PipelineRequest) GetRename() *RenameRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Rename); ok { + return x.Rename + } + } + return nil +} + +func (x *PipelineRequest) GetScan() *ScanRequest { + if x != nil { + if x, ok := x.Command.(*PipelineRequest_Scan); ok { + return x.Scan + } + } + return nil +} + +type isPipelineRequest_Command interface { + isPipelineRequest_Command() +} + +type PipelineRequest_Get struct { + Get *GetRequest `protobuf:"bytes,2,opt,name=get,proto3,oneof"` +} + +type PipelineRequest_Set struct { + Set *SetRequest `protobuf:"bytes,3,opt,name=set,proto3,oneof"` +} + +type PipelineRequest_Del struct { + Del *DelRequest `protobuf:"bytes,4,opt,name=del,proto3,oneof"` +} + +type PipelineRequest_Exists struct { + Exists *ExistsRequest `protobuf:"bytes,5,opt,name=exists,proto3,oneof"` +} + +type PipelineRequest_Incr struct { + Incr *IncrRequest `protobuf:"bytes,6,opt,name=incr,proto3,oneof"` +} + +type PipelineRequest_IncrBy struct { + IncrBy *IncrByRequest `protobuf:"bytes,7,opt,name=incr_by,json=incrBy,proto3,oneof"` +} + +type PipelineRequest_DecrBy struct { + DecrBy *DecrByRequest `protobuf:"bytes,8,opt,name=decr_by,json=decrBy,proto3,oneof"` +} + +type PipelineRequest_IncrByFloat struct { + IncrByFloat *IncrByFloatRequest `protobuf:"bytes,9,opt,name=incr_by_float,json=incrByFloat,proto3,oneof"` +} + +type PipelineRequest_Append struct { + Append *AppendRequest `protobuf:"bytes,10,opt,name=append,proto3,oneof"` +} + +type PipelineRequest_Strlen struct { + Strlen *StrlenRequest `protobuf:"bytes,11,opt,name=strlen,proto3,oneof"` +} + +type PipelineRequest_Expire struct { + Expire *ExpireRequest `protobuf:"bytes,12,opt,name=expire,proto3,oneof"` +} + +type PipelineRequest_Pexpire struct { + Pexpire *PExpireRequest `protobuf:"bytes,13,opt,name=pexpire,proto3,oneof"` +} + +type PipelineRequest_Persist struct { + Persist *PersistRequest `protobuf:"bytes,14,opt,name=persist,proto3,oneof"` +} + +type PipelineRequest_Ttl struct { + Ttl *TtlRequest `protobuf:"bytes,15,opt,name=ttl,proto3,oneof"` +} + +type PipelineRequest_Pttl struct { + Pttl *PTtlRequest `protobuf:"bytes,16,opt,name=pttl,proto3,oneof"` +} + +type PipelineRequest_Type struct { + Type *TypeRequest `protobuf:"bytes,17,opt,name=type,proto3,oneof"` +} + +type PipelineRequest_Lpush struct { + Lpush *LPushRequest `protobuf:"bytes,18,opt,name=lpush,proto3,oneof"` +} + +type PipelineRequest_Rpush struct { + Rpush *RPushRequest `protobuf:"bytes,19,opt,name=rpush,proto3,oneof"` +} + +type PipelineRequest_Lpop struct { + Lpop *LPopRequest `protobuf:"bytes,20,opt,name=lpop,proto3,oneof"` +} + +type PipelineRequest_Rpop struct { + Rpop *RPopRequest `protobuf:"bytes,21,opt,name=rpop,proto3,oneof"` +} + +type PipelineRequest_Lrange struct { + Lrange *LRangeRequest `protobuf:"bytes,22,opt,name=lrange,proto3,oneof"` +} + +type PipelineRequest_Llen struct { + Llen *LLenRequest `protobuf:"bytes,23,opt,name=llen,proto3,oneof"` +} + +type PipelineRequest_Hset struct { + Hset *HSetRequest `protobuf:"bytes,24,opt,name=hset,proto3,oneof"` +} + +type PipelineRequest_Hget struct { + Hget *HGetRequest `protobuf:"bytes,25,opt,name=hget,proto3,oneof"` +} + +type PipelineRequest_Hgetall struct { + Hgetall *HGetAllRequest `protobuf:"bytes,26,opt,name=hgetall,proto3,oneof"` +} + +type PipelineRequest_Hdel struct { + Hdel *HDelRequest `protobuf:"bytes,27,opt,name=hdel,proto3,oneof"` +} + +type PipelineRequest_Hexists struct { + Hexists *HExistsRequest `protobuf:"bytes,28,opt,name=hexists,proto3,oneof"` +} + +type PipelineRequest_Hlen struct { + Hlen *HLenRequest `protobuf:"bytes,29,opt,name=hlen,proto3,oneof"` +} + +type PipelineRequest_HincrBy struct { + HincrBy *HIncrByRequest `protobuf:"bytes,30,opt,name=hincr_by,json=hincrBy,proto3,oneof"` +} + +type PipelineRequest_Hkeys struct { + Hkeys *HKeysRequest `protobuf:"bytes,31,opt,name=hkeys,proto3,oneof"` +} + +type PipelineRequest_Hvals struct { + Hvals *HValsRequest `protobuf:"bytes,32,opt,name=hvals,proto3,oneof"` +} + +type PipelineRequest_Hmget struct { + Hmget *HMGetRequest `protobuf:"bytes,33,opt,name=hmget,proto3,oneof"` +} + +type PipelineRequest_Sadd struct { + Sadd *SAddRequest `protobuf:"bytes,34,opt,name=sadd,proto3,oneof"` +} + +type PipelineRequest_Srem struct { + Srem *SRemRequest `protobuf:"bytes,35,opt,name=srem,proto3,oneof"` +} + +type PipelineRequest_Smembers struct { + Smembers *SMembersRequest `protobuf:"bytes,36,opt,name=smembers,proto3,oneof"` +} + +type PipelineRequest_Sismember struct { + Sismember *SIsMemberRequest `protobuf:"bytes,37,opt,name=sismember,proto3,oneof"` +} + +type PipelineRequest_Scard struct { + Scard *SCardRequest `protobuf:"bytes,38,opt,name=scard,proto3,oneof"` +} + +type PipelineRequest_Zadd struct { + Zadd *ZAddRequest `protobuf:"bytes,39,opt,name=zadd,proto3,oneof"` +} + +type PipelineRequest_Zrem struct { + Zrem *ZRemRequest `protobuf:"bytes,40,opt,name=zrem,proto3,oneof"` +} + +type PipelineRequest_Zscore struct { + Zscore *ZScoreRequest `protobuf:"bytes,41,opt,name=zscore,proto3,oneof"` +} + +type PipelineRequest_Zrank struct { + Zrank *ZRankRequest `protobuf:"bytes,42,opt,name=zrank,proto3,oneof"` +} + +type PipelineRequest_Zcard struct { + Zcard *ZCardRequest `protobuf:"bytes,43,opt,name=zcard,proto3,oneof"` +} + +type PipelineRequest_Zrange struct { + Zrange *ZRangeRequest `protobuf:"bytes,44,opt,name=zrange,proto3,oneof"` +} + +type PipelineRequest_Vadd struct { + Vadd *VAddRequest `protobuf:"bytes,45,opt,name=vadd,proto3,oneof"` +} + +type PipelineRequest_Vsim struct { + Vsim *VSimRequest `protobuf:"bytes,46,opt,name=vsim,proto3,oneof"` +} + +type PipelineRequest_Vrem struct { + Vrem *VRemRequest `protobuf:"bytes,47,opt,name=vrem,proto3,oneof"` +} + +type PipelineRequest_Vget struct { + Vget *VGetRequest `protobuf:"bytes,48,opt,name=vget,proto3,oneof"` +} + +type PipelineRequest_Vcard struct { + Vcard *VCardRequest `protobuf:"bytes,49,opt,name=vcard,proto3,oneof"` +} + +type PipelineRequest_Vdim struct { + Vdim *VDimRequest `protobuf:"bytes,50,opt,name=vdim,proto3,oneof"` +} + +type PipelineRequest_Vinfo struct { + Vinfo *VInfoRequest `protobuf:"bytes,51,opt,name=vinfo,proto3,oneof"` +} + +type PipelineRequest_Ping struct { + Ping *PingRequest `protobuf:"bytes,52,opt,name=ping,proto3,oneof"` +} + +type PipelineRequest_Flushdb struct { + Flushdb *FlushDbRequest `protobuf:"bytes,53,opt,name=flushdb,proto3,oneof"` +} + +type PipelineRequest_Dbsize struct { + Dbsize *DbSizeRequest `protobuf:"bytes,54,opt,name=dbsize,proto3,oneof"` +} + +type PipelineRequest_Mget struct { + Mget *MGetRequest `protobuf:"bytes,55,opt,name=mget,proto3,oneof"` +} + +type PipelineRequest_Mset struct { + Mset *MSetRequest `protobuf:"bytes,56,opt,name=mset,proto3,oneof"` +} + +type PipelineRequest_Keys struct { + Keys *KeysRequest `protobuf:"bytes,57,opt,name=keys,proto3,oneof"` +} + +type PipelineRequest_Rename struct { + Rename *RenameRequest `protobuf:"bytes,58,opt,name=rename,proto3,oneof"` +} + +type PipelineRequest_Scan struct { + Scan *ScanRequest `protobuf:"bytes,59,opt,name=scan,proto3,oneof"` +} + +func (*PipelineRequest_Get) isPipelineRequest_Command() {} + +func (*PipelineRequest_Set) isPipelineRequest_Command() {} + +func (*PipelineRequest_Del) isPipelineRequest_Command() {} + +func (*PipelineRequest_Exists) isPipelineRequest_Command() {} + +func (*PipelineRequest_Incr) isPipelineRequest_Command() {} + +func (*PipelineRequest_IncrBy) isPipelineRequest_Command() {} + +func (*PipelineRequest_DecrBy) isPipelineRequest_Command() {} + +func (*PipelineRequest_IncrByFloat) isPipelineRequest_Command() {} + +func (*PipelineRequest_Append) isPipelineRequest_Command() {} + +func (*PipelineRequest_Strlen) isPipelineRequest_Command() {} + +func (*PipelineRequest_Expire) isPipelineRequest_Command() {} + +func (*PipelineRequest_Pexpire) isPipelineRequest_Command() {} + +func (*PipelineRequest_Persist) isPipelineRequest_Command() {} + +func (*PipelineRequest_Ttl) isPipelineRequest_Command() {} + +func (*PipelineRequest_Pttl) isPipelineRequest_Command() {} + +func (*PipelineRequest_Type) isPipelineRequest_Command() {} + +func (*PipelineRequest_Lpush) isPipelineRequest_Command() {} + +func (*PipelineRequest_Rpush) isPipelineRequest_Command() {} + +func (*PipelineRequest_Lpop) isPipelineRequest_Command() {} + +func (*PipelineRequest_Rpop) isPipelineRequest_Command() {} + +func (*PipelineRequest_Lrange) isPipelineRequest_Command() {} + +func (*PipelineRequest_Llen) isPipelineRequest_Command() {} + +func (*PipelineRequest_Hset) isPipelineRequest_Command() {} + +func (*PipelineRequest_Hget) isPipelineRequest_Command() {} + +func (*PipelineRequest_Hgetall) isPipelineRequest_Command() {} + +func (*PipelineRequest_Hdel) isPipelineRequest_Command() {} + +func (*PipelineRequest_Hexists) isPipelineRequest_Command() {} + +func (*PipelineRequest_Hlen) isPipelineRequest_Command() {} + +func (*PipelineRequest_HincrBy) isPipelineRequest_Command() {} + +func (*PipelineRequest_Hkeys) isPipelineRequest_Command() {} + +func (*PipelineRequest_Hvals) isPipelineRequest_Command() {} + +func (*PipelineRequest_Hmget) isPipelineRequest_Command() {} + +func (*PipelineRequest_Sadd) isPipelineRequest_Command() {} + +func (*PipelineRequest_Srem) isPipelineRequest_Command() {} + +func (*PipelineRequest_Smembers) isPipelineRequest_Command() {} + +func (*PipelineRequest_Sismember) isPipelineRequest_Command() {} + +func (*PipelineRequest_Scard) isPipelineRequest_Command() {} + +func (*PipelineRequest_Zadd) isPipelineRequest_Command() {} + +func (*PipelineRequest_Zrem) isPipelineRequest_Command() {} + +func (*PipelineRequest_Zscore) isPipelineRequest_Command() {} + +func (*PipelineRequest_Zrank) isPipelineRequest_Command() {} + +func (*PipelineRequest_Zcard) isPipelineRequest_Command() {} + +func (*PipelineRequest_Zrange) isPipelineRequest_Command() {} + +func (*PipelineRequest_Vadd) isPipelineRequest_Command() {} + +func (*PipelineRequest_Vsim) isPipelineRequest_Command() {} + +func (*PipelineRequest_Vrem) isPipelineRequest_Command() {} + +func (*PipelineRequest_Vget) isPipelineRequest_Command() {} + +func (*PipelineRequest_Vcard) isPipelineRequest_Command() {} + +func (*PipelineRequest_Vdim) isPipelineRequest_Command() {} + +func (*PipelineRequest_Vinfo) isPipelineRequest_Command() {} + +func (*PipelineRequest_Ping) isPipelineRequest_Command() {} + +func (*PipelineRequest_Flushdb) isPipelineRequest_Command() {} + +func (*PipelineRequest_Dbsize) isPipelineRequest_Command() {} + +func (*PipelineRequest_Mget) isPipelineRequest_Command() {} + +func (*PipelineRequest_Mset) isPipelineRequest_Command() {} + +func (*PipelineRequest_Keys) isPipelineRequest_Command() {} + +func (*PipelineRequest_Rename) isPipelineRequest_Command() {} + +func (*PipelineRequest_Scan) isPipelineRequest_Command() {} + +type PipelineResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + // Types that are valid to be assigned to Result: + // + // *PipelineResponse_Get + // *PipelineResponse_Set + // *PipelineResponse_Del + // *PipelineResponse_IntVal + // *PipelineResponse_BoolVal + // *PipelineResponse_FloatVal + // *PipelineResponse_Status + // *PipelineResponse_Ttl + // *PipelineResponse_Type + // *PipelineResponse_Array + // *PipelineResponse_Hash + // *PipelineResponse_OptionalArray + // *PipelineResponse_Keys + // *PipelineResponse_Scan + // *PipelineResponse_OptionalFloat + // *PipelineResponse_OptionalInt + // *PipelineResponse_Zrange + // *PipelineResponse_Vsim + // *PipelineResponse_Vget + // *PipelineResponse_Vinfo + // *PipelineResponse_Mget + // *PipelineResponse_Mset + // *PipelineResponse_Ping + // *PipelineResponse_Error + // *PipelineResponse_Info + Result isPipelineResponse_Result `protobuf_oneof:"result"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PipelineResponse) Reset() { + *x = PipelineResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[89] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PipelineResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PipelineResponse) ProtoMessage() {} + +func (x *PipelineResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[89] + 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 PipelineResponse.ProtoReflect.Descriptor instead. +func (*PipelineResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{89} +} + +func (x *PipelineResponse) GetId() uint64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *PipelineResponse) GetResult() isPipelineResponse_Result { + if x != nil { + return x.Result + } + return nil +} + +func (x *PipelineResponse) GetGet() *GetResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Get); ok { + return x.Get + } + } + return nil +} + +func (x *PipelineResponse) GetSet() *SetResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Set); ok { + return x.Set + } + } + return nil +} + +func (x *PipelineResponse) GetDel() *DelResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Del); ok { + return x.Del + } + } + return nil +} + +func (x *PipelineResponse) GetIntVal() *IntResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_IntVal); ok { + return x.IntVal + } + } + return nil +} + +func (x *PipelineResponse) GetBoolVal() *BoolResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_BoolVal); ok { + return x.BoolVal + } + } + return nil +} + +func (x *PipelineResponse) GetFloatVal() *FloatResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_FloatVal); ok { + return x.FloatVal + } + } + return nil +} + +func (x *PipelineResponse) GetStatus() *StatusResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Status); ok { + return x.Status + } + } + return nil +} + +func (x *PipelineResponse) GetTtl() *TtlResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Ttl); ok { + return x.Ttl + } + } + return nil +} + +func (x *PipelineResponse) GetType() *TypeResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Type); ok { + return x.Type + } + } + return nil +} + +func (x *PipelineResponse) GetArray() *ArrayResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Array); ok { + return x.Array + } + } + return nil +} + +func (x *PipelineResponse) GetHash() *HashResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Hash); ok { + return x.Hash + } + } + return nil +} + +func (x *PipelineResponse) GetOptionalArray() *OptionalArrayResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_OptionalArray); ok { + return x.OptionalArray + } + } + return nil +} + +func (x *PipelineResponse) GetKeys() *KeysResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Keys); ok { + return x.Keys + } + } + return nil +} + +func (x *PipelineResponse) GetScan() *ScanResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Scan); ok { + return x.Scan + } + } + return nil +} + +func (x *PipelineResponse) GetOptionalFloat() *OptionalFloatResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_OptionalFloat); ok { + return x.OptionalFloat + } + } + return nil +} + +func (x *PipelineResponse) GetOptionalInt() *OptionalIntResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_OptionalInt); ok { + return x.OptionalInt + } + } + return nil +} + +func (x *PipelineResponse) GetZrange() *ZRangeResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Zrange); ok { + return x.Zrange + } + } + return nil +} + +func (x *PipelineResponse) GetVsim() *VSimResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Vsim); ok { + return x.Vsim + } + } + return nil +} + +func (x *PipelineResponse) GetVget() *VGetResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Vget); ok { + return x.Vget + } + } + return nil +} + +func (x *PipelineResponse) GetVinfo() *VInfoResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Vinfo); ok { + return x.Vinfo + } + } + return nil +} + +func (x *PipelineResponse) GetMget() *MGetResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Mget); ok { + return x.Mget + } + } + return nil +} + +func (x *PipelineResponse) GetMset() *MSetResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Mset); ok { + return x.Mset + } + } + return nil +} + +func (x *PipelineResponse) GetPing() *PingResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Ping); ok { + return x.Ping + } + } + return nil +} + +func (x *PipelineResponse) GetError() *ErrorResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Error); ok { + return x.Error + } + } + return nil +} + +func (x *PipelineResponse) GetInfo() *InfoResponse { + if x != nil { + if x, ok := x.Result.(*PipelineResponse_Info); ok { + return x.Info + } + } + return nil +} + +type isPipelineResponse_Result interface { + isPipelineResponse_Result() +} + +type PipelineResponse_Get struct { + Get *GetResponse `protobuf:"bytes,2,opt,name=get,proto3,oneof"` +} + +type PipelineResponse_Set struct { + Set *SetResponse `protobuf:"bytes,3,opt,name=set,proto3,oneof"` +} + +type PipelineResponse_Del struct { + Del *DelResponse `protobuf:"bytes,4,opt,name=del,proto3,oneof"` +} + +type PipelineResponse_IntVal struct { + IntVal *IntResponse `protobuf:"bytes,5,opt,name=int_val,json=intVal,proto3,oneof"` +} + +type PipelineResponse_BoolVal struct { + BoolVal *BoolResponse `protobuf:"bytes,6,opt,name=bool_val,json=boolVal,proto3,oneof"` +} + +type PipelineResponse_FloatVal struct { + FloatVal *FloatResponse `protobuf:"bytes,7,opt,name=float_val,json=floatVal,proto3,oneof"` +} + +type PipelineResponse_Status struct { + Status *StatusResponse `protobuf:"bytes,8,opt,name=status,proto3,oneof"` +} + +type PipelineResponse_Ttl struct { + Ttl *TtlResponse `protobuf:"bytes,9,opt,name=ttl,proto3,oneof"` +} + +type PipelineResponse_Type struct { + Type *TypeResponse `protobuf:"bytes,10,opt,name=type,proto3,oneof"` +} + +type PipelineResponse_Array struct { + Array *ArrayResponse `protobuf:"bytes,11,opt,name=array,proto3,oneof"` +} + +type PipelineResponse_Hash struct { + Hash *HashResponse `protobuf:"bytes,12,opt,name=hash,proto3,oneof"` +} + +type PipelineResponse_OptionalArray struct { + OptionalArray *OptionalArrayResponse `protobuf:"bytes,13,opt,name=optional_array,json=optionalArray,proto3,oneof"` +} + +type PipelineResponse_Keys struct { + Keys *KeysResponse `protobuf:"bytes,14,opt,name=keys,proto3,oneof"` +} + +type PipelineResponse_Scan struct { + Scan *ScanResponse `protobuf:"bytes,15,opt,name=scan,proto3,oneof"` +} + +type PipelineResponse_OptionalFloat struct { + OptionalFloat *OptionalFloatResponse `protobuf:"bytes,16,opt,name=optional_float,json=optionalFloat,proto3,oneof"` +} + +type PipelineResponse_OptionalInt struct { + OptionalInt *OptionalIntResponse `protobuf:"bytes,17,opt,name=optional_int,json=optionalInt,proto3,oneof"` +} + +type PipelineResponse_Zrange struct { + Zrange *ZRangeResponse `protobuf:"bytes,18,opt,name=zrange,proto3,oneof"` +} + +type PipelineResponse_Vsim struct { + Vsim *VSimResponse `protobuf:"bytes,19,opt,name=vsim,proto3,oneof"` +} + +type PipelineResponse_Vget struct { + Vget *VGetResponse `protobuf:"bytes,20,opt,name=vget,proto3,oneof"` +} + +type PipelineResponse_Vinfo struct { + Vinfo *VInfoResponse `protobuf:"bytes,21,opt,name=vinfo,proto3,oneof"` +} + +type PipelineResponse_Mget struct { + Mget *MGetResponse `protobuf:"bytes,22,opt,name=mget,proto3,oneof"` +} + +type PipelineResponse_Mset struct { + Mset *MSetResponse `protobuf:"bytes,23,opt,name=mset,proto3,oneof"` +} + +type PipelineResponse_Ping struct { + Ping *PingResponse `protobuf:"bytes,24,opt,name=ping,proto3,oneof"` +} + +type PipelineResponse_Error struct { + Error *ErrorResponse `protobuf:"bytes,25,opt,name=error,proto3,oneof"` +} + +type PipelineResponse_Info struct { + Info *InfoResponse `protobuf:"bytes,26,opt,name=info,proto3,oneof"` +} + +func (*PipelineResponse_Get) isPipelineResponse_Result() {} + +func (*PipelineResponse_Set) isPipelineResponse_Result() {} + +func (*PipelineResponse_Del) isPipelineResponse_Result() {} + +func (*PipelineResponse_IntVal) isPipelineResponse_Result() {} + +func (*PipelineResponse_BoolVal) isPipelineResponse_Result() {} + +func (*PipelineResponse_FloatVal) isPipelineResponse_Result() {} + +func (*PipelineResponse_Status) isPipelineResponse_Result() {} + +func (*PipelineResponse_Ttl) isPipelineResponse_Result() {} + +func (*PipelineResponse_Type) isPipelineResponse_Result() {} + +func (*PipelineResponse_Array) isPipelineResponse_Result() {} + +func (*PipelineResponse_Hash) isPipelineResponse_Result() {} + +func (*PipelineResponse_OptionalArray) isPipelineResponse_Result() {} + +func (*PipelineResponse_Keys) isPipelineResponse_Result() {} + +func (*PipelineResponse_Scan) isPipelineResponse_Result() {} + +func (*PipelineResponse_OptionalFloat) isPipelineResponse_Result() {} + +func (*PipelineResponse_OptionalInt) isPipelineResponse_Result() {} + +func (*PipelineResponse_Zrange) isPipelineResponse_Result() {} + +func (*PipelineResponse_Vsim) isPipelineResponse_Result() {} + +func (*PipelineResponse_Vget) isPipelineResponse_Result() {} + +func (*PipelineResponse_Vinfo) isPipelineResponse_Result() {} + +func (*PipelineResponse_Mget) isPipelineResponse_Result() {} + +func (*PipelineResponse_Mset) isPipelineResponse_Result() {} + +func (*PipelineResponse_Ping) isPipelineResponse_Result() {} + +func (*PipelineResponse_Error) isPipelineResponse_Result() {} + +func (*PipelineResponse_Info) isPipelineResponse_Result() {} + +type ErrorResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + Kind ErrorKind `protobuf:"varint,2,opt,name=kind,proto3,enum=ember.v1.ErrorKind" json:"kind,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ErrorResponse) Reset() { + *x = ErrorResponse{} + mi := &file_ember_v1_ember_proto_msgTypes[90] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ErrorResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ErrorResponse) ProtoMessage() {} + +func (x *ErrorResponse) ProtoReflect() protoreflect.Message { + mi := &file_ember_v1_ember_proto_msgTypes[90] + 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 ErrorResponse.ProtoReflect.Descriptor instead. +func (*ErrorResponse) Descriptor() ([]byte, []int) { + return file_ember_v1_ember_proto_rawDescGZIP(), []int{90} +} + +func (x *ErrorResponse) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *ErrorResponse) GetKind() ErrorKind { + if x != nil { + return x.Kind + } + return ErrorKind_ERROR_KIND_UNSPECIFIED +} + +var File_ember_v1_ember_proto protoreflect.FileDescriptor + +const file_ember_v1_ember_proto_rawDesc = "" + + "\n" + + "\x14ember/v1/ember.proto\x12\bember.v1\"#\n" + + "\vIntResponse\x12\x14\n" + + "\x05value\x18\x01 \x01(\x03R\x05value\"$\n" + + "\fBoolResponse\x12\x14\n" + + "\x05value\x18\x01 \x01(\bR\x05value\"%\n" + + "\rFloatResponse\x12\x14\n" + + "\x05value\x18\x01 \x01(\tR\x05value\"(\n" + + "\x0eStatusResponse\x12\x16\n" + + "\x06status\x18\x01 \x01(\tR\x06status\"\x1e\n" + + "\n" + + "GetRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"2\n" + + "\vGetResponse\x12\x19\n" + + "\x05value\x18\x01 \x01(\fH\x00R\x05value\x88\x01\x01B\b\n" + + "\x06_value\"\xa0\x01\n" + + "\n" + + "SetRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\fR\x05value\x12%\n" + + "\x0eexpire_seconds\x18\x03 \x01(\x04R\rexpireSeconds\x12#\n" + + "\rexpire_millis\x18\x04 \x01(\x04R\fexpireMillis\x12\x0e\n" + + "\x02nx\x18\x05 \x01(\bR\x02nx\x12\x0e\n" + + "\x02xx\x18\x06 \x01(\bR\x02xx\"\x1d\n" + + "\vSetResponse\x12\x0e\n" + + "\x02ok\x18\x01 \x01(\bR\x02ok\" \n" + + "\n" + + "DelRequest\x12\x12\n" + + "\x04keys\x18\x01 \x03(\tR\x04keys\"'\n" + + "\vDelResponse\x12\x18\n" + + "\adeleted\x18\x01 \x01(\x03R\adeleted\"!\n" + + "\vMGetRequest\x12\x12\n" + + "\x04keys\x18\x01 \x03(\tR\x04keys\"?\n" + + "\fMGetResponse\x12/\n" + + "\x06values\x18\x01 \x03(\v2\x17.ember.v1.OptionalValueR\x06values\"4\n" + + "\rOptionalValue\x12\x19\n" + + "\x05value\x18\x01 \x01(\fH\x00R\x05value\x88\x01\x01B\b\n" + + "\x06_value\"7\n" + + "\vMSetRequest\x12(\n" + + "\x05pairs\x18\x01 \x03(\v2\x12.ember.v1.KeyValueR\x05pairs\"2\n" + + "\bKeyValue\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\fR\x05value\"\x0e\n" + + "\fMSetResponse\"\x1f\n" + + "\vIncrRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"7\n" + + "\rIncrByRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05delta\x18\x02 \x01(\x03R\x05delta\"7\n" + + "\rDecrByRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05delta\x18\x02 \x01(\x03R\x05delta\"<\n" + + "\x12IncrByFloatRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05delta\x18\x02 \x01(\x01R\x05delta\"7\n" + + "\rAppendRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\fR\x05value\"!\n" + + "\rStrlenRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"#\n" + + "\rExistsRequest\x12\x12\n" + + "\x04keys\x18\x01 \x03(\tR\x04keys\";\n" + + "\rExpireRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x18\n" + + "\aseconds\x18\x02 \x01(\x04R\aseconds\"F\n" + + "\x0ePExpireRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\"\n" + + "\fmilliseconds\x18\x02 \x01(\x04R\fmilliseconds\"\"\n" + + "\x0ePersistRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"\x1e\n" + + "\n" + + "TtlRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"\x1f\n" + + "\vPTtlRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"#\n" + + "\vTtlResponse\x12\x14\n" + + "\x05value\x18\x01 \x01(\x03R\x05value\"\x1f\n" + + "\vTypeRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"+\n" + + "\fTypeResponse\x12\x1b\n" + + "\ttype_name\x18\x01 \x01(\tR\btypeName\"'\n" + + "\vKeysRequest\x12\x18\n" + + "\apattern\x18\x01 \x01(\tR\apattern\"\"\n" + + "\fKeysResponse\x12\x12\n" + + "\x04keys\x18\x01 \x03(\tR\x04keys\":\n" + + "\rRenameRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x17\n" + + "\anew_key\x18\x02 \x01(\tR\x06newKey\"f\n" + + "\vScanRequest\x12\x16\n" + + "\x06cursor\x18\x01 \x01(\x04R\x06cursor\x12\x14\n" + + "\x05count\x18\x02 \x01(\rR\x05count\x12\x1d\n" + + "\apattern\x18\x03 \x01(\tH\x00R\apattern\x88\x01\x01B\n" + + "\n" + + "\b_pattern\":\n" + + "\fScanResponse\x12\x16\n" + + "\x06cursor\x18\x01 \x01(\x04R\x06cursor\x12\x12\n" + + "\x04keys\x18\x02 \x03(\tR\x04keys\"8\n" + + "\fLPushRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x16\n" + + "\x06values\x18\x02 \x03(\fR\x06values\"8\n" + + "\fRPushRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x16\n" + + "\x06values\x18\x02 \x03(\fR\x06values\"\x1f\n" + + "\vLPopRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"\x1f\n" + + "\vRPopRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"K\n" + + "\rLRangeRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05start\x18\x02 \x01(\x03R\x05start\x12\x12\n" + + "\x04stop\x18\x03 \x01(\x03R\x04stop\"'\n" + + "\rArrayResponse\x12\x16\n" + + "\x06values\x18\x01 \x03(\fR\x06values\"\x1f\n" + + "\vLLenRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"M\n" + + "\vHSetRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12,\n" + + "\x06fields\x18\x02 \x03(\v2\x14.ember.v1.FieldValueR\x06fields\"8\n" + + "\n" + + "FieldValue\x12\x14\n" + + "\x05field\x18\x01 \x01(\tR\x05field\x12\x14\n" + + "\x05value\x18\x02 \x01(\fR\x05value\"5\n" + + "\vHGetRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05field\x18\x02 \x01(\tR\x05field\"\"\n" + + "\x0eHGetAllRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"<\n" + + "\fHashResponse\x12,\n" + + "\x06fields\x18\x01 \x03(\v2\x14.ember.v1.FieldValueR\x06fields\"7\n" + + "\vHDelRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x16\n" + + "\x06fields\x18\x02 \x03(\tR\x06fields\"8\n" + + "\x0eHExistsRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05field\x18\x02 \x01(\tR\x05field\"\x1f\n" + + "\vHLenRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"N\n" + + "\x0eHIncrByRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05field\x18\x02 \x01(\tR\x05field\x12\x14\n" + + "\x05delta\x18\x03 \x01(\x03R\x05delta\" \n" + + "\fHKeysRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\" \n" + + "\fHValsRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"8\n" + + "\fHMGetRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x16\n" + + "\x06fields\x18\x02 \x03(\tR\x06fields\"H\n" + + "\x15OptionalArrayResponse\x12/\n" + + "\x06values\x18\x01 \x03(\v2\x17.ember.v1.OptionalValueR\x06values\"9\n" + + "\vSAddRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x18\n" + + "\amembers\x18\x02 \x03(\tR\amembers\"9\n" + + "\vSRemRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x18\n" + + "\amembers\x18\x02 \x03(\tR\amembers\"#\n" + + "\x0fSMembersRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"<\n" + + "\x10SIsMemberRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x16\n" + + "\x06member\x18\x02 \x01(\tR\x06member\" \n" + + "\fSCardRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"\xa0\x01\n" + + "\vZAddRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12/\n" + + "\amembers\x18\x02 \x03(\v2\x15.ember.v1.ScoreMemberR\amembers\x12\x0e\n" + + "\x02nx\x18\x03 \x01(\bR\x02nx\x12\x0e\n" + + "\x02xx\x18\x04 \x01(\bR\x02xx\x12\x0e\n" + + "\x02gt\x18\x05 \x01(\bR\x02gt\x12\x0e\n" + + "\x02lt\x18\x06 \x01(\bR\x02lt\x12\x0e\n" + + "\x02ch\x18\a \x01(\bR\x02ch\";\n" + + "\vScoreMember\x12\x14\n" + + "\x05score\x18\x01 \x01(\x01R\x05score\x12\x16\n" + + "\x06member\x18\x02 \x01(\tR\x06member\"9\n" + + "\vZRemRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x18\n" + + "\amembers\x18\x02 \x03(\tR\amembers\"9\n" + + "\rZScoreRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x16\n" + + "\x06member\x18\x02 \x01(\tR\x06member\"<\n" + + "\x15OptionalFloatResponse\x12\x19\n" + + "\x05value\x18\x01 \x01(\x01H\x00R\x05value\x88\x01\x01B\b\n" + + "\x06_value\"8\n" + + "\fZRankRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x16\n" + + "\x06member\x18\x02 \x01(\tR\x06member\":\n" + + "\x13OptionalIntResponse\x12\x19\n" + + "\x05value\x18\x01 \x01(\x03H\x00R\x05value\x88\x01\x01B\b\n" + + "\x06_value\" \n" + + "\fZCardRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"l\n" + + "\rZRangeRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05start\x18\x02 \x01(\x03R\x05start\x12\x12\n" + + "\x04stop\x18\x03 \x01(\x03R\x04stop\x12\x1f\n" + + "\vwith_scores\x18\x04 \x01(\bR\n" + + "withScores\"A\n" + + "\x0eZRangeResponse\x12/\n" + + "\amembers\x18\x01 \x03(\v2\x15.ember.v1.ScoreMemberR\amembers\"\xc3\x02\n" + + "\vVAddRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x18\n" + + "\aelement\x18\x02 \x01(\tR\aelement\x12\x1a\n" + + "\x06vector\x18\x03 \x03(\x02B\x02\x10\x01R\x06vector\x12.\n" + + "\x06metric\x18\x04 \x01(\x0e2\x16.ember.v1.VectorMetricR\x06metric\x12@\n" + + "\fquantization\x18\x05 \x01(\x0e2\x1c.ember.v1.VectorQuantizationR\fquantization\x12'\n" + + "\fconnectivity\x18\x06 \x01(\rH\x00R\fconnectivity\x88\x01\x01\x12,\n" + + "\x0fef_construction\x18\a \x01(\rH\x01R\x0eefConstruction\x88\x01\x01B\x0f\n" + + "\r_connectivityB\x12\n" + + "\x10_ef_construction\"\x7f\n" + + "\vVSimRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x18\n" + + "\x05query\x18\x02 \x03(\x02B\x02\x10\x01R\x05query\x12\x14\n" + + "\x05count\x18\x03 \x01(\rR\x05count\x12 \n" + + "\tef_search\x18\x04 \x01(\rH\x00R\befSearch\x88\x01\x01B\f\n" + + "\n" + + "_ef_search\">\n" + + "\fVSimResponse\x12.\n" + + "\aresults\x18\x01 \x03(\v2\x14.ember.v1.VSimResultR\aresults\"B\n" + + "\n" + + "VSimResult\x12\x18\n" + + "\aelement\x18\x01 \x01(\tR\aelement\x12\x1a\n" + + "\bdistance\x18\x02 \x01(\x02R\bdistance\"9\n" + + "\vVRemRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x18\n" + + "\aelement\x18\x02 \x01(\tR\aelement\"9\n" + + "\vVGetRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x18\n" + + "\aelement\x18\x02 \x01(\tR\aelement\"R\n" + + "\fVGetResponse\x12\x1b\n" + + "\x06exists\x18\x01 \x01(\bH\x00R\x06exists\x88\x01\x01\x12\x1a\n" + + "\x06vector\x18\x02 \x03(\x02B\x02\x10\x01R\x06vectorB\t\n" + + "\a_exists\" \n" + + "\fVCardRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"\x1f\n" + + "\vVDimRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\" \n" + + "\fVInfoRequest\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\"Q\n" + + "\rVInfoResponse\x12\x16\n" + + "\x06exists\x18\x01 \x01(\bR\x06exists\x12(\n" + + "\x04info\x18\x02 \x03(\v2\x14.ember.v1.FieldValueR\x04info\"8\n" + + "\vPingRequest\x12\x1d\n" + + "\amessage\x18\x01 \x01(\tH\x00R\amessage\x88\x01\x01B\n" + + "\n" + + "\b_message\"(\n" + + "\fPingResponse\x12\x18\n" + + "\amessage\x18\x01 \x01(\tR\amessage\"&\n" + + "\x0eFlushDbRequest\x12\x14\n" + + "\x05async\x18\x01 \x01(\bR\x05async\"\x0f\n" + + "\rDbSizeRequest\"8\n" + + "\vInfoRequest\x12\x1d\n" + + "\asection\x18\x01 \x01(\tH\x00R\asection\x88\x01\x01B\n" + + "\n" + + "\b_section\"\"\n" + + "\fInfoResponse\x12\x12\n" + + "\x04info\x18\x01 \x01(\tR\x04info\"\x9d\x16\n" + + "\x0fPipelineRequest\x12\x0e\n" + + "\x02id\x18\x01 \x01(\x04R\x02id\x12(\n" + + "\x03get\x18\x02 \x01(\v2\x14.ember.v1.GetRequestH\x00R\x03get\x12(\n" + + "\x03set\x18\x03 \x01(\v2\x14.ember.v1.SetRequestH\x00R\x03set\x12(\n" + + "\x03del\x18\x04 \x01(\v2\x14.ember.v1.DelRequestH\x00R\x03del\x121\n" + + "\x06exists\x18\x05 \x01(\v2\x17.ember.v1.ExistsRequestH\x00R\x06exists\x12+\n" + + "\x04incr\x18\x06 \x01(\v2\x15.ember.v1.IncrRequestH\x00R\x04incr\x122\n" + + "\aincr_by\x18\a \x01(\v2\x17.ember.v1.IncrByRequestH\x00R\x06incrBy\x122\n" + + "\adecr_by\x18\b \x01(\v2\x17.ember.v1.DecrByRequestH\x00R\x06decrBy\x12B\n" + + "\rincr_by_float\x18\t \x01(\v2\x1c.ember.v1.IncrByFloatRequestH\x00R\vincrByFloat\x121\n" + + "\x06append\x18\n" + + " \x01(\v2\x17.ember.v1.AppendRequestH\x00R\x06append\x121\n" + + "\x06strlen\x18\v \x01(\v2\x17.ember.v1.StrlenRequestH\x00R\x06strlen\x121\n" + + "\x06expire\x18\f \x01(\v2\x17.ember.v1.ExpireRequestH\x00R\x06expire\x124\n" + + "\apexpire\x18\r \x01(\v2\x18.ember.v1.PExpireRequestH\x00R\apexpire\x124\n" + + "\apersist\x18\x0e \x01(\v2\x18.ember.v1.PersistRequestH\x00R\apersist\x12(\n" + + "\x03ttl\x18\x0f \x01(\v2\x14.ember.v1.TtlRequestH\x00R\x03ttl\x12+\n" + + "\x04pttl\x18\x10 \x01(\v2\x15.ember.v1.PTtlRequestH\x00R\x04pttl\x12+\n" + + "\x04type\x18\x11 \x01(\v2\x15.ember.v1.TypeRequestH\x00R\x04type\x12.\n" + + "\x05lpush\x18\x12 \x01(\v2\x16.ember.v1.LPushRequestH\x00R\x05lpush\x12.\n" + + "\x05rpush\x18\x13 \x01(\v2\x16.ember.v1.RPushRequestH\x00R\x05rpush\x12+\n" + + "\x04lpop\x18\x14 \x01(\v2\x15.ember.v1.LPopRequestH\x00R\x04lpop\x12+\n" + + "\x04rpop\x18\x15 \x01(\v2\x15.ember.v1.RPopRequestH\x00R\x04rpop\x121\n" + + "\x06lrange\x18\x16 \x01(\v2\x17.ember.v1.LRangeRequestH\x00R\x06lrange\x12+\n" + + "\x04llen\x18\x17 \x01(\v2\x15.ember.v1.LLenRequestH\x00R\x04llen\x12+\n" + + "\x04hset\x18\x18 \x01(\v2\x15.ember.v1.HSetRequestH\x00R\x04hset\x12+\n" + + "\x04hget\x18\x19 \x01(\v2\x15.ember.v1.HGetRequestH\x00R\x04hget\x124\n" + + "\ahgetall\x18\x1a \x01(\v2\x18.ember.v1.HGetAllRequestH\x00R\ahgetall\x12+\n" + + "\x04hdel\x18\x1b \x01(\v2\x15.ember.v1.HDelRequestH\x00R\x04hdel\x124\n" + + "\ahexists\x18\x1c \x01(\v2\x18.ember.v1.HExistsRequestH\x00R\ahexists\x12+\n" + + "\x04hlen\x18\x1d \x01(\v2\x15.ember.v1.HLenRequestH\x00R\x04hlen\x125\n" + + "\bhincr_by\x18\x1e \x01(\v2\x18.ember.v1.HIncrByRequestH\x00R\ahincrBy\x12.\n" + + "\x05hkeys\x18\x1f \x01(\v2\x16.ember.v1.HKeysRequestH\x00R\x05hkeys\x12.\n" + + "\x05hvals\x18 \x01(\v2\x16.ember.v1.HValsRequestH\x00R\x05hvals\x12.\n" + + "\x05hmget\x18! \x01(\v2\x16.ember.v1.HMGetRequestH\x00R\x05hmget\x12+\n" + + "\x04sadd\x18\" \x01(\v2\x15.ember.v1.SAddRequestH\x00R\x04sadd\x12+\n" + + "\x04srem\x18# \x01(\v2\x15.ember.v1.SRemRequestH\x00R\x04srem\x127\n" + + "\bsmembers\x18$ \x01(\v2\x19.ember.v1.SMembersRequestH\x00R\bsmembers\x12:\n" + + "\tsismember\x18% \x01(\v2\x1a.ember.v1.SIsMemberRequestH\x00R\tsismember\x12.\n" + + "\x05scard\x18& \x01(\v2\x16.ember.v1.SCardRequestH\x00R\x05scard\x12+\n" + + "\x04zadd\x18' \x01(\v2\x15.ember.v1.ZAddRequestH\x00R\x04zadd\x12+\n" + + "\x04zrem\x18( \x01(\v2\x15.ember.v1.ZRemRequestH\x00R\x04zrem\x121\n" + + "\x06zscore\x18) \x01(\v2\x17.ember.v1.ZScoreRequestH\x00R\x06zscore\x12.\n" + + "\x05zrank\x18* \x01(\v2\x16.ember.v1.ZRankRequestH\x00R\x05zrank\x12.\n" + + "\x05zcard\x18+ \x01(\v2\x16.ember.v1.ZCardRequestH\x00R\x05zcard\x121\n" + + "\x06zrange\x18, \x01(\v2\x17.ember.v1.ZRangeRequestH\x00R\x06zrange\x12+\n" + + "\x04vadd\x18- \x01(\v2\x15.ember.v1.VAddRequestH\x00R\x04vadd\x12+\n" + + "\x04vsim\x18. \x01(\v2\x15.ember.v1.VSimRequestH\x00R\x04vsim\x12+\n" + + "\x04vrem\x18/ \x01(\v2\x15.ember.v1.VRemRequestH\x00R\x04vrem\x12+\n" + + "\x04vget\x180 \x01(\v2\x15.ember.v1.VGetRequestH\x00R\x04vget\x12.\n" + + "\x05vcard\x181 \x01(\v2\x16.ember.v1.VCardRequestH\x00R\x05vcard\x12+\n" + + "\x04vdim\x182 \x01(\v2\x15.ember.v1.VDimRequestH\x00R\x04vdim\x12.\n" + + "\x05vinfo\x183 \x01(\v2\x16.ember.v1.VInfoRequestH\x00R\x05vinfo\x12+\n" + + "\x04ping\x184 \x01(\v2\x15.ember.v1.PingRequestH\x00R\x04ping\x124\n" + + "\aflushdb\x185 \x01(\v2\x18.ember.v1.FlushDbRequestH\x00R\aflushdb\x121\n" + + "\x06dbsize\x186 \x01(\v2\x17.ember.v1.DbSizeRequestH\x00R\x06dbsize\x12+\n" + + "\x04mget\x187 \x01(\v2\x15.ember.v1.MGetRequestH\x00R\x04mget\x12+\n" + + "\x04mset\x188 \x01(\v2\x15.ember.v1.MSetRequestH\x00R\x04mset\x12+\n" + + "\x04keys\x189 \x01(\v2\x15.ember.v1.KeysRequestH\x00R\x04keys\x121\n" + + "\x06rename\x18: \x01(\v2\x17.ember.v1.RenameRequestH\x00R\x06rename\x12+\n" + + "\x04scan\x18; \x01(\v2\x15.ember.v1.ScanRequestH\x00R\x04scanB\t\n" + + "\acommand\"\x96\n" + + "\n" + + "\x10PipelineResponse\x12\x0e\n" + + "\x02id\x18\x01 \x01(\x04R\x02id\x12)\n" + + "\x03get\x18\x02 \x01(\v2\x15.ember.v1.GetResponseH\x00R\x03get\x12)\n" + + "\x03set\x18\x03 \x01(\v2\x15.ember.v1.SetResponseH\x00R\x03set\x12)\n" + + "\x03del\x18\x04 \x01(\v2\x15.ember.v1.DelResponseH\x00R\x03del\x120\n" + + "\aint_val\x18\x05 \x01(\v2\x15.ember.v1.IntResponseH\x00R\x06intVal\x123\n" + + "\bbool_val\x18\x06 \x01(\v2\x16.ember.v1.BoolResponseH\x00R\aboolVal\x126\n" + + "\tfloat_val\x18\a \x01(\v2\x17.ember.v1.FloatResponseH\x00R\bfloatVal\x122\n" + + "\x06status\x18\b \x01(\v2\x18.ember.v1.StatusResponseH\x00R\x06status\x12)\n" + + "\x03ttl\x18\t \x01(\v2\x15.ember.v1.TtlResponseH\x00R\x03ttl\x12,\n" + + "\x04type\x18\n" + + " \x01(\v2\x16.ember.v1.TypeResponseH\x00R\x04type\x12/\n" + + "\x05array\x18\v \x01(\v2\x17.ember.v1.ArrayResponseH\x00R\x05array\x12,\n" + + "\x04hash\x18\f \x01(\v2\x16.ember.v1.HashResponseH\x00R\x04hash\x12H\n" + + "\x0eoptional_array\x18\r \x01(\v2\x1f.ember.v1.OptionalArrayResponseH\x00R\roptionalArray\x12,\n" + + "\x04keys\x18\x0e \x01(\v2\x16.ember.v1.KeysResponseH\x00R\x04keys\x12,\n" + + "\x04scan\x18\x0f \x01(\v2\x16.ember.v1.ScanResponseH\x00R\x04scan\x12H\n" + + "\x0eoptional_float\x18\x10 \x01(\v2\x1f.ember.v1.OptionalFloatResponseH\x00R\roptionalFloat\x12B\n" + + "\foptional_int\x18\x11 \x01(\v2\x1d.ember.v1.OptionalIntResponseH\x00R\voptionalInt\x122\n" + + "\x06zrange\x18\x12 \x01(\v2\x18.ember.v1.ZRangeResponseH\x00R\x06zrange\x12,\n" + + "\x04vsim\x18\x13 \x01(\v2\x16.ember.v1.VSimResponseH\x00R\x04vsim\x12,\n" + + "\x04vget\x18\x14 \x01(\v2\x16.ember.v1.VGetResponseH\x00R\x04vget\x12/\n" + + "\x05vinfo\x18\x15 \x01(\v2\x17.ember.v1.VInfoResponseH\x00R\x05vinfo\x12,\n" + + "\x04mget\x18\x16 \x01(\v2\x16.ember.v1.MGetResponseH\x00R\x04mget\x12,\n" + + "\x04mset\x18\x17 \x01(\v2\x16.ember.v1.MSetResponseH\x00R\x04mset\x12,\n" + + "\x04ping\x18\x18 \x01(\v2\x16.ember.v1.PingResponseH\x00R\x04ping\x12/\n" + + "\x05error\x18\x19 \x01(\v2\x17.ember.v1.ErrorResponseH\x00R\x05error\x12,\n" + + "\x04info\x18\x1a \x01(\v2\x16.ember.v1.InfoResponseH\x00R\x04infoB\b\n" + + "\x06result\"R\n" + + "\rErrorResponse\x12\x18\n" + + "\amessage\x18\x01 \x01(\tR\amessage\x12'\n" + + "\x04kind\x18\x02 \x01(\x0e2\x13.ember.v1.ErrorKindR\x04kind*f\n" + + "\fVectorMetric\x12\x18\n" + + "\x14VECTOR_METRIC_COSINE\x10\x00\x12\x1b\n" + + "\x17VECTOR_METRIC_EUCLIDEAN\x10\x01\x12\x1f\n" + + "\x1bVECTOR_METRIC_INNER_PRODUCT\x10\x02*k\n" + + "\x12VectorQuantization\x12\x1c\n" + + "\x18VECTOR_QUANTIZATION_NONE\x10\x00\x12\x1b\n" + + "\x17VECTOR_QUANTIZATION_F16\x10\x01\x12\x1a\n" + + "\x16VECTOR_QUANTIZATION_I8\x10\x02*\x9a\x01\n" + + "\tErrorKind\x12\x1a\n" + + "\x16ERROR_KIND_UNSPECIFIED\x10\x00\x12\x19\n" + + "\x15ERROR_KIND_WRONG_TYPE\x10\x01\x12\x1c\n" + + "\x18ERROR_KIND_OUT_OF_MEMORY\x10\x02\x12\x17\n" + + "\x13ERROR_KIND_INTERNAL\x10\x03\x12\x1f\n" + + "\x1bERROR_KIND_INVALID_ARGUMENT\x10\x042\x81\x1b\n" + + "\n" + + "EmberCache\x122\n" + + "\x03Get\x12\x14.ember.v1.GetRequest\x1a\x15.ember.v1.GetResponse\x122\n" + + "\x03Set\x12\x14.ember.v1.SetRequest\x1a\x15.ember.v1.SetResponse\x122\n" + + "\x03Del\x12\x14.ember.v1.DelRequest\x1a\x15.ember.v1.DelResponse\x125\n" + + "\x04MGet\x12\x15.ember.v1.MGetRequest\x1a\x16.ember.v1.MGetResponse\x125\n" + + "\x04MSet\x12\x15.ember.v1.MSetRequest\x1a\x16.ember.v1.MSetResponse\x124\n" + + "\x04Incr\x12\x15.ember.v1.IncrRequest\x1a\x15.ember.v1.IntResponse\x128\n" + + "\x06IncrBy\x12\x17.ember.v1.IncrByRequest\x1a\x15.ember.v1.IntResponse\x128\n" + + "\x06DecrBy\x12\x17.ember.v1.DecrByRequest\x1a\x15.ember.v1.IntResponse\x12D\n" + + "\vIncrByFloat\x12\x1c.ember.v1.IncrByFloatRequest\x1a\x17.ember.v1.FloatResponse\x128\n" + + "\x06Append\x12\x17.ember.v1.AppendRequest\x1a\x15.ember.v1.IntResponse\x128\n" + + "\x06Strlen\x12\x17.ember.v1.StrlenRequest\x1a\x15.ember.v1.IntResponse\x128\n" + + "\x06Exists\x12\x17.ember.v1.ExistsRequest\x1a\x15.ember.v1.IntResponse\x129\n" + + "\x06Expire\x12\x17.ember.v1.ExpireRequest\x1a\x16.ember.v1.BoolResponse\x12;\n" + + "\aPExpire\x12\x18.ember.v1.PExpireRequest\x1a\x16.ember.v1.BoolResponse\x12;\n" + + "\aPersist\x12\x18.ember.v1.PersistRequest\x1a\x16.ember.v1.BoolResponse\x122\n" + + "\x03Ttl\x12\x14.ember.v1.TtlRequest\x1a\x15.ember.v1.TtlResponse\x124\n" + + "\x04PTtl\x12\x15.ember.v1.PTtlRequest\x1a\x15.ember.v1.TtlResponse\x125\n" + + "\x04Type\x12\x15.ember.v1.TypeRequest\x1a\x16.ember.v1.TypeResponse\x125\n" + + "\x04Keys\x12\x15.ember.v1.KeysRequest\x1a\x16.ember.v1.KeysResponse\x12;\n" + + "\x06Rename\x12\x17.ember.v1.RenameRequest\x1a\x18.ember.v1.StatusResponse\x125\n" + + "\x04Scan\x12\x15.ember.v1.ScanRequest\x1a\x16.ember.v1.ScanResponse\x126\n" + + "\x05LPush\x12\x16.ember.v1.LPushRequest\x1a\x15.ember.v1.IntResponse\x126\n" + + "\x05RPush\x12\x16.ember.v1.RPushRequest\x1a\x15.ember.v1.IntResponse\x124\n" + + "\x04LPop\x12\x15.ember.v1.LPopRequest\x1a\x15.ember.v1.GetResponse\x124\n" + + "\x04RPop\x12\x15.ember.v1.RPopRequest\x1a\x15.ember.v1.GetResponse\x12:\n" + + "\x06LRange\x12\x17.ember.v1.LRangeRequest\x1a\x17.ember.v1.ArrayResponse\x124\n" + + "\x04LLen\x12\x15.ember.v1.LLenRequest\x1a\x15.ember.v1.IntResponse\x124\n" + + "\x04HSet\x12\x15.ember.v1.HSetRequest\x1a\x15.ember.v1.IntResponse\x124\n" + + "\x04HGet\x12\x15.ember.v1.HGetRequest\x1a\x15.ember.v1.GetResponse\x12;\n" + + "\aHGetAll\x12\x18.ember.v1.HGetAllRequest\x1a\x16.ember.v1.HashResponse\x124\n" + + "\x04HDel\x12\x15.ember.v1.HDelRequest\x1a\x15.ember.v1.IntResponse\x12;\n" + + "\aHExists\x12\x18.ember.v1.HExistsRequest\x1a\x16.ember.v1.BoolResponse\x124\n" + + "\x04HLen\x12\x15.ember.v1.HLenRequest\x1a\x15.ember.v1.IntResponse\x12:\n" + + "\aHIncrBy\x12\x18.ember.v1.HIncrByRequest\x1a\x15.ember.v1.IntResponse\x127\n" + + "\x05HKeys\x12\x16.ember.v1.HKeysRequest\x1a\x16.ember.v1.KeysResponse\x128\n" + + "\x05HVals\x12\x16.ember.v1.HValsRequest\x1a\x17.ember.v1.ArrayResponse\x12@\n" + + "\x05HMGet\x12\x16.ember.v1.HMGetRequest\x1a\x1f.ember.v1.OptionalArrayResponse\x124\n" + + "\x04SAdd\x12\x15.ember.v1.SAddRequest\x1a\x15.ember.v1.IntResponse\x124\n" + + "\x04SRem\x12\x15.ember.v1.SRemRequest\x1a\x15.ember.v1.IntResponse\x12=\n" + + "\bSMembers\x12\x19.ember.v1.SMembersRequest\x1a\x16.ember.v1.KeysResponse\x12?\n" + + "\tSIsMember\x12\x1a.ember.v1.SIsMemberRequest\x1a\x16.ember.v1.BoolResponse\x126\n" + + "\x05SCard\x12\x16.ember.v1.SCardRequest\x1a\x15.ember.v1.IntResponse\x124\n" + + "\x04ZAdd\x12\x15.ember.v1.ZAddRequest\x1a\x15.ember.v1.IntResponse\x124\n" + + "\x04ZRem\x12\x15.ember.v1.ZRemRequest\x1a\x15.ember.v1.IntResponse\x12B\n" + + "\x06ZScore\x12\x17.ember.v1.ZScoreRequest\x1a\x1f.ember.v1.OptionalFloatResponse\x12>\n" + + "\x05ZRank\x12\x16.ember.v1.ZRankRequest\x1a\x1d.ember.v1.OptionalIntResponse\x126\n" + + "\x05ZCard\x12\x16.ember.v1.ZCardRequest\x1a\x15.ember.v1.IntResponse\x12;\n" + + "\x06ZRange\x12\x17.ember.v1.ZRangeRequest\x1a\x18.ember.v1.ZRangeResponse\x125\n" + + "\x04VAdd\x12\x15.ember.v1.VAddRequest\x1a\x16.ember.v1.BoolResponse\x125\n" + + "\x04VSim\x12\x15.ember.v1.VSimRequest\x1a\x16.ember.v1.VSimResponse\x125\n" + + "\x04VRem\x12\x15.ember.v1.VRemRequest\x1a\x16.ember.v1.BoolResponse\x125\n" + + "\x04VGet\x12\x15.ember.v1.VGetRequest\x1a\x16.ember.v1.VGetResponse\x126\n" + + "\x05VCard\x12\x16.ember.v1.VCardRequest\x1a\x15.ember.v1.IntResponse\x124\n" + + "\x04VDim\x12\x15.ember.v1.VDimRequest\x1a\x15.ember.v1.IntResponse\x128\n" + + "\x05VInfo\x12\x16.ember.v1.VInfoRequest\x1a\x17.ember.v1.VInfoResponse\x125\n" + + "\x04Ping\x12\x15.ember.v1.PingRequest\x1a\x16.ember.v1.PingResponse\x12=\n" + + "\aFlushDb\x12\x18.ember.v1.FlushDbRequest\x1a\x18.ember.v1.StatusResponse\x128\n" + + "\x06DbSize\x12\x17.ember.v1.DbSizeRequest\x1a\x15.ember.v1.IntResponse\x125\n" + + "\x04Info\x12\x15.ember.v1.InfoRequest\x1a\x16.ember.v1.InfoResponse\x12E\n" + + "\bPipeline\x12\x19.ember.v1.PipelineRequest\x1a\x1a.ember.v1.PipelineResponse(\x010\x01B1Z/github.com/kacy/ember-go/proto/ember/v1;emberv1b\x06proto3" + +var ( + file_ember_v1_ember_proto_rawDescOnce sync.Once + file_ember_v1_ember_proto_rawDescData []byte +) + +func file_ember_v1_ember_proto_rawDescGZIP() []byte { + file_ember_v1_ember_proto_rawDescOnce.Do(func() { + file_ember_v1_ember_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_ember_v1_ember_proto_rawDesc), len(file_ember_v1_ember_proto_rawDesc))) + }) + return file_ember_v1_ember_proto_rawDescData +} + +var file_ember_v1_ember_proto_enumTypes = make([]protoimpl.EnumInfo, 3) +var file_ember_v1_ember_proto_msgTypes = make([]protoimpl.MessageInfo, 91) +var file_ember_v1_ember_proto_goTypes = []any{ + (VectorMetric)(0), // 0: ember.v1.VectorMetric + (VectorQuantization)(0), // 1: ember.v1.VectorQuantization + (ErrorKind)(0), // 2: ember.v1.ErrorKind + (*IntResponse)(nil), // 3: ember.v1.IntResponse + (*BoolResponse)(nil), // 4: ember.v1.BoolResponse + (*FloatResponse)(nil), // 5: ember.v1.FloatResponse + (*StatusResponse)(nil), // 6: ember.v1.StatusResponse + (*GetRequest)(nil), // 7: ember.v1.GetRequest + (*GetResponse)(nil), // 8: ember.v1.GetResponse + (*SetRequest)(nil), // 9: ember.v1.SetRequest + (*SetResponse)(nil), // 10: ember.v1.SetResponse + (*DelRequest)(nil), // 11: ember.v1.DelRequest + (*DelResponse)(nil), // 12: ember.v1.DelResponse + (*MGetRequest)(nil), // 13: ember.v1.MGetRequest + (*MGetResponse)(nil), // 14: ember.v1.MGetResponse + (*OptionalValue)(nil), // 15: ember.v1.OptionalValue + (*MSetRequest)(nil), // 16: ember.v1.MSetRequest + (*KeyValue)(nil), // 17: ember.v1.KeyValue + (*MSetResponse)(nil), // 18: ember.v1.MSetResponse + (*IncrRequest)(nil), // 19: ember.v1.IncrRequest + (*IncrByRequest)(nil), // 20: ember.v1.IncrByRequest + (*DecrByRequest)(nil), // 21: ember.v1.DecrByRequest + (*IncrByFloatRequest)(nil), // 22: ember.v1.IncrByFloatRequest + (*AppendRequest)(nil), // 23: ember.v1.AppendRequest + (*StrlenRequest)(nil), // 24: ember.v1.StrlenRequest + (*ExistsRequest)(nil), // 25: ember.v1.ExistsRequest + (*ExpireRequest)(nil), // 26: ember.v1.ExpireRequest + (*PExpireRequest)(nil), // 27: ember.v1.PExpireRequest + (*PersistRequest)(nil), // 28: ember.v1.PersistRequest + (*TtlRequest)(nil), // 29: ember.v1.TtlRequest + (*PTtlRequest)(nil), // 30: ember.v1.PTtlRequest + (*TtlResponse)(nil), // 31: ember.v1.TtlResponse + (*TypeRequest)(nil), // 32: ember.v1.TypeRequest + (*TypeResponse)(nil), // 33: ember.v1.TypeResponse + (*KeysRequest)(nil), // 34: ember.v1.KeysRequest + (*KeysResponse)(nil), // 35: ember.v1.KeysResponse + (*RenameRequest)(nil), // 36: ember.v1.RenameRequest + (*ScanRequest)(nil), // 37: ember.v1.ScanRequest + (*ScanResponse)(nil), // 38: ember.v1.ScanResponse + (*LPushRequest)(nil), // 39: ember.v1.LPushRequest + (*RPushRequest)(nil), // 40: ember.v1.RPushRequest + (*LPopRequest)(nil), // 41: ember.v1.LPopRequest + (*RPopRequest)(nil), // 42: ember.v1.RPopRequest + (*LRangeRequest)(nil), // 43: ember.v1.LRangeRequest + (*ArrayResponse)(nil), // 44: ember.v1.ArrayResponse + (*LLenRequest)(nil), // 45: ember.v1.LLenRequest + (*HSetRequest)(nil), // 46: ember.v1.HSetRequest + (*FieldValue)(nil), // 47: ember.v1.FieldValue + (*HGetRequest)(nil), // 48: ember.v1.HGetRequest + (*HGetAllRequest)(nil), // 49: ember.v1.HGetAllRequest + (*HashResponse)(nil), // 50: ember.v1.HashResponse + (*HDelRequest)(nil), // 51: ember.v1.HDelRequest + (*HExistsRequest)(nil), // 52: ember.v1.HExistsRequest + (*HLenRequest)(nil), // 53: ember.v1.HLenRequest + (*HIncrByRequest)(nil), // 54: ember.v1.HIncrByRequest + (*HKeysRequest)(nil), // 55: ember.v1.HKeysRequest + (*HValsRequest)(nil), // 56: ember.v1.HValsRequest + (*HMGetRequest)(nil), // 57: ember.v1.HMGetRequest + (*OptionalArrayResponse)(nil), // 58: ember.v1.OptionalArrayResponse + (*SAddRequest)(nil), // 59: ember.v1.SAddRequest + (*SRemRequest)(nil), // 60: ember.v1.SRemRequest + (*SMembersRequest)(nil), // 61: ember.v1.SMembersRequest + (*SIsMemberRequest)(nil), // 62: ember.v1.SIsMemberRequest + (*SCardRequest)(nil), // 63: ember.v1.SCardRequest + (*ZAddRequest)(nil), // 64: ember.v1.ZAddRequest + (*ScoreMember)(nil), // 65: ember.v1.ScoreMember + (*ZRemRequest)(nil), // 66: ember.v1.ZRemRequest + (*ZScoreRequest)(nil), // 67: ember.v1.ZScoreRequest + (*OptionalFloatResponse)(nil), // 68: ember.v1.OptionalFloatResponse + (*ZRankRequest)(nil), // 69: ember.v1.ZRankRequest + (*OptionalIntResponse)(nil), // 70: ember.v1.OptionalIntResponse + (*ZCardRequest)(nil), // 71: ember.v1.ZCardRequest + (*ZRangeRequest)(nil), // 72: ember.v1.ZRangeRequest + (*ZRangeResponse)(nil), // 73: ember.v1.ZRangeResponse + (*VAddRequest)(nil), // 74: ember.v1.VAddRequest + (*VSimRequest)(nil), // 75: ember.v1.VSimRequest + (*VSimResponse)(nil), // 76: ember.v1.VSimResponse + (*VSimResult)(nil), // 77: ember.v1.VSimResult + (*VRemRequest)(nil), // 78: ember.v1.VRemRequest + (*VGetRequest)(nil), // 79: ember.v1.VGetRequest + (*VGetResponse)(nil), // 80: ember.v1.VGetResponse + (*VCardRequest)(nil), // 81: ember.v1.VCardRequest + (*VDimRequest)(nil), // 82: ember.v1.VDimRequest + (*VInfoRequest)(nil), // 83: ember.v1.VInfoRequest + (*VInfoResponse)(nil), // 84: ember.v1.VInfoResponse + (*PingRequest)(nil), // 85: ember.v1.PingRequest + (*PingResponse)(nil), // 86: ember.v1.PingResponse + (*FlushDbRequest)(nil), // 87: ember.v1.FlushDbRequest + (*DbSizeRequest)(nil), // 88: ember.v1.DbSizeRequest + (*InfoRequest)(nil), // 89: ember.v1.InfoRequest + (*InfoResponse)(nil), // 90: ember.v1.InfoResponse + (*PipelineRequest)(nil), // 91: ember.v1.PipelineRequest + (*PipelineResponse)(nil), // 92: ember.v1.PipelineResponse + (*ErrorResponse)(nil), // 93: ember.v1.ErrorResponse +} +var file_ember_v1_ember_proto_depIdxs = []int32{ + 15, // 0: ember.v1.MGetResponse.values:type_name -> ember.v1.OptionalValue + 17, // 1: ember.v1.MSetRequest.pairs:type_name -> ember.v1.KeyValue + 47, // 2: ember.v1.HSetRequest.fields:type_name -> ember.v1.FieldValue + 47, // 3: ember.v1.HashResponse.fields:type_name -> ember.v1.FieldValue + 15, // 4: ember.v1.OptionalArrayResponse.values:type_name -> ember.v1.OptionalValue + 65, // 5: ember.v1.ZAddRequest.members:type_name -> ember.v1.ScoreMember + 65, // 6: ember.v1.ZRangeResponse.members:type_name -> ember.v1.ScoreMember + 0, // 7: ember.v1.VAddRequest.metric:type_name -> ember.v1.VectorMetric + 1, // 8: ember.v1.VAddRequest.quantization:type_name -> ember.v1.VectorQuantization + 77, // 9: ember.v1.VSimResponse.results:type_name -> ember.v1.VSimResult + 47, // 10: ember.v1.VInfoResponse.info:type_name -> ember.v1.FieldValue + 7, // 11: ember.v1.PipelineRequest.get:type_name -> ember.v1.GetRequest + 9, // 12: ember.v1.PipelineRequest.set:type_name -> ember.v1.SetRequest + 11, // 13: ember.v1.PipelineRequest.del:type_name -> ember.v1.DelRequest + 25, // 14: ember.v1.PipelineRequest.exists:type_name -> ember.v1.ExistsRequest + 19, // 15: ember.v1.PipelineRequest.incr:type_name -> ember.v1.IncrRequest + 20, // 16: ember.v1.PipelineRequest.incr_by:type_name -> ember.v1.IncrByRequest + 21, // 17: ember.v1.PipelineRequest.decr_by:type_name -> ember.v1.DecrByRequest + 22, // 18: ember.v1.PipelineRequest.incr_by_float:type_name -> ember.v1.IncrByFloatRequest + 23, // 19: ember.v1.PipelineRequest.append:type_name -> ember.v1.AppendRequest + 24, // 20: ember.v1.PipelineRequest.strlen:type_name -> ember.v1.StrlenRequest + 26, // 21: ember.v1.PipelineRequest.expire:type_name -> ember.v1.ExpireRequest + 27, // 22: ember.v1.PipelineRequest.pexpire:type_name -> ember.v1.PExpireRequest + 28, // 23: ember.v1.PipelineRequest.persist:type_name -> ember.v1.PersistRequest + 29, // 24: ember.v1.PipelineRequest.ttl:type_name -> ember.v1.TtlRequest + 30, // 25: ember.v1.PipelineRequest.pttl:type_name -> ember.v1.PTtlRequest + 32, // 26: ember.v1.PipelineRequest.type:type_name -> ember.v1.TypeRequest + 39, // 27: ember.v1.PipelineRequest.lpush:type_name -> ember.v1.LPushRequest + 40, // 28: ember.v1.PipelineRequest.rpush:type_name -> ember.v1.RPushRequest + 41, // 29: ember.v1.PipelineRequest.lpop:type_name -> ember.v1.LPopRequest + 42, // 30: ember.v1.PipelineRequest.rpop:type_name -> ember.v1.RPopRequest + 43, // 31: ember.v1.PipelineRequest.lrange:type_name -> ember.v1.LRangeRequest + 45, // 32: ember.v1.PipelineRequest.llen:type_name -> ember.v1.LLenRequest + 46, // 33: ember.v1.PipelineRequest.hset:type_name -> ember.v1.HSetRequest + 48, // 34: ember.v1.PipelineRequest.hget:type_name -> ember.v1.HGetRequest + 49, // 35: ember.v1.PipelineRequest.hgetall:type_name -> ember.v1.HGetAllRequest + 51, // 36: ember.v1.PipelineRequest.hdel:type_name -> ember.v1.HDelRequest + 52, // 37: ember.v1.PipelineRequest.hexists:type_name -> ember.v1.HExistsRequest + 53, // 38: ember.v1.PipelineRequest.hlen:type_name -> ember.v1.HLenRequest + 54, // 39: ember.v1.PipelineRequest.hincr_by:type_name -> ember.v1.HIncrByRequest + 55, // 40: ember.v1.PipelineRequest.hkeys:type_name -> ember.v1.HKeysRequest + 56, // 41: ember.v1.PipelineRequest.hvals:type_name -> ember.v1.HValsRequest + 57, // 42: ember.v1.PipelineRequest.hmget:type_name -> ember.v1.HMGetRequest + 59, // 43: ember.v1.PipelineRequest.sadd:type_name -> ember.v1.SAddRequest + 60, // 44: ember.v1.PipelineRequest.srem:type_name -> ember.v1.SRemRequest + 61, // 45: ember.v1.PipelineRequest.smembers:type_name -> ember.v1.SMembersRequest + 62, // 46: ember.v1.PipelineRequest.sismember:type_name -> ember.v1.SIsMemberRequest + 63, // 47: ember.v1.PipelineRequest.scard:type_name -> ember.v1.SCardRequest + 64, // 48: ember.v1.PipelineRequest.zadd:type_name -> ember.v1.ZAddRequest + 66, // 49: ember.v1.PipelineRequest.zrem:type_name -> ember.v1.ZRemRequest + 67, // 50: ember.v1.PipelineRequest.zscore:type_name -> ember.v1.ZScoreRequest + 69, // 51: ember.v1.PipelineRequest.zrank:type_name -> ember.v1.ZRankRequest + 71, // 52: ember.v1.PipelineRequest.zcard:type_name -> ember.v1.ZCardRequest + 72, // 53: ember.v1.PipelineRequest.zrange:type_name -> ember.v1.ZRangeRequest + 74, // 54: ember.v1.PipelineRequest.vadd:type_name -> ember.v1.VAddRequest + 75, // 55: ember.v1.PipelineRequest.vsim:type_name -> ember.v1.VSimRequest + 78, // 56: ember.v1.PipelineRequest.vrem:type_name -> ember.v1.VRemRequest + 79, // 57: ember.v1.PipelineRequest.vget:type_name -> ember.v1.VGetRequest + 81, // 58: ember.v1.PipelineRequest.vcard:type_name -> ember.v1.VCardRequest + 82, // 59: ember.v1.PipelineRequest.vdim:type_name -> ember.v1.VDimRequest + 83, // 60: ember.v1.PipelineRequest.vinfo:type_name -> ember.v1.VInfoRequest + 85, // 61: ember.v1.PipelineRequest.ping:type_name -> ember.v1.PingRequest + 87, // 62: ember.v1.PipelineRequest.flushdb:type_name -> ember.v1.FlushDbRequest + 88, // 63: ember.v1.PipelineRequest.dbsize:type_name -> ember.v1.DbSizeRequest + 13, // 64: ember.v1.PipelineRequest.mget:type_name -> ember.v1.MGetRequest + 16, // 65: ember.v1.PipelineRequest.mset:type_name -> ember.v1.MSetRequest + 34, // 66: ember.v1.PipelineRequest.keys:type_name -> ember.v1.KeysRequest + 36, // 67: ember.v1.PipelineRequest.rename:type_name -> ember.v1.RenameRequest + 37, // 68: ember.v1.PipelineRequest.scan:type_name -> ember.v1.ScanRequest + 8, // 69: ember.v1.PipelineResponse.get:type_name -> ember.v1.GetResponse + 10, // 70: ember.v1.PipelineResponse.set:type_name -> ember.v1.SetResponse + 12, // 71: ember.v1.PipelineResponse.del:type_name -> ember.v1.DelResponse + 3, // 72: ember.v1.PipelineResponse.int_val:type_name -> ember.v1.IntResponse + 4, // 73: ember.v1.PipelineResponse.bool_val:type_name -> ember.v1.BoolResponse + 5, // 74: ember.v1.PipelineResponse.float_val:type_name -> ember.v1.FloatResponse + 6, // 75: ember.v1.PipelineResponse.status:type_name -> ember.v1.StatusResponse + 31, // 76: ember.v1.PipelineResponse.ttl:type_name -> ember.v1.TtlResponse + 33, // 77: ember.v1.PipelineResponse.type:type_name -> ember.v1.TypeResponse + 44, // 78: ember.v1.PipelineResponse.array:type_name -> ember.v1.ArrayResponse + 50, // 79: ember.v1.PipelineResponse.hash:type_name -> ember.v1.HashResponse + 58, // 80: ember.v1.PipelineResponse.optional_array:type_name -> ember.v1.OptionalArrayResponse + 35, // 81: ember.v1.PipelineResponse.keys:type_name -> ember.v1.KeysResponse + 38, // 82: ember.v1.PipelineResponse.scan:type_name -> ember.v1.ScanResponse + 68, // 83: ember.v1.PipelineResponse.optional_float:type_name -> ember.v1.OptionalFloatResponse + 70, // 84: ember.v1.PipelineResponse.optional_int:type_name -> ember.v1.OptionalIntResponse + 73, // 85: ember.v1.PipelineResponse.zrange:type_name -> ember.v1.ZRangeResponse + 76, // 86: ember.v1.PipelineResponse.vsim:type_name -> ember.v1.VSimResponse + 80, // 87: ember.v1.PipelineResponse.vget:type_name -> ember.v1.VGetResponse + 84, // 88: ember.v1.PipelineResponse.vinfo:type_name -> ember.v1.VInfoResponse + 14, // 89: ember.v1.PipelineResponse.mget:type_name -> ember.v1.MGetResponse + 18, // 90: ember.v1.PipelineResponse.mset:type_name -> ember.v1.MSetResponse + 86, // 91: ember.v1.PipelineResponse.ping:type_name -> ember.v1.PingResponse + 93, // 92: ember.v1.PipelineResponse.error:type_name -> ember.v1.ErrorResponse + 90, // 93: ember.v1.PipelineResponse.info:type_name -> ember.v1.InfoResponse + 2, // 94: ember.v1.ErrorResponse.kind:type_name -> ember.v1.ErrorKind + 7, // 95: ember.v1.EmberCache.Get:input_type -> ember.v1.GetRequest + 9, // 96: ember.v1.EmberCache.Set:input_type -> ember.v1.SetRequest + 11, // 97: ember.v1.EmberCache.Del:input_type -> ember.v1.DelRequest + 13, // 98: ember.v1.EmberCache.MGet:input_type -> ember.v1.MGetRequest + 16, // 99: ember.v1.EmberCache.MSet:input_type -> ember.v1.MSetRequest + 19, // 100: ember.v1.EmberCache.Incr:input_type -> ember.v1.IncrRequest + 20, // 101: ember.v1.EmberCache.IncrBy:input_type -> ember.v1.IncrByRequest + 21, // 102: ember.v1.EmberCache.DecrBy:input_type -> ember.v1.DecrByRequest + 22, // 103: ember.v1.EmberCache.IncrByFloat:input_type -> ember.v1.IncrByFloatRequest + 23, // 104: ember.v1.EmberCache.Append:input_type -> ember.v1.AppendRequest + 24, // 105: ember.v1.EmberCache.Strlen:input_type -> ember.v1.StrlenRequest + 25, // 106: ember.v1.EmberCache.Exists:input_type -> ember.v1.ExistsRequest + 26, // 107: ember.v1.EmberCache.Expire:input_type -> ember.v1.ExpireRequest + 27, // 108: ember.v1.EmberCache.PExpire:input_type -> ember.v1.PExpireRequest + 28, // 109: ember.v1.EmberCache.Persist:input_type -> ember.v1.PersistRequest + 29, // 110: ember.v1.EmberCache.Ttl:input_type -> ember.v1.TtlRequest + 30, // 111: ember.v1.EmberCache.PTtl:input_type -> ember.v1.PTtlRequest + 32, // 112: ember.v1.EmberCache.Type:input_type -> ember.v1.TypeRequest + 34, // 113: ember.v1.EmberCache.Keys:input_type -> ember.v1.KeysRequest + 36, // 114: ember.v1.EmberCache.Rename:input_type -> ember.v1.RenameRequest + 37, // 115: ember.v1.EmberCache.Scan:input_type -> ember.v1.ScanRequest + 39, // 116: ember.v1.EmberCache.LPush:input_type -> ember.v1.LPushRequest + 40, // 117: ember.v1.EmberCache.RPush:input_type -> ember.v1.RPushRequest + 41, // 118: ember.v1.EmberCache.LPop:input_type -> ember.v1.LPopRequest + 42, // 119: ember.v1.EmberCache.RPop:input_type -> ember.v1.RPopRequest + 43, // 120: ember.v1.EmberCache.LRange:input_type -> ember.v1.LRangeRequest + 45, // 121: ember.v1.EmberCache.LLen:input_type -> ember.v1.LLenRequest + 46, // 122: ember.v1.EmberCache.HSet:input_type -> ember.v1.HSetRequest + 48, // 123: ember.v1.EmberCache.HGet:input_type -> ember.v1.HGetRequest + 49, // 124: ember.v1.EmberCache.HGetAll:input_type -> ember.v1.HGetAllRequest + 51, // 125: ember.v1.EmberCache.HDel:input_type -> ember.v1.HDelRequest + 52, // 126: ember.v1.EmberCache.HExists:input_type -> ember.v1.HExistsRequest + 53, // 127: ember.v1.EmberCache.HLen:input_type -> ember.v1.HLenRequest + 54, // 128: ember.v1.EmberCache.HIncrBy:input_type -> ember.v1.HIncrByRequest + 55, // 129: ember.v1.EmberCache.HKeys:input_type -> ember.v1.HKeysRequest + 56, // 130: ember.v1.EmberCache.HVals:input_type -> ember.v1.HValsRequest + 57, // 131: ember.v1.EmberCache.HMGet:input_type -> ember.v1.HMGetRequest + 59, // 132: ember.v1.EmberCache.SAdd:input_type -> ember.v1.SAddRequest + 60, // 133: ember.v1.EmberCache.SRem:input_type -> ember.v1.SRemRequest + 61, // 134: ember.v1.EmberCache.SMembers:input_type -> ember.v1.SMembersRequest + 62, // 135: ember.v1.EmberCache.SIsMember:input_type -> ember.v1.SIsMemberRequest + 63, // 136: ember.v1.EmberCache.SCard:input_type -> ember.v1.SCardRequest + 64, // 137: ember.v1.EmberCache.ZAdd:input_type -> ember.v1.ZAddRequest + 66, // 138: ember.v1.EmberCache.ZRem:input_type -> ember.v1.ZRemRequest + 67, // 139: ember.v1.EmberCache.ZScore:input_type -> ember.v1.ZScoreRequest + 69, // 140: ember.v1.EmberCache.ZRank:input_type -> ember.v1.ZRankRequest + 71, // 141: ember.v1.EmberCache.ZCard:input_type -> ember.v1.ZCardRequest + 72, // 142: ember.v1.EmberCache.ZRange:input_type -> ember.v1.ZRangeRequest + 74, // 143: ember.v1.EmberCache.VAdd:input_type -> ember.v1.VAddRequest + 75, // 144: ember.v1.EmberCache.VSim:input_type -> ember.v1.VSimRequest + 78, // 145: ember.v1.EmberCache.VRem:input_type -> ember.v1.VRemRequest + 79, // 146: ember.v1.EmberCache.VGet:input_type -> ember.v1.VGetRequest + 81, // 147: ember.v1.EmberCache.VCard:input_type -> ember.v1.VCardRequest + 82, // 148: ember.v1.EmberCache.VDim:input_type -> ember.v1.VDimRequest + 83, // 149: ember.v1.EmberCache.VInfo:input_type -> ember.v1.VInfoRequest + 85, // 150: ember.v1.EmberCache.Ping:input_type -> ember.v1.PingRequest + 87, // 151: ember.v1.EmberCache.FlushDb:input_type -> ember.v1.FlushDbRequest + 88, // 152: ember.v1.EmberCache.DbSize:input_type -> ember.v1.DbSizeRequest + 89, // 153: ember.v1.EmberCache.Info:input_type -> ember.v1.InfoRequest + 91, // 154: ember.v1.EmberCache.Pipeline:input_type -> ember.v1.PipelineRequest + 8, // 155: ember.v1.EmberCache.Get:output_type -> ember.v1.GetResponse + 10, // 156: ember.v1.EmberCache.Set:output_type -> ember.v1.SetResponse + 12, // 157: ember.v1.EmberCache.Del:output_type -> ember.v1.DelResponse + 14, // 158: ember.v1.EmberCache.MGet:output_type -> ember.v1.MGetResponse + 18, // 159: ember.v1.EmberCache.MSet:output_type -> ember.v1.MSetResponse + 3, // 160: ember.v1.EmberCache.Incr:output_type -> ember.v1.IntResponse + 3, // 161: ember.v1.EmberCache.IncrBy:output_type -> ember.v1.IntResponse + 3, // 162: ember.v1.EmberCache.DecrBy:output_type -> ember.v1.IntResponse + 5, // 163: ember.v1.EmberCache.IncrByFloat:output_type -> ember.v1.FloatResponse + 3, // 164: ember.v1.EmberCache.Append:output_type -> ember.v1.IntResponse + 3, // 165: ember.v1.EmberCache.Strlen:output_type -> ember.v1.IntResponse + 3, // 166: ember.v1.EmberCache.Exists:output_type -> ember.v1.IntResponse + 4, // 167: ember.v1.EmberCache.Expire:output_type -> ember.v1.BoolResponse + 4, // 168: ember.v1.EmberCache.PExpire:output_type -> ember.v1.BoolResponse + 4, // 169: ember.v1.EmberCache.Persist:output_type -> ember.v1.BoolResponse + 31, // 170: ember.v1.EmberCache.Ttl:output_type -> ember.v1.TtlResponse + 31, // 171: ember.v1.EmberCache.PTtl:output_type -> ember.v1.TtlResponse + 33, // 172: ember.v1.EmberCache.Type:output_type -> ember.v1.TypeResponse + 35, // 173: ember.v1.EmberCache.Keys:output_type -> ember.v1.KeysResponse + 6, // 174: ember.v1.EmberCache.Rename:output_type -> ember.v1.StatusResponse + 38, // 175: ember.v1.EmberCache.Scan:output_type -> ember.v1.ScanResponse + 3, // 176: ember.v1.EmberCache.LPush:output_type -> ember.v1.IntResponse + 3, // 177: ember.v1.EmberCache.RPush:output_type -> ember.v1.IntResponse + 8, // 178: ember.v1.EmberCache.LPop:output_type -> ember.v1.GetResponse + 8, // 179: ember.v1.EmberCache.RPop:output_type -> ember.v1.GetResponse + 44, // 180: ember.v1.EmberCache.LRange:output_type -> ember.v1.ArrayResponse + 3, // 181: ember.v1.EmberCache.LLen:output_type -> ember.v1.IntResponse + 3, // 182: ember.v1.EmberCache.HSet:output_type -> ember.v1.IntResponse + 8, // 183: ember.v1.EmberCache.HGet:output_type -> ember.v1.GetResponse + 50, // 184: ember.v1.EmberCache.HGetAll:output_type -> ember.v1.HashResponse + 3, // 185: ember.v1.EmberCache.HDel:output_type -> ember.v1.IntResponse + 4, // 186: ember.v1.EmberCache.HExists:output_type -> ember.v1.BoolResponse + 3, // 187: ember.v1.EmberCache.HLen:output_type -> ember.v1.IntResponse + 3, // 188: ember.v1.EmberCache.HIncrBy:output_type -> ember.v1.IntResponse + 35, // 189: ember.v1.EmberCache.HKeys:output_type -> ember.v1.KeysResponse + 44, // 190: ember.v1.EmberCache.HVals:output_type -> ember.v1.ArrayResponse + 58, // 191: ember.v1.EmberCache.HMGet:output_type -> ember.v1.OptionalArrayResponse + 3, // 192: ember.v1.EmberCache.SAdd:output_type -> ember.v1.IntResponse + 3, // 193: ember.v1.EmberCache.SRem:output_type -> ember.v1.IntResponse + 35, // 194: ember.v1.EmberCache.SMembers:output_type -> ember.v1.KeysResponse + 4, // 195: ember.v1.EmberCache.SIsMember:output_type -> ember.v1.BoolResponse + 3, // 196: ember.v1.EmberCache.SCard:output_type -> ember.v1.IntResponse + 3, // 197: ember.v1.EmberCache.ZAdd:output_type -> ember.v1.IntResponse + 3, // 198: ember.v1.EmberCache.ZRem:output_type -> ember.v1.IntResponse + 68, // 199: ember.v1.EmberCache.ZScore:output_type -> ember.v1.OptionalFloatResponse + 70, // 200: ember.v1.EmberCache.ZRank:output_type -> ember.v1.OptionalIntResponse + 3, // 201: ember.v1.EmberCache.ZCard:output_type -> ember.v1.IntResponse + 73, // 202: ember.v1.EmberCache.ZRange:output_type -> ember.v1.ZRangeResponse + 4, // 203: ember.v1.EmberCache.VAdd:output_type -> ember.v1.BoolResponse + 76, // 204: ember.v1.EmberCache.VSim:output_type -> ember.v1.VSimResponse + 4, // 205: ember.v1.EmberCache.VRem:output_type -> ember.v1.BoolResponse + 80, // 206: ember.v1.EmberCache.VGet:output_type -> ember.v1.VGetResponse + 3, // 207: ember.v1.EmberCache.VCard:output_type -> ember.v1.IntResponse + 3, // 208: ember.v1.EmberCache.VDim:output_type -> ember.v1.IntResponse + 84, // 209: ember.v1.EmberCache.VInfo:output_type -> ember.v1.VInfoResponse + 86, // 210: ember.v1.EmberCache.Ping:output_type -> ember.v1.PingResponse + 6, // 211: ember.v1.EmberCache.FlushDb:output_type -> ember.v1.StatusResponse + 3, // 212: ember.v1.EmberCache.DbSize:output_type -> ember.v1.IntResponse + 90, // 213: ember.v1.EmberCache.Info:output_type -> ember.v1.InfoResponse + 92, // 214: ember.v1.EmberCache.Pipeline:output_type -> ember.v1.PipelineResponse + 155, // [155:215] is the sub-list for method output_type + 95, // [95:155] is the sub-list for method input_type + 95, // [95:95] is the sub-list for extension type_name + 95, // [95:95] is the sub-list for extension extendee + 0, // [0:95] is the sub-list for field type_name +} + +func init() { file_ember_v1_ember_proto_init() } +func file_ember_v1_ember_proto_init() { + if File_ember_v1_ember_proto != nil { + return + } + file_ember_v1_ember_proto_msgTypes[5].OneofWrappers = []any{} + file_ember_v1_ember_proto_msgTypes[12].OneofWrappers = []any{} + file_ember_v1_ember_proto_msgTypes[34].OneofWrappers = []any{} + file_ember_v1_ember_proto_msgTypes[65].OneofWrappers = []any{} + file_ember_v1_ember_proto_msgTypes[67].OneofWrappers = []any{} + file_ember_v1_ember_proto_msgTypes[71].OneofWrappers = []any{} + file_ember_v1_ember_proto_msgTypes[72].OneofWrappers = []any{} + file_ember_v1_ember_proto_msgTypes[77].OneofWrappers = []any{} + file_ember_v1_ember_proto_msgTypes[82].OneofWrappers = []any{} + file_ember_v1_ember_proto_msgTypes[86].OneofWrappers = []any{} + file_ember_v1_ember_proto_msgTypes[88].OneofWrappers = []any{ + (*PipelineRequest_Get)(nil), + (*PipelineRequest_Set)(nil), + (*PipelineRequest_Del)(nil), + (*PipelineRequest_Exists)(nil), + (*PipelineRequest_Incr)(nil), + (*PipelineRequest_IncrBy)(nil), + (*PipelineRequest_DecrBy)(nil), + (*PipelineRequest_IncrByFloat)(nil), + (*PipelineRequest_Append)(nil), + (*PipelineRequest_Strlen)(nil), + (*PipelineRequest_Expire)(nil), + (*PipelineRequest_Pexpire)(nil), + (*PipelineRequest_Persist)(nil), + (*PipelineRequest_Ttl)(nil), + (*PipelineRequest_Pttl)(nil), + (*PipelineRequest_Type)(nil), + (*PipelineRequest_Lpush)(nil), + (*PipelineRequest_Rpush)(nil), + (*PipelineRequest_Lpop)(nil), + (*PipelineRequest_Rpop)(nil), + (*PipelineRequest_Lrange)(nil), + (*PipelineRequest_Llen)(nil), + (*PipelineRequest_Hset)(nil), + (*PipelineRequest_Hget)(nil), + (*PipelineRequest_Hgetall)(nil), + (*PipelineRequest_Hdel)(nil), + (*PipelineRequest_Hexists)(nil), + (*PipelineRequest_Hlen)(nil), + (*PipelineRequest_HincrBy)(nil), + (*PipelineRequest_Hkeys)(nil), + (*PipelineRequest_Hvals)(nil), + (*PipelineRequest_Hmget)(nil), + (*PipelineRequest_Sadd)(nil), + (*PipelineRequest_Srem)(nil), + (*PipelineRequest_Smembers)(nil), + (*PipelineRequest_Sismember)(nil), + (*PipelineRequest_Scard)(nil), + (*PipelineRequest_Zadd)(nil), + (*PipelineRequest_Zrem)(nil), + (*PipelineRequest_Zscore)(nil), + (*PipelineRequest_Zrank)(nil), + (*PipelineRequest_Zcard)(nil), + (*PipelineRequest_Zrange)(nil), + (*PipelineRequest_Vadd)(nil), + (*PipelineRequest_Vsim)(nil), + (*PipelineRequest_Vrem)(nil), + (*PipelineRequest_Vget)(nil), + (*PipelineRequest_Vcard)(nil), + (*PipelineRequest_Vdim)(nil), + (*PipelineRequest_Vinfo)(nil), + (*PipelineRequest_Ping)(nil), + (*PipelineRequest_Flushdb)(nil), + (*PipelineRequest_Dbsize)(nil), + (*PipelineRequest_Mget)(nil), + (*PipelineRequest_Mset)(nil), + (*PipelineRequest_Keys)(nil), + (*PipelineRequest_Rename)(nil), + (*PipelineRequest_Scan)(nil), + } + file_ember_v1_ember_proto_msgTypes[89].OneofWrappers = []any{ + (*PipelineResponse_Get)(nil), + (*PipelineResponse_Set)(nil), + (*PipelineResponse_Del)(nil), + (*PipelineResponse_IntVal)(nil), + (*PipelineResponse_BoolVal)(nil), + (*PipelineResponse_FloatVal)(nil), + (*PipelineResponse_Status)(nil), + (*PipelineResponse_Ttl)(nil), + (*PipelineResponse_Type)(nil), + (*PipelineResponse_Array)(nil), + (*PipelineResponse_Hash)(nil), + (*PipelineResponse_OptionalArray)(nil), + (*PipelineResponse_Keys)(nil), + (*PipelineResponse_Scan)(nil), + (*PipelineResponse_OptionalFloat)(nil), + (*PipelineResponse_OptionalInt)(nil), + (*PipelineResponse_Zrange)(nil), + (*PipelineResponse_Vsim)(nil), + (*PipelineResponse_Vget)(nil), + (*PipelineResponse_Vinfo)(nil), + (*PipelineResponse_Mget)(nil), + (*PipelineResponse_Mset)(nil), + (*PipelineResponse_Ping)(nil), + (*PipelineResponse_Error)(nil), + (*PipelineResponse_Info)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_ember_v1_ember_proto_rawDesc), len(file_ember_v1_ember_proto_rawDesc)), + NumEnums: 3, + NumMessages: 91, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_ember_v1_ember_proto_goTypes, + DependencyIndexes: file_ember_v1_ember_proto_depIdxs, + EnumInfos: file_ember_v1_ember_proto_enumTypes, + MessageInfos: file_ember_v1_ember_proto_msgTypes, + }.Build() + File_ember_v1_ember_proto = out.File + file_ember_v1_ember_proto_goTypes = nil + file_ember_v1_ember_proto_depIdxs = nil +} diff --git a/clients/ember-go/proto/ember/v1/ember_grpc.pb.go b/clients/ember-go/proto/ember/v1/ember_grpc.pb.go new file mode 100644 index 00000000..b97274f1 --- /dev/null +++ b/clients/ember-go/proto/ember/v1/ember_grpc.pb.go @@ -0,0 +1,2366 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.6.0 +// - protoc v6.33.4 +// source: ember/v1/ember.proto + +package emberv1 + +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.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + EmberCache_Get_FullMethodName = "/ember.v1.EmberCache/Get" + EmberCache_Set_FullMethodName = "/ember.v1.EmberCache/Set" + EmberCache_Del_FullMethodName = "/ember.v1.EmberCache/Del" + EmberCache_MGet_FullMethodName = "/ember.v1.EmberCache/MGet" + EmberCache_MSet_FullMethodName = "/ember.v1.EmberCache/MSet" + EmberCache_Incr_FullMethodName = "/ember.v1.EmberCache/Incr" + EmberCache_IncrBy_FullMethodName = "/ember.v1.EmberCache/IncrBy" + EmberCache_DecrBy_FullMethodName = "/ember.v1.EmberCache/DecrBy" + EmberCache_IncrByFloat_FullMethodName = "/ember.v1.EmberCache/IncrByFloat" + EmberCache_Append_FullMethodName = "/ember.v1.EmberCache/Append" + EmberCache_Strlen_FullMethodName = "/ember.v1.EmberCache/Strlen" + EmberCache_Exists_FullMethodName = "/ember.v1.EmberCache/Exists" + EmberCache_Expire_FullMethodName = "/ember.v1.EmberCache/Expire" + EmberCache_PExpire_FullMethodName = "/ember.v1.EmberCache/PExpire" + EmberCache_Persist_FullMethodName = "/ember.v1.EmberCache/Persist" + EmberCache_Ttl_FullMethodName = "/ember.v1.EmberCache/Ttl" + EmberCache_PTtl_FullMethodName = "/ember.v1.EmberCache/PTtl" + EmberCache_Type_FullMethodName = "/ember.v1.EmberCache/Type" + EmberCache_Keys_FullMethodName = "/ember.v1.EmberCache/Keys" + EmberCache_Rename_FullMethodName = "/ember.v1.EmberCache/Rename" + EmberCache_Scan_FullMethodName = "/ember.v1.EmberCache/Scan" + EmberCache_LPush_FullMethodName = "/ember.v1.EmberCache/LPush" + EmberCache_RPush_FullMethodName = "/ember.v1.EmberCache/RPush" + EmberCache_LPop_FullMethodName = "/ember.v1.EmberCache/LPop" + EmberCache_RPop_FullMethodName = "/ember.v1.EmberCache/RPop" + EmberCache_LRange_FullMethodName = "/ember.v1.EmberCache/LRange" + EmberCache_LLen_FullMethodName = "/ember.v1.EmberCache/LLen" + EmberCache_HSet_FullMethodName = "/ember.v1.EmberCache/HSet" + EmberCache_HGet_FullMethodName = "/ember.v1.EmberCache/HGet" + EmberCache_HGetAll_FullMethodName = "/ember.v1.EmberCache/HGetAll" + EmberCache_HDel_FullMethodName = "/ember.v1.EmberCache/HDel" + EmberCache_HExists_FullMethodName = "/ember.v1.EmberCache/HExists" + EmberCache_HLen_FullMethodName = "/ember.v1.EmberCache/HLen" + EmberCache_HIncrBy_FullMethodName = "/ember.v1.EmberCache/HIncrBy" + EmberCache_HKeys_FullMethodName = "/ember.v1.EmberCache/HKeys" + EmberCache_HVals_FullMethodName = "/ember.v1.EmberCache/HVals" + EmberCache_HMGet_FullMethodName = "/ember.v1.EmberCache/HMGet" + EmberCache_SAdd_FullMethodName = "/ember.v1.EmberCache/SAdd" + EmberCache_SRem_FullMethodName = "/ember.v1.EmberCache/SRem" + EmberCache_SMembers_FullMethodName = "/ember.v1.EmberCache/SMembers" + EmberCache_SIsMember_FullMethodName = "/ember.v1.EmberCache/SIsMember" + EmberCache_SCard_FullMethodName = "/ember.v1.EmberCache/SCard" + EmberCache_ZAdd_FullMethodName = "/ember.v1.EmberCache/ZAdd" + EmberCache_ZRem_FullMethodName = "/ember.v1.EmberCache/ZRem" + EmberCache_ZScore_FullMethodName = "/ember.v1.EmberCache/ZScore" + EmberCache_ZRank_FullMethodName = "/ember.v1.EmberCache/ZRank" + EmberCache_ZCard_FullMethodName = "/ember.v1.EmberCache/ZCard" + EmberCache_ZRange_FullMethodName = "/ember.v1.EmberCache/ZRange" + EmberCache_VAdd_FullMethodName = "/ember.v1.EmberCache/VAdd" + EmberCache_VSim_FullMethodName = "/ember.v1.EmberCache/VSim" + EmberCache_VRem_FullMethodName = "/ember.v1.EmberCache/VRem" + EmberCache_VGet_FullMethodName = "/ember.v1.EmberCache/VGet" + EmberCache_VCard_FullMethodName = "/ember.v1.EmberCache/VCard" + EmberCache_VDim_FullMethodName = "/ember.v1.EmberCache/VDim" + EmberCache_VInfo_FullMethodName = "/ember.v1.EmberCache/VInfo" + EmberCache_Ping_FullMethodName = "/ember.v1.EmberCache/Ping" + EmberCache_FlushDb_FullMethodName = "/ember.v1.EmberCache/FlushDb" + EmberCache_DbSize_FullMethodName = "/ember.v1.EmberCache/DbSize" + EmberCache_Info_FullMethodName = "/ember.v1.EmberCache/Info" + EmberCache_Pipeline_FullMethodName = "/ember.v1.EmberCache/Pipeline" +) + +// EmberCacheClient is the client API for EmberCache 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. +// +// EmberCache provides a gRPC interface to ember's key-value store. +// all commands route through the same engine as RESP3, so behavior +// is identical regardless of protocol. +type EmberCacheClient interface { + Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) + Set(ctx context.Context, in *SetRequest, opts ...grpc.CallOption) (*SetResponse, error) + Del(ctx context.Context, in *DelRequest, opts ...grpc.CallOption) (*DelResponse, error) + MGet(ctx context.Context, in *MGetRequest, opts ...grpc.CallOption) (*MGetResponse, error) + MSet(ctx context.Context, in *MSetRequest, opts ...grpc.CallOption) (*MSetResponse, error) + Incr(ctx context.Context, in *IncrRequest, opts ...grpc.CallOption) (*IntResponse, error) + IncrBy(ctx context.Context, in *IncrByRequest, opts ...grpc.CallOption) (*IntResponse, error) + DecrBy(ctx context.Context, in *DecrByRequest, opts ...grpc.CallOption) (*IntResponse, error) + IncrByFloat(ctx context.Context, in *IncrByFloatRequest, opts ...grpc.CallOption) (*FloatResponse, error) + Append(ctx context.Context, in *AppendRequest, opts ...grpc.CallOption) (*IntResponse, error) + Strlen(ctx context.Context, in *StrlenRequest, opts ...grpc.CallOption) (*IntResponse, error) + Exists(ctx context.Context, in *ExistsRequest, opts ...grpc.CallOption) (*IntResponse, error) + Expire(ctx context.Context, in *ExpireRequest, opts ...grpc.CallOption) (*BoolResponse, error) + PExpire(ctx context.Context, in *PExpireRequest, opts ...grpc.CallOption) (*BoolResponse, error) + Persist(ctx context.Context, in *PersistRequest, opts ...grpc.CallOption) (*BoolResponse, error) + Ttl(ctx context.Context, in *TtlRequest, opts ...grpc.CallOption) (*TtlResponse, error) + PTtl(ctx context.Context, in *PTtlRequest, opts ...grpc.CallOption) (*TtlResponse, error) + Type(ctx context.Context, in *TypeRequest, opts ...grpc.CallOption) (*TypeResponse, error) + Keys(ctx context.Context, in *KeysRequest, opts ...grpc.CallOption) (*KeysResponse, error) + Rename(ctx context.Context, in *RenameRequest, opts ...grpc.CallOption) (*StatusResponse, error) + Scan(ctx context.Context, in *ScanRequest, opts ...grpc.CallOption) (*ScanResponse, error) + LPush(ctx context.Context, in *LPushRequest, opts ...grpc.CallOption) (*IntResponse, error) + RPush(ctx context.Context, in *RPushRequest, opts ...grpc.CallOption) (*IntResponse, error) + LPop(ctx context.Context, in *LPopRequest, opts ...grpc.CallOption) (*GetResponse, error) + RPop(ctx context.Context, in *RPopRequest, opts ...grpc.CallOption) (*GetResponse, error) + LRange(ctx context.Context, in *LRangeRequest, opts ...grpc.CallOption) (*ArrayResponse, error) + LLen(ctx context.Context, in *LLenRequest, opts ...grpc.CallOption) (*IntResponse, error) + HSet(ctx context.Context, in *HSetRequest, opts ...grpc.CallOption) (*IntResponse, error) + HGet(ctx context.Context, in *HGetRequest, opts ...grpc.CallOption) (*GetResponse, error) + HGetAll(ctx context.Context, in *HGetAllRequest, opts ...grpc.CallOption) (*HashResponse, error) + HDel(ctx context.Context, in *HDelRequest, opts ...grpc.CallOption) (*IntResponse, error) + HExists(ctx context.Context, in *HExistsRequest, opts ...grpc.CallOption) (*BoolResponse, error) + HLen(ctx context.Context, in *HLenRequest, opts ...grpc.CallOption) (*IntResponse, error) + HIncrBy(ctx context.Context, in *HIncrByRequest, opts ...grpc.CallOption) (*IntResponse, error) + HKeys(ctx context.Context, in *HKeysRequest, opts ...grpc.CallOption) (*KeysResponse, error) + HVals(ctx context.Context, in *HValsRequest, opts ...grpc.CallOption) (*ArrayResponse, error) + HMGet(ctx context.Context, in *HMGetRequest, opts ...grpc.CallOption) (*OptionalArrayResponse, error) + SAdd(ctx context.Context, in *SAddRequest, opts ...grpc.CallOption) (*IntResponse, error) + SRem(ctx context.Context, in *SRemRequest, opts ...grpc.CallOption) (*IntResponse, error) + SMembers(ctx context.Context, in *SMembersRequest, opts ...grpc.CallOption) (*KeysResponse, error) + SIsMember(ctx context.Context, in *SIsMemberRequest, opts ...grpc.CallOption) (*BoolResponse, error) + SCard(ctx context.Context, in *SCardRequest, opts ...grpc.CallOption) (*IntResponse, error) + ZAdd(ctx context.Context, in *ZAddRequest, opts ...grpc.CallOption) (*IntResponse, error) + ZRem(ctx context.Context, in *ZRemRequest, opts ...grpc.CallOption) (*IntResponse, error) + ZScore(ctx context.Context, in *ZScoreRequest, opts ...grpc.CallOption) (*OptionalFloatResponse, error) + ZRank(ctx context.Context, in *ZRankRequest, opts ...grpc.CallOption) (*OptionalIntResponse, error) + ZCard(ctx context.Context, in *ZCardRequest, opts ...grpc.CallOption) (*IntResponse, error) + ZRange(ctx context.Context, in *ZRangeRequest, opts ...grpc.CallOption) (*ZRangeResponse, error) + VAdd(ctx context.Context, in *VAddRequest, opts ...grpc.CallOption) (*BoolResponse, error) + VSim(ctx context.Context, in *VSimRequest, opts ...grpc.CallOption) (*VSimResponse, error) + VRem(ctx context.Context, in *VRemRequest, opts ...grpc.CallOption) (*BoolResponse, error) + VGet(ctx context.Context, in *VGetRequest, opts ...grpc.CallOption) (*VGetResponse, error) + VCard(ctx context.Context, in *VCardRequest, opts ...grpc.CallOption) (*IntResponse, error) + VDim(ctx context.Context, in *VDimRequest, opts ...grpc.CallOption) (*IntResponse, error) + VInfo(ctx context.Context, in *VInfoRequest, opts ...grpc.CallOption) (*VInfoResponse, error) + Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) + FlushDb(ctx context.Context, in *FlushDbRequest, opts ...grpc.CallOption) (*StatusResponse, error) + DbSize(ctx context.Context, in *DbSizeRequest, opts ...grpc.CallOption) (*IntResponse, error) + Info(ctx context.Context, in *InfoRequest, opts ...grpc.CallOption) (*InfoResponse, error) + Pipeline(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[PipelineRequest, PipelineResponse], error) +} + +type emberCacheClient struct { + cc grpc.ClientConnInterface +} + +func NewEmberCacheClient(cc grpc.ClientConnInterface) EmberCacheClient { + return &emberCacheClient{cc} +} + +func (c *emberCacheClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetResponse) + err := c.cc.Invoke(ctx, EmberCache_Get_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Set(ctx context.Context, in *SetRequest, opts ...grpc.CallOption) (*SetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SetResponse) + err := c.cc.Invoke(ctx, EmberCache_Set_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Del(ctx context.Context, in *DelRequest, opts ...grpc.CallOption) (*DelResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(DelResponse) + err := c.cc.Invoke(ctx, EmberCache_Del_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) MGet(ctx context.Context, in *MGetRequest, opts ...grpc.CallOption) (*MGetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(MGetResponse) + err := c.cc.Invoke(ctx, EmberCache_MGet_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) MSet(ctx context.Context, in *MSetRequest, opts ...grpc.CallOption) (*MSetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(MSetResponse) + err := c.cc.Invoke(ctx, EmberCache_MSet_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Incr(ctx context.Context, in *IncrRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_Incr_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) IncrBy(ctx context.Context, in *IncrByRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_IncrBy_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) DecrBy(ctx context.Context, in *DecrByRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_DecrBy_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) IncrByFloat(ctx context.Context, in *IncrByFloatRequest, opts ...grpc.CallOption) (*FloatResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(FloatResponse) + err := c.cc.Invoke(ctx, EmberCache_IncrByFloat_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Append(ctx context.Context, in *AppendRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_Append_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Strlen(ctx context.Context, in *StrlenRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_Strlen_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Exists(ctx context.Context, in *ExistsRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_Exists_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Expire(ctx context.Context, in *ExpireRequest, opts ...grpc.CallOption) (*BoolResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(BoolResponse) + err := c.cc.Invoke(ctx, EmberCache_Expire_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) PExpire(ctx context.Context, in *PExpireRequest, opts ...grpc.CallOption) (*BoolResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(BoolResponse) + err := c.cc.Invoke(ctx, EmberCache_PExpire_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Persist(ctx context.Context, in *PersistRequest, opts ...grpc.CallOption) (*BoolResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(BoolResponse) + err := c.cc.Invoke(ctx, EmberCache_Persist_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Ttl(ctx context.Context, in *TtlRequest, opts ...grpc.CallOption) (*TtlResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(TtlResponse) + err := c.cc.Invoke(ctx, EmberCache_Ttl_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) PTtl(ctx context.Context, in *PTtlRequest, opts ...grpc.CallOption) (*TtlResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(TtlResponse) + err := c.cc.Invoke(ctx, EmberCache_PTtl_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Type(ctx context.Context, in *TypeRequest, opts ...grpc.CallOption) (*TypeResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(TypeResponse) + err := c.cc.Invoke(ctx, EmberCache_Type_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Keys(ctx context.Context, in *KeysRequest, opts ...grpc.CallOption) (*KeysResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(KeysResponse) + err := c.cc.Invoke(ctx, EmberCache_Keys_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Rename(ctx context.Context, in *RenameRequest, opts ...grpc.CallOption) (*StatusResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(StatusResponse) + err := c.cc.Invoke(ctx, EmberCache_Rename_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Scan(ctx context.Context, in *ScanRequest, opts ...grpc.CallOption) (*ScanResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ScanResponse) + err := c.cc.Invoke(ctx, EmberCache_Scan_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) LPush(ctx context.Context, in *LPushRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_LPush_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) RPush(ctx context.Context, in *RPushRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_RPush_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) LPop(ctx context.Context, in *LPopRequest, opts ...grpc.CallOption) (*GetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetResponse) + err := c.cc.Invoke(ctx, EmberCache_LPop_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) RPop(ctx context.Context, in *RPopRequest, opts ...grpc.CallOption) (*GetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetResponse) + err := c.cc.Invoke(ctx, EmberCache_RPop_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) LRange(ctx context.Context, in *LRangeRequest, opts ...grpc.CallOption) (*ArrayResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ArrayResponse) + err := c.cc.Invoke(ctx, EmberCache_LRange_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) LLen(ctx context.Context, in *LLenRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_LLen_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) HSet(ctx context.Context, in *HSetRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_HSet_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) HGet(ctx context.Context, in *HGetRequest, opts ...grpc.CallOption) (*GetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetResponse) + err := c.cc.Invoke(ctx, EmberCache_HGet_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) HGetAll(ctx context.Context, in *HGetAllRequest, opts ...grpc.CallOption) (*HashResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HashResponse) + err := c.cc.Invoke(ctx, EmberCache_HGetAll_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) HDel(ctx context.Context, in *HDelRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_HDel_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) HExists(ctx context.Context, in *HExistsRequest, opts ...grpc.CallOption) (*BoolResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(BoolResponse) + err := c.cc.Invoke(ctx, EmberCache_HExists_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) HLen(ctx context.Context, in *HLenRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_HLen_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) HIncrBy(ctx context.Context, in *HIncrByRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_HIncrBy_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) HKeys(ctx context.Context, in *HKeysRequest, opts ...grpc.CallOption) (*KeysResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(KeysResponse) + err := c.cc.Invoke(ctx, EmberCache_HKeys_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) HVals(ctx context.Context, in *HValsRequest, opts ...grpc.CallOption) (*ArrayResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ArrayResponse) + err := c.cc.Invoke(ctx, EmberCache_HVals_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) HMGet(ctx context.Context, in *HMGetRequest, opts ...grpc.CallOption) (*OptionalArrayResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(OptionalArrayResponse) + err := c.cc.Invoke(ctx, EmberCache_HMGet_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) SAdd(ctx context.Context, in *SAddRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_SAdd_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) SRem(ctx context.Context, in *SRemRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_SRem_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) SMembers(ctx context.Context, in *SMembersRequest, opts ...grpc.CallOption) (*KeysResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(KeysResponse) + err := c.cc.Invoke(ctx, EmberCache_SMembers_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) SIsMember(ctx context.Context, in *SIsMemberRequest, opts ...grpc.CallOption) (*BoolResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(BoolResponse) + err := c.cc.Invoke(ctx, EmberCache_SIsMember_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) SCard(ctx context.Context, in *SCardRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_SCard_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) ZAdd(ctx context.Context, in *ZAddRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_ZAdd_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) ZRem(ctx context.Context, in *ZRemRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_ZRem_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) ZScore(ctx context.Context, in *ZScoreRequest, opts ...grpc.CallOption) (*OptionalFloatResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(OptionalFloatResponse) + err := c.cc.Invoke(ctx, EmberCache_ZScore_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) ZRank(ctx context.Context, in *ZRankRequest, opts ...grpc.CallOption) (*OptionalIntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(OptionalIntResponse) + err := c.cc.Invoke(ctx, EmberCache_ZRank_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) ZCard(ctx context.Context, in *ZCardRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_ZCard_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) ZRange(ctx context.Context, in *ZRangeRequest, opts ...grpc.CallOption) (*ZRangeResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ZRangeResponse) + err := c.cc.Invoke(ctx, EmberCache_ZRange_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) VAdd(ctx context.Context, in *VAddRequest, opts ...grpc.CallOption) (*BoolResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(BoolResponse) + err := c.cc.Invoke(ctx, EmberCache_VAdd_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) VSim(ctx context.Context, in *VSimRequest, opts ...grpc.CallOption) (*VSimResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(VSimResponse) + err := c.cc.Invoke(ctx, EmberCache_VSim_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) VRem(ctx context.Context, in *VRemRequest, opts ...grpc.CallOption) (*BoolResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(BoolResponse) + err := c.cc.Invoke(ctx, EmberCache_VRem_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) VGet(ctx context.Context, in *VGetRequest, opts ...grpc.CallOption) (*VGetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(VGetResponse) + err := c.cc.Invoke(ctx, EmberCache_VGet_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) VCard(ctx context.Context, in *VCardRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_VCard_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) VDim(ctx context.Context, in *VDimRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_VDim_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) VInfo(ctx context.Context, in *VInfoRequest, opts ...grpc.CallOption) (*VInfoResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(VInfoResponse) + err := c.cc.Invoke(ctx, EmberCache_VInfo_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(PingResponse) + err := c.cc.Invoke(ctx, EmberCache_Ping_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) FlushDb(ctx context.Context, in *FlushDbRequest, opts ...grpc.CallOption) (*StatusResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(StatusResponse) + err := c.cc.Invoke(ctx, EmberCache_FlushDb_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) DbSize(ctx context.Context, in *DbSizeRequest, opts ...grpc.CallOption) (*IntResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(IntResponse) + err := c.cc.Invoke(ctx, EmberCache_DbSize_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Info(ctx context.Context, in *InfoRequest, opts ...grpc.CallOption) (*InfoResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(InfoResponse) + err := c.cc.Invoke(ctx, EmberCache_Info_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *emberCacheClient) Pipeline(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[PipelineRequest, PipelineResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &EmberCache_ServiceDesc.Streams[0], EmberCache_Pipeline_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[PipelineRequest, PipelineResponse]{ClientStream: stream} + return x, nil +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type EmberCache_PipelineClient = grpc.BidiStreamingClient[PipelineRequest, PipelineResponse] + +// EmberCacheServer is the server API for EmberCache service. +// All implementations must embed UnimplementedEmberCacheServer +// for forward compatibility. +// +// EmberCache provides a gRPC interface to ember's key-value store. +// all commands route through the same engine as RESP3, so behavior +// is identical regardless of protocol. +type EmberCacheServer interface { + Get(context.Context, *GetRequest) (*GetResponse, error) + Set(context.Context, *SetRequest) (*SetResponse, error) + Del(context.Context, *DelRequest) (*DelResponse, error) + MGet(context.Context, *MGetRequest) (*MGetResponse, error) + MSet(context.Context, *MSetRequest) (*MSetResponse, error) + Incr(context.Context, *IncrRequest) (*IntResponse, error) + IncrBy(context.Context, *IncrByRequest) (*IntResponse, error) + DecrBy(context.Context, *DecrByRequest) (*IntResponse, error) + IncrByFloat(context.Context, *IncrByFloatRequest) (*FloatResponse, error) + Append(context.Context, *AppendRequest) (*IntResponse, error) + Strlen(context.Context, *StrlenRequest) (*IntResponse, error) + Exists(context.Context, *ExistsRequest) (*IntResponse, error) + Expire(context.Context, *ExpireRequest) (*BoolResponse, error) + PExpire(context.Context, *PExpireRequest) (*BoolResponse, error) + Persist(context.Context, *PersistRequest) (*BoolResponse, error) + Ttl(context.Context, *TtlRequest) (*TtlResponse, error) + PTtl(context.Context, *PTtlRequest) (*TtlResponse, error) + Type(context.Context, *TypeRequest) (*TypeResponse, error) + Keys(context.Context, *KeysRequest) (*KeysResponse, error) + Rename(context.Context, *RenameRequest) (*StatusResponse, error) + Scan(context.Context, *ScanRequest) (*ScanResponse, error) + LPush(context.Context, *LPushRequest) (*IntResponse, error) + RPush(context.Context, *RPushRequest) (*IntResponse, error) + LPop(context.Context, *LPopRequest) (*GetResponse, error) + RPop(context.Context, *RPopRequest) (*GetResponse, error) + LRange(context.Context, *LRangeRequest) (*ArrayResponse, error) + LLen(context.Context, *LLenRequest) (*IntResponse, error) + HSet(context.Context, *HSetRequest) (*IntResponse, error) + HGet(context.Context, *HGetRequest) (*GetResponse, error) + HGetAll(context.Context, *HGetAllRequest) (*HashResponse, error) + HDel(context.Context, *HDelRequest) (*IntResponse, error) + HExists(context.Context, *HExistsRequest) (*BoolResponse, error) + HLen(context.Context, *HLenRequest) (*IntResponse, error) + HIncrBy(context.Context, *HIncrByRequest) (*IntResponse, error) + HKeys(context.Context, *HKeysRequest) (*KeysResponse, error) + HVals(context.Context, *HValsRequest) (*ArrayResponse, error) + HMGet(context.Context, *HMGetRequest) (*OptionalArrayResponse, error) + SAdd(context.Context, *SAddRequest) (*IntResponse, error) + SRem(context.Context, *SRemRequest) (*IntResponse, error) + SMembers(context.Context, *SMembersRequest) (*KeysResponse, error) + SIsMember(context.Context, *SIsMemberRequest) (*BoolResponse, error) + SCard(context.Context, *SCardRequest) (*IntResponse, error) + ZAdd(context.Context, *ZAddRequest) (*IntResponse, error) + ZRem(context.Context, *ZRemRequest) (*IntResponse, error) + ZScore(context.Context, *ZScoreRequest) (*OptionalFloatResponse, error) + ZRank(context.Context, *ZRankRequest) (*OptionalIntResponse, error) + ZCard(context.Context, *ZCardRequest) (*IntResponse, error) + ZRange(context.Context, *ZRangeRequest) (*ZRangeResponse, error) + VAdd(context.Context, *VAddRequest) (*BoolResponse, error) + VSim(context.Context, *VSimRequest) (*VSimResponse, error) + VRem(context.Context, *VRemRequest) (*BoolResponse, error) + VGet(context.Context, *VGetRequest) (*VGetResponse, error) + VCard(context.Context, *VCardRequest) (*IntResponse, error) + VDim(context.Context, *VDimRequest) (*IntResponse, error) + VInfo(context.Context, *VInfoRequest) (*VInfoResponse, error) + Ping(context.Context, *PingRequest) (*PingResponse, error) + FlushDb(context.Context, *FlushDbRequest) (*StatusResponse, error) + DbSize(context.Context, *DbSizeRequest) (*IntResponse, error) + Info(context.Context, *InfoRequest) (*InfoResponse, error) + Pipeline(grpc.BidiStreamingServer[PipelineRequest, PipelineResponse]) error + mustEmbedUnimplementedEmberCacheServer() +} + +// UnimplementedEmberCacheServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedEmberCacheServer struct{} + +func (UnimplementedEmberCacheServer) Get(context.Context, *GetRequest) (*GetResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Get not implemented") +} +func (UnimplementedEmberCacheServer) Set(context.Context, *SetRequest) (*SetResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Set not implemented") +} +func (UnimplementedEmberCacheServer) Del(context.Context, *DelRequest) (*DelResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Del not implemented") +} +func (UnimplementedEmberCacheServer) MGet(context.Context, *MGetRequest) (*MGetResponse, error) { + return nil, status.Error(codes.Unimplemented, "method MGet not implemented") +} +func (UnimplementedEmberCacheServer) MSet(context.Context, *MSetRequest) (*MSetResponse, error) { + return nil, status.Error(codes.Unimplemented, "method MSet not implemented") +} +func (UnimplementedEmberCacheServer) Incr(context.Context, *IncrRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Incr not implemented") +} +func (UnimplementedEmberCacheServer) IncrBy(context.Context, *IncrByRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method IncrBy not implemented") +} +func (UnimplementedEmberCacheServer) DecrBy(context.Context, *DecrByRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method DecrBy not implemented") +} +func (UnimplementedEmberCacheServer) IncrByFloat(context.Context, *IncrByFloatRequest) (*FloatResponse, error) { + return nil, status.Error(codes.Unimplemented, "method IncrByFloat not implemented") +} +func (UnimplementedEmberCacheServer) Append(context.Context, *AppendRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Append not implemented") +} +func (UnimplementedEmberCacheServer) Strlen(context.Context, *StrlenRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Strlen not implemented") +} +func (UnimplementedEmberCacheServer) Exists(context.Context, *ExistsRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Exists not implemented") +} +func (UnimplementedEmberCacheServer) Expire(context.Context, *ExpireRequest) (*BoolResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Expire not implemented") +} +func (UnimplementedEmberCacheServer) PExpire(context.Context, *PExpireRequest) (*BoolResponse, error) { + return nil, status.Error(codes.Unimplemented, "method PExpire not implemented") +} +func (UnimplementedEmberCacheServer) Persist(context.Context, *PersistRequest) (*BoolResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Persist not implemented") +} +func (UnimplementedEmberCacheServer) Ttl(context.Context, *TtlRequest) (*TtlResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Ttl not implemented") +} +func (UnimplementedEmberCacheServer) PTtl(context.Context, *PTtlRequest) (*TtlResponse, error) { + return nil, status.Error(codes.Unimplemented, "method PTtl not implemented") +} +func (UnimplementedEmberCacheServer) Type(context.Context, *TypeRequest) (*TypeResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Type not implemented") +} +func (UnimplementedEmberCacheServer) Keys(context.Context, *KeysRequest) (*KeysResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Keys not implemented") +} +func (UnimplementedEmberCacheServer) Rename(context.Context, *RenameRequest) (*StatusResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Rename not implemented") +} +func (UnimplementedEmberCacheServer) Scan(context.Context, *ScanRequest) (*ScanResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Scan not implemented") +} +func (UnimplementedEmberCacheServer) LPush(context.Context, *LPushRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method LPush not implemented") +} +func (UnimplementedEmberCacheServer) RPush(context.Context, *RPushRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RPush not implemented") +} +func (UnimplementedEmberCacheServer) LPop(context.Context, *LPopRequest) (*GetResponse, error) { + return nil, status.Error(codes.Unimplemented, "method LPop not implemented") +} +func (UnimplementedEmberCacheServer) RPop(context.Context, *RPopRequest) (*GetResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RPop not implemented") +} +func (UnimplementedEmberCacheServer) LRange(context.Context, *LRangeRequest) (*ArrayResponse, error) { + return nil, status.Error(codes.Unimplemented, "method LRange not implemented") +} +func (UnimplementedEmberCacheServer) LLen(context.Context, *LLenRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method LLen not implemented") +} +func (UnimplementedEmberCacheServer) HSet(context.Context, *HSetRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method HSet not implemented") +} +func (UnimplementedEmberCacheServer) HGet(context.Context, *HGetRequest) (*GetResponse, error) { + return nil, status.Error(codes.Unimplemented, "method HGet not implemented") +} +func (UnimplementedEmberCacheServer) HGetAll(context.Context, *HGetAllRequest) (*HashResponse, error) { + return nil, status.Error(codes.Unimplemented, "method HGetAll not implemented") +} +func (UnimplementedEmberCacheServer) HDel(context.Context, *HDelRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method HDel not implemented") +} +func (UnimplementedEmberCacheServer) HExists(context.Context, *HExistsRequest) (*BoolResponse, error) { + return nil, status.Error(codes.Unimplemented, "method HExists not implemented") +} +func (UnimplementedEmberCacheServer) HLen(context.Context, *HLenRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method HLen not implemented") +} +func (UnimplementedEmberCacheServer) HIncrBy(context.Context, *HIncrByRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method HIncrBy not implemented") +} +func (UnimplementedEmberCacheServer) HKeys(context.Context, *HKeysRequest) (*KeysResponse, error) { + return nil, status.Error(codes.Unimplemented, "method HKeys not implemented") +} +func (UnimplementedEmberCacheServer) HVals(context.Context, *HValsRequest) (*ArrayResponse, error) { + return nil, status.Error(codes.Unimplemented, "method HVals not implemented") +} +func (UnimplementedEmberCacheServer) HMGet(context.Context, *HMGetRequest) (*OptionalArrayResponse, error) { + return nil, status.Error(codes.Unimplemented, "method HMGet not implemented") +} +func (UnimplementedEmberCacheServer) SAdd(context.Context, *SAddRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method SAdd not implemented") +} +func (UnimplementedEmberCacheServer) SRem(context.Context, *SRemRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method SRem not implemented") +} +func (UnimplementedEmberCacheServer) SMembers(context.Context, *SMembersRequest) (*KeysResponse, error) { + return nil, status.Error(codes.Unimplemented, "method SMembers not implemented") +} +func (UnimplementedEmberCacheServer) SIsMember(context.Context, *SIsMemberRequest) (*BoolResponse, error) { + return nil, status.Error(codes.Unimplemented, "method SIsMember not implemented") +} +func (UnimplementedEmberCacheServer) SCard(context.Context, *SCardRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method SCard not implemented") +} +func (UnimplementedEmberCacheServer) ZAdd(context.Context, *ZAddRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ZAdd not implemented") +} +func (UnimplementedEmberCacheServer) ZRem(context.Context, *ZRemRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ZRem not implemented") +} +func (UnimplementedEmberCacheServer) ZScore(context.Context, *ZScoreRequest) (*OptionalFloatResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ZScore not implemented") +} +func (UnimplementedEmberCacheServer) ZRank(context.Context, *ZRankRequest) (*OptionalIntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ZRank not implemented") +} +func (UnimplementedEmberCacheServer) ZCard(context.Context, *ZCardRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ZCard not implemented") +} +func (UnimplementedEmberCacheServer) ZRange(context.Context, *ZRangeRequest) (*ZRangeResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ZRange not implemented") +} +func (UnimplementedEmberCacheServer) VAdd(context.Context, *VAddRequest) (*BoolResponse, error) { + return nil, status.Error(codes.Unimplemented, "method VAdd not implemented") +} +func (UnimplementedEmberCacheServer) VSim(context.Context, *VSimRequest) (*VSimResponse, error) { + return nil, status.Error(codes.Unimplemented, "method VSim not implemented") +} +func (UnimplementedEmberCacheServer) VRem(context.Context, *VRemRequest) (*BoolResponse, error) { + return nil, status.Error(codes.Unimplemented, "method VRem not implemented") +} +func (UnimplementedEmberCacheServer) VGet(context.Context, *VGetRequest) (*VGetResponse, error) { + return nil, status.Error(codes.Unimplemented, "method VGet not implemented") +} +func (UnimplementedEmberCacheServer) VCard(context.Context, *VCardRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method VCard not implemented") +} +func (UnimplementedEmberCacheServer) VDim(context.Context, *VDimRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method VDim not implemented") +} +func (UnimplementedEmberCacheServer) VInfo(context.Context, *VInfoRequest) (*VInfoResponse, error) { + return nil, status.Error(codes.Unimplemented, "method VInfo not implemented") +} +func (UnimplementedEmberCacheServer) Ping(context.Context, *PingRequest) (*PingResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Ping not implemented") +} +func (UnimplementedEmberCacheServer) FlushDb(context.Context, *FlushDbRequest) (*StatusResponse, error) { + return nil, status.Error(codes.Unimplemented, "method FlushDb not implemented") +} +func (UnimplementedEmberCacheServer) DbSize(context.Context, *DbSizeRequest) (*IntResponse, error) { + return nil, status.Error(codes.Unimplemented, "method DbSize not implemented") +} +func (UnimplementedEmberCacheServer) Info(context.Context, *InfoRequest) (*InfoResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Info not implemented") +} +func (UnimplementedEmberCacheServer) Pipeline(grpc.BidiStreamingServer[PipelineRequest, PipelineResponse]) error { + return status.Error(codes.Unimplemented, "method Pipeline not implemented") +} +func (UnimplementedEmberCacheServer) mustEmbedUnimplementedEmberCacheServer() {} +func (UnimplementedEmberCacheServer) testEmbeddedByValue() {} + +// UnsafeEmberCacheServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to EmberCacheServer will +// result in compilation errors. +type UnsafeEmberCacheServer interface { + mustEmbedUnimplementedEmberCacheServer() +} + +func RegisterEmberCacheServer(s grpc.ServiceRegistrar, srv EmberCacheServer) { + // If the following call panics, it indicates UnimplementedEmberCacheServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&EmberCache_ServiceDesc, srv) +} + +func _EmberCache_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Get(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Get_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Get(ctx, req.(*GetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Set_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Set(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Set_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Set(ctx, req.(*SetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Del_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DelRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Del(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Del_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Del(ctx, req.(*DelRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_MGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MGetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).MGet(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_MGet_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).MGet(ctx, req.(*MGetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_MSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MSetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).MSet(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_MSet_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).MSet(ctx, req.(*MSetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Incr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(IncrRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Incr(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Incr_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Incr(ctx, req.(*IncrRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_IncrBy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(IncrByRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).IncrBy(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_IncrBy_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).IncrBy(ctx, req.(*IncrByRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_DecrBy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DecrByRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).DecrBy(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_DecrBy_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).DecrBy(ctx, req.(*DecrByRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_IncrByFloat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(IncrByFloatRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).IncrByFloat(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_IncrByFloat_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).IncrByFloat(ctx, req.(*IncrByFloatRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Append_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AppendRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Append(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Append_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Append(ctx, req.(*AppendRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Strlen_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StrlenRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Strlen(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Strlen_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Strlen(ctx, req.(*StrlenRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Exists_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ExistsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Exists(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Exists_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Exists(ctx, req.(*ExistsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Expire_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ExpireRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Expire(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Expire_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Expire(ctx, req.(*ExpireRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_PExpire_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PExpireRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).PExpire(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_PExpire_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).PExpire(ctx, req.(*PExpireRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Persist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PersistRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Persist(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Persist_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Persist(ctx, req.(*PersistRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Ttl_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TtlRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Ttl(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Ttl_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Ttl(ctx, req.(*TtlRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_PTtl_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PTtlRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).PTtl(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_PTtl_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).PTtl(ctx, req.(*PTtlRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Type_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TypeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Type(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Type_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Type(ctx, req.(*TypeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Keys_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(KeysRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Keys(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Keys_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Keys(ctx, req.(*KeysRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Rename_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RenameRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Rename(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Rename_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Rename(ctx, req.(*RenameRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Scan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ScanRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Scan(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Scan_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Scan(ctx, req.(*ScanRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_LPush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LPushRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).LPush(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_LPush_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).LPush(ctx, req.(*LPushRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_RPush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RPushRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).RPush(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_RPush_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).RPush(ctx, req.(*RPushRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_LPop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LPopRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).LPop(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_LPop_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).LPop(ctx, req.(*LPopRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_RPop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RPopRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).RPop(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_RPop_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).RPop(ctx, req.(*RPopRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_LRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LRangeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).LRange(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_LRange_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).LRange(ctx, req.(*LRangeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_LLen_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LLenRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).LLen(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_LLen_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).LLen(ctx, req.(*LLenRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_HSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HSetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).HSet(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_HSet_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).HSet(ctx, req.(*HSetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_HGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HGetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).HGet(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_HGet_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).HGet(ctx, req.(*HGetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_HGetAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HGetAllRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).HGetAll(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_HGetAll_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).HGetAll(ctx, req.(*HGetAllRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_HDel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HDelRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).HDel(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_HDel_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).HDel(ctx, req.(*HDelRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_HExists_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HExistsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).HExists(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_HExists_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).HExists(ctx, req.(*HExistsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_HLen_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HLenRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).HLen(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_HLen_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).HLen(ctx, req.(*HLenRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_HIncrBy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HIncrByRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).HIncrBy(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_HIncrBy_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).HIncrBy(ctx, req.(*HIncrByRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_HKeys_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HKeysRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).HKeys(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_HKeys_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).HKeys(ctx, req.(*HKeysRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_HVals_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HValsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).HVals(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_HVals_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).HVals(ctx, req.(*HValsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_HMGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(HMGetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).HMGet(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_HMGet_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).HMGet(ctx, req.(*HMGetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_SAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SAddRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).SAdd(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_SAdd_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).SAdd(ctx, req.(*SAddRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_SRem_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SRemRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).SRem(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_SRem_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).SRem(ctx, req.(*SRemRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_SMembers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SMembersRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).SMembers(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_SMembers_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).SMembers(ctx, req.(*SMembersRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_SIsMember_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SIsMemberRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).SIsMember(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_SIsMember_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).SIsMember(ctx, req.(*SIsMemberRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_SCard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SCardRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).SCard(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_SCard_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).SCard(ctx, req.(*SCardRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_ZAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ZAddRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).ZAdd(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_ZAdd_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).ZAdd(ctx, req.(*ZAddRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_ZRem_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ZRemRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).ZRem(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_ZRem_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).ZRem(ctx, req.(*ZRemRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_ZScore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ZScoreRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).ZScore(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_ZScore_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).ZScore(ctx, req.(*ZScoreRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_ZRank_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ZRankRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).ZRank(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_ZRank_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).ZRank(ctx, req.(*ZRankRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_ZCard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ZCardRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).ZCard(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_ZCard_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).ZCard(ctx, req.(*ZCardRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_ZRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ZRangeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).ZRange(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_ZRange_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).ZRange(ctx, req.(*ZRangeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_VAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VAddRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).VAdd(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_VAdd_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).VAdd(ctx, req.(*VAddRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_VSim_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VSimRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).VSim(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_VSim_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).VSim(ctx, req.(*VSimRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_VRem_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VRemRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).VRem(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_VRem_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).VRem(ctx, req.(*VRemRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_VGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VGetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).VGet(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_VGet_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).VGet(ctx, req.(*VGetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_VCard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VCardRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).VCard(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_VCard_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).VCard(ctx, req.(*VCardRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_VDim_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VDimRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).VDim(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_VDim_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).VDim(ctx, req.(*VDimRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_VInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).VInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_VInfo_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).VInfo(ctx, req.(*VInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PingRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Ping(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Ping_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Ping(ctx, req.(*PingRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_FlushDb_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(FlushDbRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).FlushDb(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_FlushDb_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).FlushDb(ctx, req.(*FlushDbRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_DbSize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DbSizeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).DbSize(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_DbSize_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).DbSize(ctx, req.(*DbSizeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Info_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(InfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(EmberCacheServer).Info(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: EmberCache_Info_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(EmberCacheServer).Info(ctx, req.(*InfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _EmberCache_Pipeline_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(EmberCacheServer).Pipeline(&grpc.GenericServerStream[PipelineRequest, PipelineResponse]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type EmberCache_PipelineServer = grpc.BidiStreamingServer[PipelineRequest, PipelineResponse] + +// EmberCache_ServiceDesc is the grpc.ServiceDesc for EmberCache service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var EmberCache_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "ember.v1.EmberCache", + HandlerType: (*EmberCacheServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Get", + Handler: _EmberCache_Get_Handler, + }, + { + MethodName: "Set", + Handler: _EmberCache_Set_Handler, + }, + { + MethodName: "Del", + Handler: _EmberCache_Del_Handler, + }, + { + MethodName: "MGet", + Handler: _EmberCache_MGet_Handler, + }, + { + MethodName: "MSet", + Handler: _EmberCache_MSet_Handler, + }, + { + MethodName: "Incr", + Handler: _EmberCache_Incr_Handler, + }, + { + MethodName: "IncrBy", + Handler: _EmberCache_IncrBy_Handler, + }, + { + MethodName: "DecrBy", + Handler: _EmberCache_DecrBy_Handler, + }, + { + MethodName: "IncrByFloat", + Handler: _EmberCache_IncrByFloat_Handler, + }, + { + MethodName: "Append", + Handler: _EmberCache_Append_Handler, + }, + { + MethodName: "Strlen", + Handler: _EmberCache_Strlen_Handler, + }, + { + MethodName: "Exists", + Handler: _EmberCache_Exists_Handler, + }, + { + MethodName: "Expire", + Handler: _EmberCache_Expire_Handler, + }, + { + MethodName: "PExpire", + Handler: _EmberCache_PExpire_Handler, + }, + { + MethodName: "Persist", + Handler: _EmberCache_Persist_Handler, + }, + { + MethodName: "Ttl", + Handler: _EmberCache_Ttl_Handler, + }, + { + MethodName: "PTtl", + Handler: _EmberCache_PTtl_Handler, + }, + { + MethodName: "Type", + Handler: _EmberCache_Type_Handler, + }, + { + MethodName: "Keys", + Handler: _EmberCache_Keys_Handler, + }, + { + MethodName: "Rename", + Handler: _EmberCache_Rename_Handler, + }, + { + MethodName: "Scan", + Handler: _EmberCache_Scan_Handler, + }, + { + MethodName: "LPush", + Handler: _EmberCache_LPush_Handler, + }, + { + MethodName: "RPush", + Handler: _EmberCache_RPush_Handler, + }, + { + MethodName: "LPop", + Handler: _EmberCache_LPop_Handler, + }, + { + MethodName: "RPop", + Handler: _EmberCache_RPop_Handler, + }, + { + MethodName: "LRange", + Handler: _EmberCache_LRange_Handler, + }, + { + MethodName: "LLen", + Handler: _EmberCache_LLen_Handler, + }, + { + MethodName: "HSet", + Handler: _EmberCache_HSet_Handler, + }, + { + MethodName: "HGet", + Handler: _EmberCache_HGet_Handler, + }, + { + MethodName: "HGetAll", + Handler: _EmberCache_HGetAll_Handler, + }, + { + MethodName: "HDel", + Handler: _EmberCache_HDel_Handler, + }, + { + MethodName: "HExists", + Handler: _EmberCache_HExists_Handler, + }, + { + MethodName: "HLen", + Handler: _EmberCache_HLen_Handler, + }, + { + MethodName: "HIncrBy", + Handler: _EmberCache_HIncrBy_Handler, + }, + { + MethodName: "HKeys", + Handler: _EmberCache_HKeys_Handler, + }, + { + MethodName: "HVals", + Handler: _EmberCache_HVals_Handler, + }, + { + MethodName: "HMGet", + Handler: _EmberCache_HMGet_Handler, + }, + { + MethodName: "SAdd", + Handler: _EmberCache_SAdd_Handler, + }, + { + MethodName: "SRem", + Handler: _EmberCache_SRem_Handler, + }, + { + MethodName: "SMembers", + Handler: _EmberCache_SMembers_Handler, + }, + { + MethodName: "SIsMember", + Handler: _EmberCache_SIsMember_Handler, + }, + { + MethodName: "SCard", + Handler: _EmberCache_SCard_Handler, + }, + { + MethodName: "ZAdd", + Handler: _EmberCache_ZAdd_Handler, + }, + { + MethodName: "ZRem", + Handler: _EmberCache_ZRem_Handler, + }, + { + MethodName: "ZScore", + Handler: _EmberCache_ZScore_Handler, + }, + { + MethodName: "ZRank", + Handler: _EmberCache_ZRank_Handler, + }, + { + MethodName: "ZCard", + Handler: _EmberCache_ZCard_Handler, + }, + { + MethodName: "ZRange", + Handler: _EmberCache_ZRange_Handler, + }, + { + MethodName: "VAdd", + Handler: _EmberCache_VAdd_Handler, + }, + { + MethodName: "VSim", + Handler: _EmberCache_VSim_Handler, + }, + { + MethodName: "VRem", + Handler: _EmberCache_VRem_Handler, + }, + { + MethodName: "VGet", + Handler: _EmberCache_VGet_Handler, + }, + { + MethodName: "VCard", + Handler: _EmberCache_VCard_Handler, + }, + { + MethodName: "VDim", + Handler: _EmberCache_VDim_Handler, + }, + { + MethodName: "VInfo", + Handler: _EmberCache_VInfo_Handler, + }, + { + MethodName: "Ping", + Handler: _EmberCache_Ping_Handler, + }, + { + MethodName: "FlushDb", + Handler: _EmberCache_FlushDb_Handler, + }, + { + MethodName: "DbSize", + Handler: _EmberCache_DbSize_Handler, + }, + { + MethodName: "Info", + Handler: _EmberCache_Info_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "Pipeline", + Handler: _EmberCache_Pipeline_Handler, + ServerStreams: true, + ClientStreams: true, + }, + }, + Metadata: "ember/v1/ember.proto", +}