diff --git a/client/client.go b/client/client.go
index 7e5796d74..8da2414a3 100644
--- a/client/client.go
+++ b/client/client.go
@@ -1671,7 +1671,7 @@ type SchemaOptions struct {
 	CacheType      string        `json:"cacheType"`
 	CacheSize      uint          `json:"cacheSize"`
 	TimeQuantum    string        `json:"timeQuantum"`
-	Ttl            time.Duration `json:"ttl"`
+	TTL            time.Duration `json:"ttl"`
 	Min            pql.Decimal   `json:"min"`
 	Max            pql.Decimal   `json:"max"`
 	Scale          int64         `json:"scale"`
@@ -1696,7 +1696,7 @@ func (so SchemaOptions) asFieldOptions() *FieldOptions {
 		cacheSize:      int(so.CacheSize),
 		cacheType:      CacheType(so.CacheType),
 		timeQuantum:    TimeQuantum(so.TimeQuantum),
-		ttl:            so.Ttl,
+		ttl:            so.TTL,
 		min:            so.Min,
 		max:            so.Max,
 		scale:          so.Scale,
diff --git a/client/orm.go b/client/orm.go
index 5035cc59c..c02573ff5 100644
--- a/client/orm.go
+++ b/client/orm.go
@@ -752,8 +752,8 @@ func (fo FieldOptions) TimeQuantum() TimeQuantum {
 	return fo.timeQuantum
 }
 
-// Ttl returns the configured ttl for a time field.
-func (fo FieldOptions) Ttl() time.Duration {
+// TTL returns the configured ttl for a time field.
+func (fo FieldOptions) TTL() time.Duration {
 	return fo.ttl
 }
 
@@ -920,7 +920,7 @@ func OptFieldTypeTime(quantum TimeQuantum, opts ...bool) FieldOption {
 	}
 }
 
-func OptFieldTtl(dur time.Duration) FieldOption {
+func OptFieldTTL(dur time.Duration) FieldOption {
 	return func(options *FieldOptions) {
 		options.ttl = dur
 	}
diff --git a/client/orm_test.go b/client/orm_test.go
index 29256a23c..57a70f1cc 100644
--- a/client/orm_test.go
+++ b/client/orm_test.go
@@ -1026,8 +1026,8 @@ func TestORM(t *testing.T) {
 			0)
 	})
 
-	t.Run("TtlOptions", func(t *testing.T) {
-		field := sampleIndex.Field("ttl-field", OptFieldTypeTime(TimeQuantumDayHour, true), OptFieldTtl(0))
+	t.Run("TTLOptions", func(t *testing.T) {
+		field := sampleIndex.Field("ttl-field", OptFieldTypeTime(TimeQuantumDayHour, true), OptFieldTTL(0))
 		if true != field.Opts().NoStandardView() {
 			t.Fatalf("field noStandardView %v != %v", true, field.Opts().NoStandardView())
 		}
@@ -1222,8 +1222,8 @@ func compareFieldOptions(t *testing.T, opts *FieldOptions, fieldType FieldType,
 	if timeUnit != opts.TimeUnit() {
 		t.Fatalf("%s != %s", timeUnit, opts.TimeUnit())
 	}
-	if ttl != opts.Ttl() {
-		t.Fatalf("%s != %s", ttl, opts.Ttl())
+	if ttl != opts.TTL() {
+		t.Fatalf("%s != %s", ttl, opts.TTL())
 	}
 }
 
diff --git a/cmd/import.go b/cmd/import.go
index 77dfbb7f0..52f28a4aa 100644
--- a/cmd/import.go
+++ b/cmd/import.go
@@ -46,7 +46,7 @@ omitted. If it is present then its format should be YYYY-MM-DDTHH:MM.
 	flags.StringVar(&Importer.FieldOptions.CacheType, "field-cache-type", pilosa.CacheTypeRanked, "Specify the cache type for a set field on creation. One of: none, lru, ranked")
 	flags.Uint32Var(&Importer.FieldOptions.CacheSize, "field-cache-size", 50000, "Specify the cache size for a set field on creation")
 	flags.Var(&Importer.FieldOptions.TimeQuantum, "field-time-quantum", "Specify the time quantum for a time field on creation. One of: D, DH, H, M, MD, MDH, Y, YM, YMD, YMDH")
-	flags.DurationVarP(&Importer.FieldOptions.Ttl, "time-to-live", "t", 0, "Specify the time to live for views created by time quantum. Supported time unit: \"s\", \"m\", \"h\"") // \"ns\", \"us\" (or \"µs\"), \"ms\" also supported but ommitted for simplicity
+	flags.DurationVarP(&Importer.FieldOptions.TTL, "time-to-live", "t", 0, "Specify the time to live for views created by time quantum. Supported time unit: \"s\", \"m\", \"h\"") // \"ns\", \"us\" (or \"µs\"), \"ms\" also supported but ommitted for simplicity
 	flags.IntVarP(&Importer.BufferSize, "buffer-size", "s", 10000000, "Number of bits to buffer/sort before importing.")
 	flags.BoolVarP(&Importer.Sort, "sort", "", false, "Enables sorting before import.")
 	flags.BoolVarP(&Importer.CreateSchema, "create", "e", false, "Create the schema if it does not exist before import.")
diff --git a/encoding/proto/proto.go b/encoding/proto/proto.go
index d0e894cfe..4b9958f81 100644
--- a/encoding/proto/proto.go
+++ b/encoding/proto/proto.go
@@ -669,7 +669,7 @@ func (s Serializer) encodeFieldOptions(o *pilosa.FieldOptions) *pb.FieldOptions
 		Scale:        o.Scale,
 		BitDepth:     uint64(o.BitDepth),
 		TimeQuantum:  string(o.TimeQuantum),
-		Ttl:          o.Ttl.String(),
+		TTL:          o.TTL.String(),
 		TimeUnit:     string(o.TimeUnit),
 		Keys:         o.Keys,
 		ForeignIndex: o.ForeignIndex,
@@ -1073,11 +1073,11 @@ func (s Serializer) decodeFieldOptions(options *pb.FieldOptions, m *pilosa.Field
 	m.Scale = options.Scale
 	m.BitDepth = uint64(options.BitDepth)
 	m.TimeQuantum = pilosa.TimeQuantum(options.TimeQuantum)
-	ttlValue, err := time.ParseDuration(options.Ttl)
+	ttlValue, err := time.ParseDuration(options.TTL)
 	if err != nil {
 		ttlValue = 0
 	}
-	m.Ttl = ttlValue
+	m.TTL = ttlValue
 	m.TimeUnit = options.TimeUnit
 	m.Keys = options.Keys
 	m.ForeignIndex = options.ForeignIndex
diff --git a/field.go b/field.go
index 0d401a340..988a79186 100644
--- a/field.go
+++ b/field.go
@@ -303,7 +303,7 @@ func OptFieldTypeTime(timeQuantum TimeQuantum, ttl string, opt ...bool) FieldOpt
 		if err != nil {
 			return errors.Errorf("cannot parse ttl: %s", ttl)
 		}
-		fo.Ttl = ttlParsed
+		fo.TTL = ttlParsed
 		fo.NoStandardView = len(opt) >= 1 && opt[0]
 		return nil
 	}
@@ -685,9 +685,9 @@ func (f *Field) ForeignIndex() string {
 	return f.options.ForeignIndex
 }
 
-// Ttl returns the ttl of the field.
-func (f *Field) Ttl() time.Duration {
-	return f.options.Ttl
+// TTL returns the ttl of the field.
+func (f *Field) TTL() time.Duration {
+	return f.options.TTL
 }
 
 func (f *Field) bitDepth() (uint64, error) {
@@ -779,7 +779,7 @@ func (f *Field) applyOptions(opt FieldOptions) error {
 		f.options.Base = 0
 		f.options.BitDepth = 0
 		f.options.TimeQuantum = ""
-		f.options.Ttl = 0
+		f.options.TTL = 0
 		f.options.Keys = opt.Keys
 		f.options.ForeignIndex = opt.ForeignIndex
 	case FieldTypeInt, FieldTypeDecimal, FieldTypeTimestamp:
@@ -793,7 +793,7 @@ func (f *Field) applyOptions(opt FieldOptions) error {
 		f.options.BitDepth = opt.BitDepth
 		f.options.TimeUnit = opt.TimeUnit
 		f.options.TimeQuantum = ""
-		f.options.Ttl = 0
+		f.options.TTL = 0
 		f.options.Keys = opt.Keys
 		f.options.ForeignIndex = opt.ForeignIndex
 
@@ -827,7 +827,7 @@ func (f *Field) applyOptions(opt FieldOptions) error {
 			return ErrInvalidTimeQuantum
 		}
 		f.options.TimeQuantum = opt.TimeQuantum
-		f.options.Ttl = opt.Ttl
+		f.options.TTL = opt.TTL
 		f.options.ForeignIndex = opt.ForeignIndex
 	case FieldTypeBool:
 		f.options.Type = FieldTypeBool
@@ -838,7 +838,7 @@ func (f *Field) applyOptions(opt FieldOptions) error {
 		f.options.Base = 0
 		f.options.BitDepth = 0
 		f.options.TimeQuantum = ""
-		f.options.Ttl = 0
+		f.options.TTL = 0
 		f.options.Keys = false
 		f.options.ForeignIndex = ""
 	default:
@@ -1943,7 +1943,7 @@ type FieldOptions struct {
 	TimeUnit       string        `json:"timeUnit,omitempty"`
 	TimeQuantum    TimeQuantum   `json:"timeQuantum,omitempty"`
 	ForeignIndex   string        `json:"foreignIndex"`
-	Ttl            time.Duration `json:"ttl,omitempty"`
+	TTL            time.Duration `json:"ttl,omitempty"`
 }
 
 // newFieldOptions returns a new instance of FieldOptions
@@ -2062,13 +2062,13 @@ func (o *FieldOptions) MarshalJSON() ([]byte, error) {
 			TimeQuantum    TimeQuantum   `json:"timeQuantum"`
 			Keys           bool          `json:"keys"`
 			NoStandardView bool          `json:"noStandardView"`
-			Ttl            time.Duration `json:"Ttl"`
+			TTL            time.Duration `json:"ttl"`
 		}{
 			o.Type,
 			o.TimeQuantum,
 			o.Keys,
 			o.NoStandardView,
-			o.Ttl,
+			o.TTL,
 		})
 	case FieldTypeMutex:
 		return json.Marshal(struct {
diff --git a/field_test.go b/field_test.go
index 40697addb..e0623f999 100644
--- a/field_test.go
+++ b/field_test.go
@@ -280,7 +280,7 @@ func TestFieldInfoMarshal(t *testing.T) {
 		Options: pilosa.FieldOptions{Base: 0, BitDepth: 0x0, Min: pql.Decimal{Value: -4294967296,
 			Scale: 0}, Max: pql.Decimal{Value: 4294967296, Scale: 0}, Scale: 0, Keys: false,
 			NoStandardView: false, CacheType: "", Type: "timestamp", TimeUnit: "s",
-			TimeQuantum: "", ForeignIndex: "", Ttl: 0}, Cardinality: (*uint64)(nil)}
+			TimeQuantum: "", ForeignIndex: "", TTL: 0}, Cardinality: (*uint64)(nil)}
 	a, err := json.Marshal(f)
 	if err != nil {
 		t.Fatalf("unexpected error marshalling index info,  %v", err)
diff --git a/hack.go b/hack.go
index de4ff4279..b538eee03 100644
--- a/hack.go
+++ b/hack.go
@@ -52,11 +52,11 @@ func UnmarshalFieldOptions(name string, createdAt int64, buf []byte) (*FieldInfo
 	fi.Options.Base = pbi.Base
 	fi.Options.BitDepth = pbi.BitDepth
 	fi.Options.TimeQuantum = TimeQuantum(pbi.TimeQuantum)
-	ttlValue, err := time.ParseDuration(pbi.Ttl)
+	ttlValue, err := time.ParseDuration(pbi.TTL)
 	if err != nil {
 		ttlValue = 0
 	}
-	fi.Options.Ttl = ttlValue
+	fi.Options.TTL = ttlValue
 	fi.Options.Keys = pbi.Keys
 	fi.Options.NoStandardView = pbi.NoStandardView
 
diff --git a/http_handler.go b/http_handler.go
index 3328485b0..3c555ab5c 100644
--- a/http_handler.go
+++ b/http_handler.go
@@ -1625,8 +1625,8 @@ func fieldOptionsToFunctionalOpts(opt fieldOptions) []FieldOption {
 		}
 		fos = append(fos, OptFieldTypeTimestamp(opt.Epoch.UTC(), *opt.TimeUnit))
 	case FieldTypeTime:
-		if opt.Ttl != nil {
-			fos = append(fos, OptFieldTypeTime(*opt.TimeQuantum, *opt.Ttl, opt.NoStandardView))
+		if opt.TTL != nil {
+			fos = append(fos, OptFieldTypeTime(*opt.TimeQuantum, *opt.TTL, opt.NoStandardView))
 		} else {
 			fos = append(fos, OptFieldTypeTime(*opt.TimeQuantum, "0", opt.NoStandardView))
 		}
@@ -1755,7 +1755,7 @@ type fieldOptionSpec struct {
 	Epoch                  *time.Time `json:"epoch"`
 	Unit                   *string    `json:"unit"`
 	TimeQuantum            *string    `json:"time-quantum"`
-	Ttl                    *string    `json:"ttl"`
+	TTL                    *string    `json:"ttl"`
 }
 
 func fieldSpecToFieldOption(fSpec fieldSpec) fieldOptions {
@@ -1789,7 +1789,7 @@ func fieldSpecToFieldOption(fSpec fieldSpec) fieldOptions {
 		timeQuantumVal := TimeQuantum(*fSpec.FieldOptions.TimeQuantum)
 		opt.TimeQuantum = &timeQuantumVal
 	}
-	opt.Ttl = fSpec.FieldOptions.Ttl
+	opt.TTL = fSpec.FieldOptions.TTL
 
 	return opt
 }
@@ -1886,7 +1886,7 @@ type fieldOptions struct {
 	Keys           *bool        `json:"keys,omitempty"`
 	NoStandardView bool         `json:"noStandardView,omitempty"`
 	ForeignIndex   *string      `json:"foreignIndex,omitempty"`
-	Ttl            *string      `json:"ttl,omitempty"`
+	TTL            *string      `json:"ttl,omitempty"`
 }
 
 func (o *fieldOptions) validate() error {
@@ -1914,7 +1914,7 @@ func (o *fieldOptions) validate() error {
 			return NewBadRequestError(errors.New("max does not apply to field type set"))
 		} else if o.TimeQuantum != nil {
 			return NewBadRequestError(errors.New("timeQuantum does not apply to field type set"))
-		} else if o.Ttl != nil {
+		} else if o.TTL != nil {
 			return NewBadRequestError(errors.New("ttl does not apply to field type set"))
 		}
 	case FieldTypeInt:
@@ -1924,7 +1924,7 @@ func (o *fieldOptions) validate() error {
 			return NewBadRequestError(errors.New("cacheSize does not apply to field type int"))
 		} else if o.TimeQuantum != nil {
 			return NewBadRequestError(errors.New("timeQuantum does not apply to field type int"))
-		} else if o.Ttl != nil {
+		} else if o.TTL != nil {
 			return NewBadRequestError(errors.New("ttl does not apply to field type int"))
 		}
 	case FieldTypeDecimal:
@@ -1936,7 +1936,7 @@ func (o *fieldOptions) validate() error {
 			return NewBadRequestError(errors.New("cacheSize does not apply to field type int"))
 		} else if o.TimeQuantum != nil {
 			return NewBadRequestError(errors.New("timeQuantum does not apply to field type int"))
-		} else if o.Ttl != nil {
+		} else if o.TTL != nil {
 			return NewBadRequestError(errors.New("ttl does not apply to field type int"))
 		} else if o.ForeignIndex != nil && o.Type == FieldTypeDecimal {
 			return NewBadRequestError(errors.New("decimal field cannot be a foreign key"))
@@ -1952,7 +1952,7 @@ func (o *fieldOptions) validate() error {
 			return NewBadRequestError(errors.New("cacheSize does not apply to field type timestamp"))
 		} else if o.TimeQuantum != nil {
 			return NewBadRequestError(errors.New("timeQuantum does not apply to field type timestamp"))
-		} else if o.Ttl != nil {
+		} else if o.TTL != nil {
 			return NewBadRequestError(errors.New("ttl does not apply to field type timestamp"))
 		} else if o.ForeignIndex != nil {
 			return NewBadRequestError(errors.New("timestamp field cannot be a foreign key"))
@@ -1982,7 +1982,7 @@ func (o *fieldOptions) validate() error {
 			return NewBadRequestError(errors.New("max does not apply to field type mutex"))
 		} else if o.TimeQuantum != nil {
 			return NewBadRequestError(errors.New("timeQuantum does not apply to field type mutex"))
-		} else if o.Ttl != nil {
+		} else if o.TTL != nil {
 			return NewBadRequestError(errors.New("ttl does not apply to field type mutex"))
 		}
 	case FieldTypeBool:
@@ -1998,7 +1998,7 @@ func (o *fieldOptions) validate() error {
 			return NewBadRequestError(errors.New("timeQuantum does not apply to field type bool"))
 		} else if o.Keys != nil {
 			return NewBadRequestError(errors.New("keys does not apply to field type bool"))
-		} else if o.Ttl != nil {
+		} else if o.TTL != nil {
 			return NewBadRequestError(errors.New("ttl does not apply to field type bool"))
 		} else if o.ForeignIndex != nil {
 			return NewBadRequestError(errors.New("bool field cannot be a foreign key"))
diff --git a/http_handler_test.go b/http_handler_test.go
index 95ddf2934..e5195205e 100644
--- a/http_handler_test.go
+++ b/http_handler_test.go
@@ -172,7 +172,7 @@ func TestIngestSchemaHandler(t *testing.T) {
 	}
 }
 
-func TestPostFieldWithTtl(t *testing.T) {
+func TestPostFieldWithTTL(t *testing.T) {
 	c := test.MustRunCluster(t, 1)
 	defer c.Close()
 
@@ -191,33 +191,33 @@ func TestPostFieldWithTtl(t *testing.T) {
 		t.Errorf("invalid status: %d, body=%s", resp.StatusCode, resp.Body)
 	}
 
-	postFieldTtlUrl := fmt.Sprintf("%s/index/example/field/with_ttl", m.URL())
+	postFieldTTLUrl := fmt.Sprintf("%s/index/example/field/with_ttl", m.URL())
 
 	// Create new field with ttl but in invalid format
-	fieldOptionInvalidTtl := `
+	fieldOptionInvalidTTL := `
  	{ "options": {"timeQuantum":"YMDH","type":"time","ttl":"24hour" }}
 	`
-	respField := test.Do(t, "POST", postFieldTtlUrl, string(fieldOptionInvalidTtl))
+	respField := test.Do(t, "POST", postFieldTTLUrl, string(fieldOptionInvalidTTL))
 	if (respField.StatusCode != gohttp.StatusBadRequest) &&
 		(respField.Body != "applying option: cannot parse ttl: 24hour") {
 		t.Errorf("expected ttl parse error, got status: %d, body=%s", respField.StatusCode, respField.Body)
 	}
 
 	// Create new field with ttl in invalid format
-	fieldOptionValidTtl := `
+	fieldOptionValidTTL := `
 	{ "options": {"timeQuantum":"YMDH","type":"time","ttl":"24h" }}
 	`
-	respField = test.Do(t, "POST", postFieldTtlUrl, string(fieldOptionValidTtl))
+	respField = test.Do(t, "POST", postFieldTTLUrl, string(fieldOptionValidTTL))
 	if resp.StatusCode != gohttp.StatusOK {
 		t.Errorf("creating field with ttl, got status: %d, body=%s", respField.StatusCode, respField.Body)
 	}
 
 	// Create new field without ttl
-	postFieldNoTtlUrl := fmt.Sprintf("%s/index/example/field/no_ttl", m.URL())
-	fieldOptionNoTtl := `
+	postFieldNoTTLUrl := fmt.Sprintf("%s/index/example/field/no_ttl", m.URL())
+	fieldOptionNoTTL := `
 	{ "options": {"timeQuantum":"YMDH","type":"time" }}
 	`
-	respField = test.Do(t, "POST", postFieldNoTtlUrl, string(fieldOptionNoTtl))
+	respField = test.Do(t, "POST", postFieldNoTTLUrl, string(fieldOptionNoTTL))
 	if resp.StatusCode != gohttp.StatusOK {
 		t.Errorf("creating field without ttl, status: %d, body=%s", respField.StatusCode, respField.Body)
 	}
diff --git a/internal_client.go b/internal_client.go
index cbfeb355f..a4396282c 100644
--- a/internal_client.go
+++ b/internal_client.go
@@ -1093,8 +1093,8 @@ func (c *InternalClient) CreateFieldWithOptions(ctx context.Context, index, fiel
 		fieldOpt.Max = &opt.Max
 	case FieldTypeTime:
 		fieldOpt.TimeQuantum = &opt.TimeQuantum
-		ttlString := opt.Ttl.String()
-		fieldOpt.Ttl = &ttlString
+		ttlString := opt.TTL.String()
+		fieldOpt.TTL = &ttlString
 	case FieldTypeBool:
 		// pass
 	case FieldTypeDecimal:
diff --git a/internal_client_test.go b/internal_client_test.go
index 8acb74751..73fe9f07a 100644
--- a/internal_client_test.go
+++ b/internal_client_test.go
@@ -7,7 +7,6 @@ import (
 	"context"
 	"encoding/hex"
 	"fmt"
-	"net/http"
 	gohttp "net/http"
 	"reflect"
 	"strings"
@@ -1199,21 +1198,21 @@ func TestClient_CreateTimeField(t *testing.T) {
 	if err != nil {
 		t.Fatalf("getting field: %v", err)
 	}
-	if fld.Ttl() != 0 {
-		t.Fatalf("expected Ttl to be 0, got: %+v", fld.Options().Ttl.String())
+	if fld.TTL() != 0 {
+		t.Fatalf("expected TTL to be 0, got: %+v", fld.Options().TTL.String())
 	}
 
-	fieldTtl := "field_ttl"
-	err = c.CreateFieldWithOptions(context.Background(), index, fieldTtl, pilosa.FieldOptions{Type: pilosa.FieldTypeTime, TimeQuantum: "YMDH", Ttl: time.Hour})
+	fieldTTL := "field_ttl"
+	err = c.CreateFieldWithOptions(context.Background(), index, fieldTTL, pilosa.FieldOptions{Type: pilosa.FieldTypeTime, TimeQuantum: "YMDH", TTL: time.Hour})
 	if err != nil {
 		t.Fatalf("creating field: %v", err)
 	}
-	fldTtl, err := cmd.API.Field(context.Background(), index, fieldTtl)
+	fldTTL, err := cmd.API.Field(context.Background(), index, fieldTTL)
 	if err != nil {
 		t.Fatalf("getting field: %v", err)
 	}
-	if fldTtl.Ttl() != time.Hour {
-		t.Fatalf("expected Ttl 1 hour, got: %+v", fldTtl.Ttl().String())
+	if fldTTL.TTL() != time.Hour {
+		t.Fatalf("expected TTL 1 hour, got: %+v", fldTTL.TTL().String())
 	}
 }
 
@@ -1573,7 +1572,7 @@ func TestClient_ImportRoaringExists(t *testing.T) {
 
 func TestAddAuthToken(t *testing.T) {
 	t.Run("none", func(t *testing.T) {
-		req, err := http.NewRequest("GET", "dontmatternone", strings.NewReader("this doesn't matter"))
+		req, err := gohttp.NewRequest("GET", "dontmatternone", strings.NewReader("this doesn't matter"))
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}
@@ -1583,7 +1582,7 @@ func TestAddAuthToken(t *testing.T) {
 		}
 	})
 	t.Run("userinfo", func(t *testing.T) {
-		req, err := http.NewRequest("GET", "dontmatternone", strings.NewReader("this doesn't matter"))
+		req, err := gohttp.NewRequest("GET", "dontmatternone", strings.NewReader("this doesn't matter"))
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}
@@ -1594,7 +1593,7 @@ func TestAddAuthToken(t *testing.T) {
 		}
 	})
 	t.Run("token", func(t *testing.T) {
-		req, err := http.NewRequest("GET", "dontmatternone", strings.NewReader("this doesn't matter"))
+		req, err := gohttp.NewRequest("GET", "dontmatternone", strings.NewReader("this doesn't matter"))
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}
diff --git a/pb/private.pb.go b/pb/private.pb.go
index 21d27da12..f4b4c6c51 100644
--- a/pb/private.pb.go
+++ b/pb/private.pb.go
@@ -93,7 +93,7 @@ type FieldOptions struct {
 	Min                  *Decimal `protobuf:"bytes,17,opt,name=Min,proto3" json:"Min,omitempty"`
 	Max                  *Decimal `protobuf:"bytes,18,opt,name=Max,proto3" json:"Max,omitempty"`
 	TimeUnit             string   `protobuf:"bytes,19,opt,name=TimeUnit,proto3" json:"TimeUnit,omitempty"`
-	Ttl                  string   `protobuf:"bytes,20,opt,name=Ttl,proto3" json:"Ttl,omitempty"`
+	TTL                  string   `protobuf:"bytes,20,opt,name=TTL,proto3" json:"TTL,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -237,9 +237,9 @@ func (m *FieldOptions) GetTimeUnit() string {
 	return ""
 }
 
-func (m *FieldOptions) GetTtl() string {
+func (m *FieldOptions) GetTTL() string {
 	if m != nil {
-		return m.Ttl
+		return m.TTL
 	}
 	return ""
 }
@@ -2767,111 +2767,111 @@ func init() {
 func init() { proto.RegisterFile("private.proto", fileDescriptor_d2a91b51c7bdc125) }
 
 var fileDescriptor_d2a91b51c7bdc125 = []byte{
-	// 1650 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcf, 0x72, 0x1b, 0x45,
-	0x13, 0xff, 0x76, 0x57, 0xb2, 0xa4, 0x96, 0x65, 0xcb, 0x13, 0x7f, 0xf9, 0xd6, 0x4e, 0x3e, 0x97,
-	0x3c, 0x50, 0x89, 0x70, 0x15, 0xa6, 0x70, 0x0e, 0xa1, 0xe0, 0x12, 0x5b, 0x72, 0x82, 0x08, 0x4e,
-	0x9c, 0xb1, 0xe3, 0x23, 0xd4, 0x58, 0x9a, 0xb2, 0xb7, 0xbc, 0xda, 0x15, 0xbb, 0x2b, 0x47, 0xca,
-	0x81, 0x2a, 0x28, 0x28, 0xb8, 0x70, 0xe7, 0xc4, 0x5b, 0xf0, 0x02, 0x9c, 0xb8, 0x50, 0xc5, 0x23,
-	0x50, 0xe1, 0x45, 0xa8, 0xe9, 0x99, 0xd9, 0x5d, 0x29, 0x72, 0x04, 0x2e, 0x6e, 0xdb, 0xbf, 0xee,
-	0xe9, 0x7f, 0xd3, 0xd3, 0xd3, 0xb3, 0x50, 0x1b, 0x44, 0xde, 0x25, 0x4f, 0xc4, 0xf6, 0x20, 0x0a,
-	0x93, 0x90, 0xd8, 0x83, 0xd3, 0xf5, 0xc5, 0xc1, 0xf0, 0xd4, 0xf7, 0xba, 0x0a, 0xa1, 0x8f, 0xa0,
-	0xd2, 0x09, 0x7a, 0x62, 0x74, 0x20, 0x12, 0x4e, 0x08, 0x14, 0x1e, 0x8b, 0x71, 0xec, 0x3a, 0x0d,
-	0xab, 0x59, 0x66, 0xf8, 0x4d, 0xee, 0xc0, 0xd2, 0x71, 0xc4, 0xbb, 0x17, 0xfb, 0x23, 0x2f, 0x4e,
-	0x44, 0xd0, 0x15, 0x6e, 0x01, 0xb9, 0x53, 0x28, 0xfd, 0xc5, 0x81, 0xc5, 0x87, 0x9e, 0xf0, 0x7b,
-	0x4f, 0x07, 0x89, 0x17, 0x06, 0xb1, 0x54, 0x76, 0x3c, 0x1e, 0x08, 0xb7, 0xdc, 0xb0, 0x9a, 0x15,
-	0x86, 0xdf, 0xe4, 0x36, 0x54, 0x5a, 0xbc, 0x7b, 0x2e, 0x90, 0xe1, 0x20, 0x23, 0x03, 0x52, 0xee,
-	0x91, 0xf7, 0x52, 0x59, 0xa9, 0xb1, 0x0c, 0x20, 0x0d, 0xa8, 0x1e, 0x7b, 0x7d, 0xf1, 0x6c, 0xc8,
-	0x83, 0x64, 0xd8, 0x77, 0x8b, 0xb8, 0x3a, 0x0f, 0x91, 0x9b, 0xb0, 0xf0, 0xd4, 0xef, 0x1d, 0x78,
-	0x81, 0x5b, 0x69, 0x58, 0x4d, 0x87, 0x69, 0xca, 0xe0, 0x7c, 0xe4, 0x42, 0x86, 0xf3, 0x51, 0x1a,
-	0x6e, 0x75, 0x32, 0xdc, 0x27, 0xe1, 0x51, 0xc2, 0x83, 0x1e, 0x8f, 0x7a, 0x27, 0x9e, 0x78, 0xe1,
-	0x2e, 0xaa, 0x70, 0x27, 0x51, 0xb9, 0x76, 0x8f, 0xc7, 0xc2, 0xad, 0xa1, 0x46, 0xfc, 0x26, 0xeb,
-	0x50, 0xde, 0xf3, 0x92, 0xb6, 0x18, 0x24, 0xe7, 0xee, 0x52, 0xc3, 0x6a, 0x16, 0x58, 0x4a, 0x93,
-	0x55, 0x28, 0x1e, 0x75, 0xb9, 0x2f, 0xdc, 0x65, 0x5c, 0xa0, 0x08, 0x42, 0x61, 0xf1, 0x61, 0x18,
-	0x09, 0xef, 0x2c, 0xc0, 0x4d, 0x70, 0xeb, 0x18, 0xd4, 0x04, 0x46, 0xfe, 0x0f, 0x8e, 0x0c, 0x69,
-	0xa5, 0x61, 0x35, 0xab, 0x3b, 0xd5, 0xed, 0xc1, 0xe9, 0x76, 0x5b, 0x74, 0xbd, 0x3e, 0xf7, 0x99,
-	0xc4, 0x91, 0xcd, 0x47, 0x2e, 0x99, 0xc5, 0xe6, 0x23, 0xe9, 0x93, 0x4c, 0xd1, 0xf3, 0xc0, 0x4b,
-	0xdc, 0x1b, 0xa8, 0x3d, 0xa5, 0x49, 0x1d, 0x9c, 0xe3, 0xc4, 0x77, 0x57, 0x11, 0x96, 0x9f, 0x94,
-	0xc2, 0x52, 0xa7, 0x3f, 0x08, 0xa3, 0x84, 0x89, 0x78, 0x10, 0x06, 0xb1, 0x90, 0x32, 0xfb, 0x51,
-	0xe4, 0x5a, 0x4a, 0x66, 0x3f, 0x8a, 0xe8, 0x97, 0x50, 0xdf, 0xf3, 0xc3, 0xee, 0x45, 0x9b, 0x27,
-	0x9c, 0x89, 0x2f, 0x86, 0x22, 0x4e, 0x64, 0x74, 0x2a, 0x00, 0x25, 0xa7, 0x08, 0x89, 0x62, 0x45,
-	0xb8, 0xb6, 0x42, 0x91, 0x90, 0x99, 0xc3, 0xbc, 0xaa, 0x0d, 0xc4, 0x6f, 0xcc, 0xce, 0x39, 0x8f,
-	0x7a, 0xb8, 0xeb, 0x05, 0xa6, 0x08, 0x89, 0xa2, 0x25, 0xac, 0x94, 0x02, 0x53, 0x04, 0xed, 0xc0,
-	0x4a, 0xce, 0xbe, 0x76, 0xf3, 0x26, 0x2c, 0xb0, 0xf0, 0x45, 0xa7, 0x1d, 0xbb, 0x56, 0xc3, 0x69,
-	0x16, 0x98, 0xa6, 0xb0, 0xa4, 0x42, 0x7f, 0xd8, 0x0f, 0x24, 0xcb, 0x46, 0x56, 0x06, 0xd0, 0x35,
-	0x28, 0x62, 0x7d, 0xc9, 0x28, 0xb3, 0xb5, 0xf2, 0x93, 0x7e, 0x65, 0x41, 0xe5, 0x80, 0x8f, 0xd0,
-	0x91, 0x98, 0xdc, 0x87, 0xb2, 0xd9, 0x7d, 0x14, 0xaa, 0xee, 0xdc, 0x92, 0x99, 0x4e, 0x05, 0xb6,
-	0x0d, 0x77, 0x3f, 0x48, 0xa2, 0x31, 0x4b, 0x85, 0xd7, 0x3f, 0x82, 0xda, 0x04, 0x4b, 0x5a, 0xba,
-	0x10, 0x63, 0x93, 0xcf, 0x0b, 0x31, 0x96, 0x51, 0x5e, 0x72, 0x7f, 0x28, 0x30, 0x4b, 0x05, 0xa6,
-	0x88, 0x0f, 0xed, 0x0f, 0x2c, 0x7a, 0x02, 0xa4, 0x15, 0x09, 0x9e, 0x08, 0x34, 0x72, 0x20, 0xe2,
-	0x98, 0x9f, 0x89, 0x79, 0xb9, 0x76, 0xf2, 0xb9, 0x4e, 0xf3, 0x6a, 0xe7, 0xf2, 0x4a, 0xb7, 0x80,
-	0xb4, 0x85, 0x2f, 0x12, 0xa1, 0x4f, 0xfe, 0x1b, 0xf4, 0xd2, 0x0b, 0xe3, 0xc3, 0x7c, 0x59, 0xb2,
-	0x09, 0x05, 0xd9, 0x46, 0xd0, 0x58, 0x75, 0xa7, 0x26, 0x33, 0x94, 0xf6, 0x16, 0x86, 0x2c, 0xdc,
-	0x0f, 0x54, 0xd7, 0xdb, 0x4d, 0xd0, 0x55, 0x87, 0x65, 0x00, 0xfd, 0xc6, 0x32, 0xd6, 0xd0, 0xfd,
-	0xbf, 0x19, 0xf1, 0x44, 0x75, 0xbd, 0xad, 0x7d, 0x70, 0xd0, 0x87, 0xba, 0xf4, 0x21, 0xdf, 0x95,
-	0x66, 0xb9, 0x51, 0x98, 0x76, 0xe3, 0x81, 0xc9, 0xcf, 0x75, 0xbd, 0xa0, 0x5d, 0xb8, 0xa5, 0x34,
-	0xec, 0x5e, 0x72, 0xcf, 0xe7, 0xa7, 0xfe, 0x3f, 0xda, 0xc2, 0x89, 0x80, 0x5c, 0x28, 0xe1, 0xda,
-	0x4e, 0x5b, 0x1f, 0x03, 0x43, 0xd2, 0x21, 0x64, 0x27, 0xea, 0x09, 0xef, 0x0b, 0xad, 0x0d, 0xbf,
-	0xd3, 0x3c, 0xd8, 0x6f, 0xcc, 0xc3, 0x2a, 0x14, 0xe5, 0xf9, 0x93, 0x1d, 0xdf, 0x91, 0x26, 0x91,
-	0x98, 0x93, 0x9d, 0x77, 0x61, 0xe1, 0xa8, 0x7b, 0x2e, 0xfa, 0x9c, 0xbc, 0x05, 0x25, 0xf4, 0x5c,
-	0xc4, 0xfa, 0x50, 0x54, 0xd2, 0x2d, 0x67, 0x86, 0x43, 0xbf, 0xb5, 0x74, 0xb0, 0x33, 0xdd, 0x9c,
-	0x30, 0x65, 0x4f, 0x99, 0x22, 0x77, 0xa1, 0xa4, 0xfd, 0xc5, 0x6e, 0xf1, 0x5a, 0x4d, 0x19, 0x2e,
-	0xd9, 0x84, 0x05, 0x8c, 0x2e, 0x76, 0x0b, 0x99, 0x23, 0x88, 0x30, 0xcd, 0xa0, 0xfb, 0xe0, 0x3c,
-	0x67, 0x1d, 0xd9, 0x28, 0xd0, 0x7b, 0xe3, 0x86, 0xa6, 0xa4, 0x73, 0x1f, 0x87, 0x71, 0xa2, 0x73,
-	0x8f, 0xdf, 0x12, 0x3b, 0x0c, 0x23, 0x55, 0xa7, 0x35, 0x86, 0xdf, 0xf4, 0x7b, 0x0b, 0x0a, 0x4f,
-	0xc2, 0x9e, 0x20, 0x4b, 0x60, 0x77, 0xda, 0x5a, 0x89, 0xdd, 0x69, 0x93, 0x35, 0xd4, 0xaf, 0xf3,
-	0x5d, 0x92, 0xf6, 0x9f, 0xb3, 0x0e, 0x43, 0x9b, 0xb7, 0xa1, 0xd2, 0x89, 0x0f, 0x23, 0xaf, 0xcf,
-	0xa3, 0xb1, 0xbe, 0x5b, 0x33, 0x00, 0xcf, 0x68, 0xc2, 0x13, 0x75, 0xe3, 0x55, 0x98, 0x22, 0xc8,
-	0x26, 0x94, 0x1e, 0xb1, 0xc3, 0x96, 0x54, 0x59, 0x9c, 0x54, 0x69, 0x70, 0xfa, 0x00, 0xea, 0xd2,
-	0x13, 0x94, 0x37, 0x95, 0x75, 0x13, 0x16, 0x24, 0x96, 0x7a, 0xa6, 0xa9, 0xcc, 0x88, 0x9d, 0x33,
-	0x42, 0x1f, 0x2a, 0x0d, 0xfb, 0x97, 0x22, 0x48, 0x72, 0xb5, 0x89, 0x34, 0x2a, 0xa8, 0x31, 0x45,
-	0x90, 0xdb, 0x2a, 0x6a, 0x1d, 0x5e, 0x59, 0xfa, 0x22, 0x69, 0x86, 0x28, 0x1d, 0x03, 0x18, 0x4f,
-	0x86, 0x71, 0x2a, 0x6b, 0xcd, 0x92, 0x25, 0xd4, 0x94, 0x8f, 0x3e, 0xa2, 0x20, 0xf9, 0x0a, 0x61,
-	0xa6, 0xb0, 0xde, 0xc9, 0x0a, 0x4b, 0xed, 0xe7, 0x72, 0xba, 0xef, 0xca, 0x46, 0x56, 0x5e, 0xe7,
-	0x50, 0xcd, 0xe1, 0x33, 0x6b, 0xec, 0x6e, 0x5a, 0x1c, 0x76, 0xa6, 0x0c, 0x11, 0xad, 0x4c, 0xb3,
-	0xe7, 0x34, 0x27, 0x0f, 0xaa, 0xb9, 0x45, 0x33, 0x2d, 0x35, 0x61, 0x79, 0xf2, 0xc0, 0x9b, 0x3b,
-	0x67, 0x1a, 0x9e, 0x63, 0xea, 0x3b, 0x0b, 0x6a, 0x2d, 0x7f, 0x18, 0x27, 0x22, 0x4a, 0x73, 0x5a,
-	0xd1, 0x40, 0xba, 0xb5, 0x19, 0x30, 0x7b, 0x77, 0xc9, 0x06, 0x14, 0x65, 0xc6, 0xd5, 0xe1, 0xce,
-	0x6f, 0x84, 0x82, 0x73, 0x3b, 0x51, 0xb8, 0x6a, 0x27, 0xe8, 0x09, 0x94, 0xf7, 0x8e, 0x3a, 0x8f,
-	0xa2, 0x70, 0x38, 0x98, 0x19, 0xb1, 0x19, 0xf2, 0xec, 0xdc, 0x90, 0x57, 0x57, 0x03, 0x8b, 0x8a,
-	0x0a, 0x67, 0x94, 0xba, 0x9a, 0x51, 0x0a, 0x1a, 0xe1, 0x23, 0x7a, 0x04, 0x2b, 0x2a, 0x5c, 0xd9,
-	0x71, 0xae, 0xd3, 0x16, 0xcd, 0x14, 0xe1, 0x64, 0x53, 0x84, 0x54, 0xaa, 0xba, 0xee, 0xbf, 0xa9,
-	0xf4, 0x37, 0x1b, 0x56, 0x98, 0x88, 0xbd, 0x97, 0xa2, 0x13, 0xc4, 0x49, 0x34, 0xec, 0xca, 0x8e,
-	0x23, 0xd7, 0x7f, 0x12, 0x9e, 0xea, 0xbd, 0x70, 0x98, 0x22, 0xde, 0x7c, 0x4a, 0x08, 0x85, 0x52,
-	0xbe, 0x09, 0xe4, 0x05, 0x0c, 0x83, 0x6c, 0x41, 0xe9, 0x28, 0x1c, 0x46, 0xdd, 0xb4, 0xf2, 0xb1,
-	0x73, 0x2b, 0xfb, 0x8a, 0xc1, 0x8c, 0x00, 0x79, 0x0c, 0xe4, 0x38, 0xe2, 0x41, 0xec, 0x73, 0xe9,
-	0x92, 0x59, 0x56, 0xce, 0xc6, 0x93, 0x1c, 0x77, 0x42, 0xc3, 0x8c, 0x65, 0x64, 0x3b, 0x7f, 0x84,
-	0xdd, 0x12, 0xfa, 0xb7, 0x64, 0xfc, 0xd3, 0xe7, 0x24, 0x7f, 0xc8, 0xef, 0x4f, 0x55, 0xa8, 0xbb,
-	0x80, 0x4b, 0x56, 0xe4, 0x92, 0x09, 0x06, 0x9b, 0x94, 0xa3, 0x5f, 0x5b, 0xb0, 0x98, 0xf7, 0x66,
-	0x4e, 0xbb, 0x48, 0xb7, 0xcf, 0x9e, 0x3f, 0xed, 0x98, 0xed, 0x2b, 0xcc, 0x9a, 0x2c, 0x8b, 0xf9,
-	0x09, 0x28, 0x84, 0xff, 0x5d, 0x91, 0x9c, 0x6b, 0xb9, 0xd3, 0x80, 0xea, 0x21, 0x8f, 0x12, 0x4f,
-	0x2a, 0xd3, 0xf7, 0x74, 0x91, 0xe5, 0x21, 0x2a, 0x60, 0xed, 0xb5, 0x22, 0x6a, 0x85, 0xfd, 0x81,
-	0xac, 0xd6, 0x6b, 0x15, 0x93, 0x6c, 0xd3, 0x51, 0x14, 0x46, 0x26, 0x03, 0x48, 0xd0, 0x3d, 0x28,
-	0x1f, 0x87, 0x83, 0xd0, 0x0f, 0xcf, 0xc6, 0x73, 0x5a, 0x86, 0x0b, 0x25, 0x75, 0x35, 0xa8, 0x16,
-	0x55, 0x61, 0x86, 0xa4, 0x37, 0x64, 0xbd, 0x77, 0xb9, 0xdf, 0x1d, 0xfa, 0x3c, 0x11, 0x38, 0x1f,
-	0x23, 0xf8, 0x69, 0xc8, 0x7b, 0xaa, 0x2b, 0xe8, 0xa3, 0x45, 0x3f, 0xd7, 0x05, 0xc8, 0x31, 0x9c,
-	0xdc, 0x15, 0xb4, 0x8b, 0x80, 0xb9, 0x82, 0x14, 0x45, 0xde, 0x87, 0x6a, 0x4e, 0x5a, 0x87, 0xb5,
-	0x9c, 0xd6, 0xa9, 0x82, 0x59, 0x5e, 0x86, 0xfe, 0x6c, 0x4d, 0xac, 0x79, 0xed, 0xce, 0xd5, 0xa6,
-	0x2e, 0x55, 0x92, 0xca, 0x4c, 0x53, 0x32, 0xf4, 0xfd, 0x51, 0xd7, 0x1f, 0xc6, 0x92, 0xa5, 0x2f,
-	0xdc, 0x14, 0x90, 0xa1, 0xcb, 0x27, 0x50, 0x38, 0x34, 0xc3, 0x8d, 0x21, 0xe5, 0x63, 0xa9, 0x2d,
-	0x78, 0xcf, 0xf7, 0x02, 0x81, 0xf5, 0xe2, 0xb0, 0x94, 0x26, 0x5b, 0xaa, 0xc7, 0x9a, 0x42, 0x5f,
-	0x9d, 0x72, 0x1c, 0x79, 0xaa, 0xf3, 0xc6, 0x94, 0x40, 0x7d, 0x9a, 0x45, 0x57, 0x81, 0xa8, 0x0a,
-	0xd8, 0x3d, 0x0d, 0x23, 0x73, 0xdb, 0xd2, 0x96, 0x69, 0x2e, 0x32, 0xfb, 0xf3, 0x2e, 0xf1, 0x2c,
-	0xb3, 0x76, 0x3e, 0xb3, 0xf4, 0x33, 0x58, 0xd2, 0xb3, 0x9d, 0x88, 0xb0, 0xa0, 0x65, 0x02, 0x98,
-	0xe8, 0x86, 0x72, 0x4c, 0x34, 0xaf, 0x9a, 0x0c, 0x90, 0x7a, 0x4e, 0xe4, 0x23, 0xc3, 0xdc, 0x4e,
-	0x9a, 0xc2, 0xd9, 0xc8, 0x3b, 0x0b, 0x44, 0x0f, 0x6f, 0x0c, 0x87, 0x69, 0x8a, 0xfe, 0x60, 0xc3,
-	0xaa, 0x1a, 0x3a, 0x83, 0x33, 0x11, 0x27, 0x99, 0x19, 0xf9, 0xb0, 0x1e, 0x60, 0xff, 0xd7, 0x8e,
-	0x2a, 0x4a, 0x3e, 0xa2, 0x5b, 0xbe, 0xe0, 0x51, 0xe6, 0x83, 0x32, 0x34, 0x85, 0xca, 0x73, 0x83,
-	0x88, 0xbe, 0x9e, 0xd5, 0x10, 0x9a, 0x87, 0xc8, 0x1e, 0x94, 0x75, 0x68, 0xa6, 0x21, 0xde, 0xc1,
-	0x5b, 0x6a, 0x86, 0x37, 0x66, 0xbe, 0x8d, 0xf5, 0x1b, 0xcc, 0x90, 0xeb, 0x4f, 0xa1, 0x36, 0xc1,
-	0x9a, 0xf1, 0x06, 0x6b, 0xe6, 0xdf, 0x60, 0xd5, 0x1d, 0x92, 0x1b, 0x97, 0xb5, 0xf6, 0xfc, 0xbb,
-	0xac, 0x05, 0xff, 0x9d, 0xe5, 0x40, 0x4c, 0xb6, 0xc0, 0x91, 0x8e, 0xaa, 0x61, 0xd8, 0xbd, 0xca,
-	0x51, 0x26, 0x85, 0xe8, 0x4f, 0x96, 0x4e, 0xaa, 0xd0, 0x7c, 0xf3, 0x96, 0xbe, 0x97, 0x57, 0xb2,
-	0x99, 0x2a, 0x99, 0x12, 0xdb, 0x4e, 0x03, 0x95, 0xd2, 0xeb, 0xcf, 0xa0, 0x3c, 0x2b, 0xbc, 0x82,
-	0x0a, 0xef, 0xbd, 0xc9, 0xf0, 0xd6, 0xae, 0xf2, 0x2c, 0xce, 0x45, 0xb9, 0x57, 0xff, 0xf5, 0xd5,
-	0x86, 0xf5, 0xfb, 0xab, 0x0d, 0xeb, 0x8f, 0x57, 0x1b, 0xd6, 0x8f, 0x7f, 0x6e, 0xfc, 0xe7, 0x74,
-	0x01, 0x7f, 0x19, 0xdd, 0xfb, 0x2b, 0x00, 0x00, 0xff, 0xff, 0xcf, 0xdb, 0x63, 0xcd, 0x55, 0x12,
-	0x00, 0x00,
+	// 1652 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x4f, 0x6f, 0xdb, 0xc6,
+	0x12, 0x7f, 0x24, 0x25, 0x4b, 0x1a, 0x59, 0xb6, 0xbc, 0xf1, 0xcb, 0xa3, 0x9d, 0x3c, 0x43, 0xde,
+	0xf7, 0x90, 0xa8, 0x06, 0xea, 0xa2, 0xce, 0x21, 0x45, 0x7b, 0x89, 0x2d, 0x39, 0xa9, 0x9a, 0x38,
+	0x71, 0xd6, 0x8e, 0x8f, 0x2d, 0xd6, 0xd2, 0xc2, 0x26, 0x4c, 0x91, 0x2a, 0x49, 0x39, 0x52, 0x0e,
+	0x05, 0x5a, 0xb4, 0x68, 0x2f, 0xbd, 0xf7, 0xd4, 0x6f, 0xd1, 0x2f, 0xd0, 0x53, 0x2f, 0x05, 0xfa,
+	0x11, 0x8a, 0xf4, 0x8b, 0x14, 0x3b, 0xbb, 0x4b, 0x52, 0x8a, 0x1c, 0xb5, 0x46, 0x6f, 0x9c, 0xdf,
+	0xcc, 0xce, 0xbf, 0x9d, 0x9d, 0x9d, 0x25, 0xd4, 0x06, 0x91, 0x77, 0xc9, 0x13, 0xb1, 0x3d, 0x88,
+	0xc2, 0x24, 0x24, 0xf6, 0xe0, 0x74, 0x7d, 0x71, 0x30, 0x3c, 0xf5, 0xbd, 0xae, 0x42, 0xe8, 0x23,
+	0xa8, 0x74, 0x82, 0x9e, 0x18, 0x1d, 0x88, 0x84, 0x13, 0x02, 0x85, 0xc7, 0x62, 0x1c, 0xbb, 0x4e,
+	0xc3, 0x6a, 0x96, 0x19, 0x7e, 0x93, 0x3b, 0xb0, 0x74, 0x1c, 0xf1, 0xee, 0xc5, 0xfe, 0xc8, 0x8b,
+	0x13, 0x11, 0x74, 0x85, 0x5b, 0x40, 0xee, 0x14, 0x4a, 0x7f, 0x76, 0x60, 0xf1, 0xa1, 0x27, 0xfc,
+	0xde, 0xb3, 0x41, 0xe2, 0x85, 0x41, 0x2c, 0x95, 0x1d, 0x8f, 0x07, 0xc2, 0x2d, 0x37, 0xac, 0x66,
+	0x85, 0xe1, 0x37, 0xb9, 0x0d, 0x95, 0x16, 0xef, 0x9e, 0x0b, 0x64, 0x38, 0xc8, 0xc8, 0x80, 0x94,
+	0x7b, 0xe4, 0xbd, 0x52, 0x56, 0x6a, 0x2c, 0x03, 0x48, 0x03, 0xaa, 0xc7, 0x5e, 0x5f, 0x3c, 0x1f,
+	0xf2, 0x20, 0x19, 0xf6, 0xdd, 0x22, 0xae, 0xce, 0x43, 0xe4, 0x26, 0x2c, 0x3c, 0xf3, 0x7b, 0x07,
+	0x5e, 0xe0, 0x56, 0x1a, 0x56, 0xd3, 0x61, 0x9a, 0x32, 0x38, 0x1f, 0xb9, 0x90, 0xe1, 0x7c, 0x94,
+	0x86, 0x5b, 0x9d, 0x0c, 0xf7, 0x69, 0x78, 0x94, 0xf0, 0xa0, 0xc7, 0xa3, 0xde, 0x89, 0x27, 0x5e,
+	0xba, 0x8b, 0x2a, 0xdc, 0x49, 0x54, 0xae, 0xdd, 0xe3, 0xb1, 0x70, 0x6b, 0xa8, 0x11, 0xbf, 0xc9,
+	0x3a, 0x94, 0xf7, 0xbc, 0xa4, 0x2d, 0x06, 0xc9, 0xb9, 0xbb, 0xd4, 0xb0, 0x9a, 0x05, 0x96, 0xd2,
+	0x64, 0x15, 0x8a, 0x47, 0x5d, 0xee, 0x0b, 0x77, 0x19, 0x17, 0x28, 0x82, 0x50, 0x58, 0x7c, 0x18,
+	0x46, 0xc2, 0x3b, 0x0b, 0x70, 0x13, 0xdc, 0x3a, 0x06, 0x35, 0x81, 0x91, 0xff, 0x82, 0x23, 0x43,
+	0x5a, 0x69, 0x58, 0xcd, 0xea, 0x4e, 0x75, 0x7b, 0x70, 0xba, 0xdd, 0x16, 0x5d, 0xaf, 0xcf, 0x7d,
+	0x26, 0x71, 0x64, 0xf3, 0x91, 0x4b, 0x66, 0xb1, 0xf9, 0x48, 0xfa, 0x24, 0x53, 0xf4, 0x22, 0xf0,
+	0x12, 0xf7, 0x06, 0x6a, 0x4f, 0x69, 0x52, 0x07, 0xe7, 0xf8, 0xf8, 0x89, 0xbb, 0x8a, 0xb0, 0xfc,
+	0xa4, 0x14, 0x96, 0x3a, 0xfd, 0x41, 0x18, 0x25, 0x4c, 0xc4, 0x83, 0x30, 0x88, 0x85, 0x94, 0xd9,
+	0x8f, 0x22, 0xd7, 0x52, 0x32, 0xfb, 0x51, 0x44, 0xbf, 0x80, 0xfa, 0x9e, 0x1f, 0x76, 0x2f, 0xda,
+	0x3c, 0xe1, 0x4c, 0x7c, 0x3e, 0x14, 0x71, 0x22, 0xa3, 0x53, 0x01, 0x28, 0x39, 0x45, 0x48, 0x14,
+	0x2b, 0xc2, 0xb5, 0x15, 0x8a, 0x84, 0xcc, 0x1c, 0xe6, 0x55, 0x6d, 0x20, 0x7e, 0x63, 0x76, 0xce,
+	0x79, 0xd4, 0xc3, 0x5d, 0x2f, 0x30, 0x45, 0x48, 0x14, 0x2d, 0x61, 0xa5, 0x14, 0x98, 0x22, 0x68,
+	0x07, 0x56, 0x72, 0xf6, 0xb5, 0x9b, 0x37, 0x61, 0x81, 0x85, 0x2f, 0x3b, 0xed, 0xd8, 0xb5, 0x1a,
+	0x4e, 0xb3, 0xc0, 0x34, 0x85, 0x25, 0x15, 0xfa, 0xc3, 0x7e, 0x20, 0x59, 0x36, 0xb2, 0x32, 0x80,
+	0xae, 0x41, 0x11, 0xeb, 0x4b, 0x46, 0x99, 0xad, 0x95, 0x9f, 0xf4, 0x4b, 0x0b, 0x2a, 0x07, 0x7c,
+	0x84, 0x8e, 0xc4, 0xe4, 0x3e, 0x94, 0xcd, 0xee, 0xa3, 0x50, 0x75, 0xe7, 0x96, 0xcc, 0x74, 0x2a,
+	0xb0, 0x6d, 0xb8, 0xfb, 0x41, 0x12, 0x8d, 0x59, 0x2a, 0xbc, 0xfe, 0x11, 0xd4, 0x26, 0x58, 0xd2,
+	0xd2, 0x85, 0x18, 0x9b, 0x7c, 0x5e, 0x88, 0xb1, 0x8c, 0xf2, 0x92, 0xfb, 0x43, 0x81, 0x59, 0x2a,
+	0x30, 0x45, 0x7c, 0x68, 0x7f, 0x60, 0xd1, 0x13, 0x20, 0xad, 0x48, 0xf0, 0x44, 0xa0, 0x91, 0x03,
+	0x11, 0xc7, 0xfc, 0x4c, 0xcc, 0xcb, 0xb5, 0x93, 0xcf, 0x75, 0x9a, 0x57, 0x3b, 0x97, 0x57, 0xba,
+	0x05, 0xa4, 0x2d, 0x7c, 0x91, 0x08, 0x7d, 0xf2, 0xdf, 0xa2, 0x97, 0x5e, 0x18, 0x1f, 0xe6, 0xcb,
+	0x92, 0x4d, 0x28, 0xc8, 0x36, 0x82, 0xc6, 0xaa, 0x3b, 0x35, 0x99, 0xa1, 0xb4, 0xb7, 0x30, 0x64,
+	0xe1, 0x7e, 0xa0, 0xba, 0xde, 0x6e, 0x82, 0xae, 0x3a, 0x2c, 0x03, 0xe8, 0xd7, 0x96, 0xb1, 0x86,
+	0xee, 0xff, 0xc5, 0x88, 0x27, 0xaa, 0xeb, 0xff, 0xda, 0x07, 0x07, 0x7d, 0xa8, 0x4b, 0x1f, 0xf2,
+	0x5d, 0x69, 0x96, 0x1b, 0x85, 0x69, 0x37, 0x1e, 0x98, 0xfc, 0x5c, 0xd7, 0x0b, 0xda, 0x85, 0x5b,
+	0x4a, 0xc3, 0xee, 0x25, 0xf7, 0x7c, 0x7e, 0xea, 0xff, 0xad, 0x2d, 0x9c, 0x08, 0xc8, 0x85, 0x12,
+	0xae, 0xed, 0xb4, 0xf5, 0x31, 0x30, 0x24, 0x1d, 0x42, 0x76, 0xa2, 0x9e, 0xf2, 0xbe, 0xd0, 0xda,
+	0xf0, 0x3b, 0xcd, 0x83, 0xfd, 0xd6, 0x3c, 0xac, 0x42, 0x51, 0x9e, 0x3f, 0xd9, 0xf1, 0x1d, 0x69,
+	0x12, 0x89, 0x39, 0xd9, 0x79, 0x17, 0x16, 0x8e, 0xba, 0xe7, 0xa2, 0xcf, 0xc9, 0xff, 0xa0, 0x84,
+	0x9e, 0x8b, 0x58, 0x1f, 0x8a, 0x4a, 0xba, 0xe5, 0xcc, 0x70, 0xe8, 0x37, 0x96, 0x0e, 0x76, 0xa6,
+	0x9b, 0x13, 0xa6, 0xec, 0x29, 0x53, 0xe4, 0x2e, 0x94, 0xb4, 0xbf, 0xd8, 0x2d, 0xde, 0xa8, 0x29,
+	0xc3, 0x25, 0x9b, 0xb0, 0x80, 0xd1, 0xc5, 0x6e, 0x21, 0x73, 0x04, 0x11, 0xa6, 0x19, 0x74, 0x1f,
+	0x9c, 0x17, 0xac, 0x23, 0x1b, 0x05, 0x7a, 0x6f, 0xdc, 0xd0, 0x94, 0x74, 0xee, 0xe3, 0x30, 0x4e,
+	0x74, 0xee, 0xf1, 0x5b, 0x62, 0x87, 0x61, 0xa4, 0xea, 0xb4, 0xc6, 0xf0, 0x9b, 0x7e, 0x67, 0x41,
+	0xe1, 0x69, 0xd8, 0x13, 0x64, 0x09, 0xec, 0x4e, 0x5b, 0x2b, 0xb1, 0x3b, 0x6d, 0xb2, 0x86, 0xfa,
+	0x75, 0xbe, 0x4b, 0xd2, 0xfe, 0x0b, 0xd6, 0x61, 0x68, 0xf3, 0x36, 0x54, 0x3a, 0xf1, 0x61, 0xe4,
+	0xf5, 0x79, 0x34, 0xd6, 0x77, 0x6b, 0x06, 0xe0, 0x19, 0x4d, 0x78, 0xa2, 0x6e, 0xbc, 0x0a, 0x53,
+	0x04, 0xd9, 0x84, 0xd2, 0x23, 0x76, 0xd8, 0x92, 0x2a, 0x8b, 0x93, 0x2a, 0x0d, 0x4e, 0x1f, 0x40,
+	0x5d, 0x7a, 0x82, 0xf2, 0xa6, 0xb2, 0x6e, 0xc2, 0x82, 0xc4, 0x52, 0xcf, 0x34, 0x95, 0x19, 0xb1,
+	0x73, 0x46, 0xe8, 0x43, 0xa5, 0x61, 0xff, 0x52, 0x04, 0x49, 0xae, 0x36, 0x91, 0x46, 0x05, 0x35,
+	0xa6, 0x08, 0x72, 0x5b, 0x45, 0xad, 0xc3, 0x2b, 0x4b, 0x5f, 0x24, 0xcd, 0x10, 0xa5, 0x63, 0x00,
+	0xe3, 0xc9, 0x30, 0x4e, 0x65, 0xad, 0x59, 0xb2, 0x84, 0x9a, 0xf2, 0xd1, 0x47, 0x14, 0x24, 0x5f,
+	0x21, 0xcc, 0x14, 0xd6, 0x3b, 0x59, 0x61, 0xa9, 0xfd, 0x5c, 0x4e, 0xf7, 0x5d, 0xd9, 0xc8, 0xca,
+	0xeb, 0x1c, 0xaa, 0x39, 0x7c, 0x66, 0x8d, 0xdd, 0x4d, 0x8b, 0xc3, 0xce, 0x94, 0x21, 0xa2, 0x95,
+	0x69, 0xf6, 0x9c, 0xe6, 0xe4, 0x41, 0x35, 0xb7, 0x68, 0xa6, 0xa5, 0x26, 0x2c, 0x4f, 0x1e, 0x78,
+	0x73, 0xe7, 0x4c, 0xc3, 0x73, 0x4c, 0x7d, 0x6b, 0x41, 0xad, 0xe5, 0x0f, 0xe3, 0x44, 0x44, 0x69,
+	0x4e, 0x2b, 0x1a, 0x48, 0xb7, 0x36, 0x03, 0x66, 0xef, 0x2e, 0xd9, 0x80, 0xa2, 0xcc, 0xb8, 0x3a,
+	0xdc, 0xf9, 0x8d, 0x50, 0x70, 0x6e, 0x27, 0x0a, 0x57, 0xed, 0x04, 0x3d, 0x81, 0xf2, 0xde, 0x51,
+	0xe7, 0x51, 0x14, 0x0e, 0x07, 0x33, 0x23, 0x36, 0x43, 0x9e, 0x9d, 0x1b, 0xf2, 0xea, 0x6a, 0x60,
+	0x51, 0x51, 0xe1, 0x8c, 0x52, 0x57, 0x33, 0x4a, 0x41, 0x23, 0x7c, 0x44, 0x8f, 0x60, 0x45, 0x85,
+	0x2b, 0x3b, 0xce, 0x75, 0xda, 0xa2, 0x99, 0x22, 0x9c, 0x6c, 0x8a, 0x90, 0x4a, 0x55, 0xd7, 0xfd,
+	0x27, 0x95, 0xfe, 0x6a, 0xc3, 0x0a, 0x13, 0xb1, 0xf7, 0x4a, 0x74, 0x82, 0x38, 0x89, 0x86, 0x5d,
+	0xd9, 0x71, 0xe4, 0xfa, 0x4f, 0xc2, 0x53, 0xbd, 0x17, 0x0e, 0x53, 0xc4, 0xdb, 0x4f, 0x09, 0xa1,
+	0x50, 0xca, 0x37, 0x81, 0xbc, 0x80, 0x61, 0x90, 0x2d, 0x28, 0x1d, 0x85, 0xc3, 0xa8, 0x9b, 0x56,
+	0x3e, 0x76, 0x6e, 0x65, 0x5f, 0x31, 0x98, 0x11, 0x20, 0x8f, 0x81, 0x1c, 0x47, 0x3c, 0x88, 0x7d,
+	0x2e, 0x5d, 0x32, 0xcb, 0xca, 0xd9, 0x78, 0x92, 0xe3, 0x4e, 0x68, 0x98, 0xb1, 0x8c, 0x6c, 0xe7,
+	0x8f, 0xb0, 0x5b, 0x42, 0xff, 0x96, 0x8c, 0x7f, 0xfa, 0x9c, 0xe4, 0x0f, 0xf9, 0xfd, 0xa9, 0x0a,
+	0x75, 0x17, 0x70, 0xc9, 0x8a, 0x5c, 0x32, 0xc1, 0x60, 0x93, 0x72, 0xf4, 0x2b, 0x0b, 0x16, 0xf3,
+	0xde, 0xcc, 0x69, 0x17, 0xe9, 0xf6, 0xd9, 0xf3, 0xa7, 0x1d, 0xb3, 0x7d, 0x85, 0x59, 0x93, 0x65,
+	0x31, 0x3f, 0x01, 0x85, 0xf0, 0x9f, 0x2b, 0x92, 0x73, 0x2d, 0x77, 0x1a, 0x50, 0x3d, 0xe4, 0x51,
+	0xe2, 0x49, 0x65, 0xfa, 0x9e, 0x2e, 0xb2, 0x3c, 0x44, 0x05, 0xac, 0xbd, 0x51, 0x44, 0xad, 0xb0,
+	0x3f, 0x90, 0xd5, 0x7a, 0xad, 0x62, 0x92, 0x6d, 0x3a, 0x8a, 0xc2, 0xc8, 0x64, 0x00, 0x09, 0xba,
+	0x07, 0xe5, 0xe3, 0x70, 0x10, 0xfa, 0xe1, 0xd9, 0x78, 0x4e, 0xcb, 0x70, 0xa1, 0xa4, 0xae, 0x06,
+	0xd5, 0xa2, 0x2a, 0xcc, 0x90, 0xf4, 0x86, 0xac, 0xf7, 0x2e, 0xf7, 0xbb, 0x43, 0x9f, 0x27, 0x02,
+	0xe7, 0x63, 0x04, 0x9f, 0x84, 0xbc, 0xa7, 0xba, 0x82, 0x3e, 0x5a, 0xf4, 0x33, 0x5d, 0x80, 0x1c,
+	0xc3, 0xc9, 0x5d, 0x41, 0xbb, 0x08, 0x98, 0x2b, 0x48, 0x51, 0xe4, 0x7d, 0xa8, 0xe6, 0xa4, 0x75,
+	0x58, 0xcb, 0x69, 0x9d, 0x2a, 0x98, 0xe5, 0x65, 0xe8, 0x4f, 0xd6, 0xc4, 0x9a, 0x37, 0xee, 0x5c,
+	0x6d, 0xea, 0x52, 0x25, 0xa9, 0xcc, 0x34, 0x25, 0x43, 0xdf, 0x1f, 0x75, 0xfd, 0x61, 0x2c, 0x59,
+	0xfa, 0xc2, 0x4d, 0x01, 0x19, 0xba, 0x7c, 0x02, 0x85, 0x43, 0x33, 0xdc, 0x18, 0x52, 0x3e, 0x96,
+	0xda, 0x82, 0xf7, 0x7c, 0x2f, 0x10, 0x58, 0x2f, 0x0e, 0x4b, 0x69, 0xb2, 0xa5, 0x7a, 0xac, 0x29,
+	0xf4, 0xd5, 0x29, 0xc7, 0x91, 0xa7, 0x3a, 0x6f, 0x4c, 0x09, 0xd4, 0xa7, 0x59, 0x74, 0x15, 0x88,
+	0xaa, 0x80, 0xdd, 0xd3, 0x30, 0x32, 0xb7, 0x2d, 0x6d, 0x99, 0xe6, 0x22, 0xb3, 0x3f, 0xef, 0x12,
+	0xcf, 0x32, 0x6b, 0xe7, 0x33, 0x4b, 0x3f, 0x85, 0x25, 0x3d, 0xdb, 0x89, 0x08, 0x0b, 0x5a, 0x26,
+	0x80, 0x89, 0x6e, 0x28, 0xc7, 0x44, 0xf3, 0xaa, 0xc9, 0x00, 0xa9, 0xe7, 0x44, 0x3e, 0x32, 0xcc,
+	0xed, 0xa4, 0x29, 0x9c, 0x8d, 0xbc, 0xb3, 0x40, 0xf4, 0xf0, 0xc6, 0x70, 0x98, 0xa6, 0xe8, 0xf7,
+	0x36, 0xac, 0xaa, 0xa1, 0x33, 0x38, 0x13, 0x71, 0x92, 0x99, 0x91, 0x0f, 0xeb, 0x01, 0xf6, 0x7f,
+	0xed, 0xa8, 0xa2, 0xe4, 0x23, 0xba, 0xe5, 0x0b, 0x1e, 0x65, 0x3e, 0x28, 0x43, 0x53, 0xa8, 0x3c,
+	0x37, 0x88, 0xe8, 0xeb, 0x59, 0x0d, 0xa1, 0x79, 0x88, 0xec, 0x41, 0x59, 0x87, 0x66, 0x1a, 0xe2,
+	0x1d, 0xbc, 0xa5, 0x66, 0x78, 0x63, 0xe6, 0xdb, 0x58, 0xbf, 0xc1, 0x0c, 0xb9, 0xfe, 0x0c, 0x6a,
+	0x13, 0xac, 0x19, 0x6f, 0xb0, 0x66, 0xfe, 0x0d, 0x56, 0xdd, 0x21, 0xb9, 0x71, 0x59, 0x6b, 0xcf,
+	0xbf, 0xcb, 0x5a, 0xf0, 0xef, 0x59, 0x0e, 0xc4, 0x64, 0x0b, 0x1c, 0xe9, 0xa8, 0x1a, 0x86, 0xdd,
+	0xab, 0x1c, 0x65, 0x52, 0x88, 0xfe, 0x68, 0xe9, 0xa4, 0x0a, 0xcd, 0x37, 0x6f, 0xe9, 0x7b, 0x79,
+	0x25, 0x9b, 0xa9, 0x92, 0x29, 0xb1, 0xed, 0x34, 0x50, 0x29, 0xbd, 0xfe, 0x1c, 0xca, 0xb3, 0xc2,
+	0x2b, 0xa8, 0xf0, 0xde, 0x9b, 0x0c, 0x6f, 0xed, 0x2a, 0xcf, 0xe2, 0x5c, 0x94, 0x7b, 0xf5, 0x5f,
+	0x5e, 0x6f, 0x58, 0xbf, 0xbd, 0xde, 0xb0, 0x7e, 0x7f, 0xbd, 0x61, 0xfd, 0xf0, 0xc7, 0xc6, 0xbf,
+	0x4e, 0x17, 0xf0, 0x97, 0xd1, 0xbd, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xd0, 0x83, 0x3d, 0x4c,
+	0x55, 0x12, 0x00, 0x00,
 }
 
 func (m *IndexMeta) Marshal() (dAtA []byte, err error) {
@@ -2945,10 +2945,10 @@ func (m *FieldOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if len(m.Ttl) > 0 {
-		i -= len(m.Ttl)
-		copy(dAtA[i:], m.Ttl)
-		i = encodeVarintPrivate(dAtA, i, uint64(len(m.Ttl)))
+	if len(m.TTL) > 0 {
+		i -= len(m.TTL)
+		copy(dAtA[i:], m.TTL)
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.TTL)))
 		i--
 		dAtA[i] = 0x1
 		i--
@@ -5292,7 +5292,7 @@ func (m *FieldOptions) Size() (n int) {
 	if l > 0 {
 		n += 2 + l + sovPrivate(uint64(l))
 	}
-	l = len(m.Ttl)
+	l = len(m.TTL)
 	if l > 0 {
 		n += 2 + l + sovPrivate(uint64(l))
 	}
@@ -6356,7 +6356,10 @@ func (m *IndexMeta) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -6789,7 +6792,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 20:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Ttl", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -6817,7 +6820,7 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Ttl = string(dAtA[iNdEx:postIndex])
+			m.TTL = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -6825,7 +6828,10 @@ func (m *FieldOptions) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -6908,7 +6914,10 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -7093,7 +7102,10 @@ func (m *BlockDataRequest) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -7296,7 +7308,10 @@ func (m *BlockDataResponse) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -7423,7 +7438,10 @@ func (m *Cache) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -7570,7 +7588,7 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 					if err != nil {
 						return err
 					}
-					if (skippy < 0) || (iNdEx+skippy) < 0 {
+					if skippy < 0 {
 						return ErrInvalidLengthPrivate
 					}
 					if (iNdEx + skippy) > postIndex {
@@ -7587,7 +7605,10 @@ func (m *MaxShards) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -7721,7 +7742,10 @@ func (m *CreateShardMessage) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -7804,7 +7828,10 @@ func (m *DeleteIndexMessage) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -7942,7 +7969,10 @@ func (m *CreateIndexMessage) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -8112,7 +8142,10 @@ func (m *CreateFieldMessage) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -8227,7 +8260,10 @@ func (m *DeleteFieldMessage) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -8361,7 +8397,10 @@ func (m *DeleteAvailableShardMessage) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -8531,7 +8570,10 @@ func (m *Field) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -8616,7 +8658,10 @@ func (m *Schema) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -8788,7 +8833,10 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -8922,7 +8970,10 @@ func (m *URI) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -9129,7 +9180,10 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -9244,7 +9298,10 @@ func (m *NodeStateMessage) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -9350,7 +9407,10 @@ func (m *NodeEventMessage) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -9507,7 +9567,10 @@ func (m *NodeStatus) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -9643,7 +9706,10 @@ func (m *IndexStatus) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -9821,7 +9887,10 @@ func (m *FieldStatus) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -10006,7 +10075,10 @@ func (m *ClusterStatus) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -10159,7 +10231,10 @@ func (m *BSIGroup) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -10306,7 +10381,10 @@ func (m *CreateViewMessage) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -10453,7 +10531,10 @@ func (m *DeleteViewMessage) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -10735,7 +10816,10 @@ func (m *ResizeInstruction) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -10937,7 +11021,10 @@ func (m *ResizeSource) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -11075,7 +11162,10 @@ func (m *TranslationResizeSource) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -11213,7 +11303,10 @@ func (m *ResizeInstructionComplete) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -11328,7 +11421,10 @@ func (m *Topology) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -11379,7 +11475,10 @@ func (m *RecalculateCaches) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -11430,7 +11529,10 @@ func (m *LoadSchemaMessage) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -11549,7 +11651,10 @@ func (m *TransactionMessage) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -11746,7 +11851,10 @@ func (m *Transaction) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -11797,7 +11905,10 @@ func (m *TransactionStats) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -11848,7 +11959,10 @@ func (m *ResizeAbortMessage) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -11963,7 +12077,10 @@ func (m *ResizeNodeMessage) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -12242,7 +12359,10 @@ func (m *FieldOperation) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -12545,7 +12665,7 @@ func (m *ShardIngestOperation) Unmarshal(dAtA []byte) error {
 					if err != nil {
 						return err
 					}
-					if (skippy < 0) || (iNdEx+skippy) < 0 {
+					if skippy < 0 {
 						return ErrInvalidLengthPrivate
 					}
 					if (iNdEx + skippy) > postIndex {
@@ -12562,7 +12682,10 @@ func (m *ShardIngestOperation) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -12647,7 +12770,10 @@ func (m *ShardIngestOperations) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
@@ -12796,7 +12922,7 @@ func (m *ShardedIngestRequest) Unmarshal(dAtA []byte) error {
 					if err != nil {
 						return err
 					}
-					if (skippy < 0) || (iNdEx+skippy) < 0 {
+					if skippy < 0 {
 						return ErrInvalidLengthPrivate
 					}
 					if (iNdEx + skippy) > postIndex {
@@ -12813,7 +12939,10 @@ func (m *ShardedIngestRequest) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPrivate
 			}
 			if (iNdEx + skippy) > l {
diff --git a/pb/private.proto b/pb/private.proto
index 9c4c37f25..99e2a76e3 100644
--- a/pb/private.proto
+++ b/pb/private.proto
@@ -25,7 +25,7 @@ message FieldOptions {
 	Decimal Min = 17;
 	Decimal Max = 18;
 	string TimeUnit = 19;
-	string Ttl = 20;
+	string TTL = 20;
 }
 
 message ImportResponse {
diff --git a/pb/public.pb.go b/pb/public.pb.go
index a31efe263..0fff5709b 100644
--- a/pb/public.pb.go
+++ b/pb/public.pb.go
@@ -6149,7 +6149,10 @@ func (m *Row) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -6234,7 +6237,10 @@ func (m *RowMatrix) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -6357,7 +6363,10 @@ func (m *SignedRow) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -6516,7 +6525,10 @@ func (m *RowIdentifiers) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -6643,7 +6655,10 @@ func (m *IDList) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -6747,7 +6762,10 @@ func (m *ExtractedIDColumn) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -6864,7 +6882,10 @@ func (m *ExtractedIDMatrix) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -6947,7 +6968,10 @@ func (m *KeyList) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -7161,7 +7185,10 @@ func (m *ExtractedTableValue) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -7298,7 +7325,10 @@ func (m *ExtractedTableColumn) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -7413,7 +7443,10 @@ func (m *ExtractedTableField) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -7532,7 +7565,10 @@ func (m *ExtractedTable) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -7653,7 +7689,10 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -7772,7 +7811,10 @@ func (m *PairField) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -7889,7 +7931,10 @@ func (m *PairsField) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -7959,7 +8004,10 @@ func (m *Int64) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -8129,7 +8177,10 @@ func (m *FieldRow) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -8252,7 +8303,10 @@ func (m *GroupCount) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -8420,7 +8474,10 @@ func (m *ValCount) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -8509,7 +8566,10 @@ func (m *Decimal) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -8624,7 +8684,10 @@ func (m *DistinctTimestamp) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -8876,7 +8939,10 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -8993,7 +9059,10 @@ func (m *QueryResponse) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -9642,7 +9711,10 @@ func (m *QueryResult) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -10126,7 +10198,10 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -10588,7 +10663,10 @@ func (m *ImportValueRequest) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -10758,7 +10836,10 @@ func (m *AtomicRecord) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -10841,7 +10922,10 @@ func (m *AtomicImportResponse) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -11008,7 +11092,10 @@ func (m *TranslateKeysRequest) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -11135,7 +11222,10 @@ func (m *TranslateKeysResponse) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -11326,7 +11416,10 @@ func (m *TranslateIDsRequest) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -11409,7 +11502,10 @@ func (m *TranslateIDsResponse) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -11526,7 +11622,10 @@ func (m *ImportRoaringRequestView) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -11740,7 +11839,10 @@ func (m *ImportRoaringRequest) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
@@ -11857,7 +11959,10 @@ func (m *GroupCounts) Unmarshal(dAtA []byte) error {
 			if err != nil {
 				return err
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			if skippy < 0 {
+				return ErrInvalidLengthPublic
+			}
+			if (iNdEx + skippy) < 0 {
 				return ErrInvalidLengthPublic
 			}
 			if (iNdEx + skippy) > l {
diff --git a/server.go b/server.go
index 12efb6375..baa3fb463 100644
--- a/server.go
+++ b/server.go
@@ -168,9 +168,9 @@ func OptServerAntiEntropyInterval(interval time.Duration) ServerOption {
 	}
 }
 
-// OptServerTtlRemovalInterval is a functional option on Server
+// OptServerTTLRemovalInterval is a functional option on Server
 // used to set the ttl removal interval.
-func OptServerTtlRemovalInterval(interval time.Duration) ServerOption {
+func OptServerTTLRemovalInterval(interval time.Duration) ServerOption {
 	return func(s *Server) error {
 		s.ttlRemovalInterval = interval
 		return nil
@@ -658,7 +658,7 @@ func (s *Server) Open() error {
 	go func() { defer s.wg.Done(); s.monitorAntiEntropy() }()
 	go func() { defer s.wg.Done(); s.monitorRuntime() }()
 	go func() { defer s.wg.Done(); s.monitorDiagnostics() }()
-	go func() { defer s.wg.Done(); s.monitorTtl() }()
+	go func() { defer s.wg.Done(); s.monitorTTL() }()
 
 	toSend := func() []Message {
 		s.holder.startMsgsMu.Lock()
@@ -842,26 +842,26 @@ func (s *Server) monitorResetTranslationSync() {
 	}
 }
 
-func (s *Server) monitorTtl() {
+func (s *Server) monitorTTL() {
 	ctx := context.Background()
-	// Run TtlRemoval on server start
-	s.TtlRemoval(ctx)
+	// Run TTLRemoval on server start
+	s.TTLRemoval(ctx)
 	ticker := time.NewTicker(s.ttlRemovalInterval)
 	for {
 		select {
 		case <-s.closing:
 			return
 		case <-ticker.C:
-			s.TtlRemoval(ctx)
+			s.TTLRemoval(ctx)
 		}
 	}
 }
 
-func (s *Server) TtlRemoval(ctx context.Context) {
+func (s *Server) TTLRemoval(ctx context.Context) {
 	for _, index := range s.holder.Indexes() {
 		for _, field := range index.Fields() {
 			if field.Options().Type == "time" {
-				if field.Options().Ttl > 0 {
+				if field.Options().TTL > 0 {
 					for _, view := range field.views() {
 						viewNames := strings.Split(view.name, "_")
 						if len(viewNames) >= 2 {
@@ -872,7 +872,7 @@ func (s *Server) TtlRemoval(ctx context.Context) {
 							}
 							timeSince := time.Since(viewTime)
 
-							if timeSince >= field.Options().Ttl {
+							if timeSince >= field.Options().TTL {
 								for _, shard := range field.AvailableShards(true).Slice() {
 									s.holder.txf.DeleteFragmentFromStore(index.Name(), field.Name(), view.name, shard, nil)
 								}
diff --git a/server_test.go b/server_test.go
index 487a39286..1e0b28ae9 100644
--- a/server_test.go
+++ b/server_test.go
@@ -13,7 +13,7 @@ import (
 	"github.com/molecula/featurebase/v3/test"
 )
 
-func TestTtlRemoval(t *testing.T) {
+func TestTTLRemoval(t *testing.T) {
 
 	cluster := test.MustRunCluster(t, 1)
 	node := cluster.GetNode(0)
@@ -28,7 +28,7 @@ func TestTtlRemoval(t *testing.T) {
 	// Create indexes and field with ttl lasting 24 hours
 	if err := client.CreateIndex(context.Background(), indexName, pilosa.IndexOptions{TrackExistence: true}); err != nil && err != pilosa.ErrIndexExists {
 		t.Fatalf("creating index, err: %v", err)
-	} else if err := client.CreateFieldWithOptions(context.Background(), indexName, fieldName, pilosa.FieldOptions{Ttl: time.Hour * 24, Type: pilosa.FieldTypeTime, TimeQuantum: "YMDH"}); err != nil {
+	} else if err := client.CreateFieldWithOptions(context.Background(), indexName, fieldName, pilosa.FieldOptions{TTL: time.Hour * 24, Type: pilosa.FieldTypeTime, TimeQuantum: "YMDH"}); err != nil {
 		t.Fatalf("creating field, err: %v", err)
 	}
 
@@ -69,7 +69,7 @@ func TestTtlRemoval(t *testing.T) {
 		t.Fatalf("setting sample data 3, err: %v", err)
 	}
 
-	node.Server.TtlRemoval(context.Background())
+	node.Server.TTLRemoval(context.Background())
 
 	// Get all the views for given index + field
 	views, err := node.API.Views(context.Background(), indexName, fieldName)