iSharkFly-Docs
/
packer-cn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add dependencies to vendor/

This commit is contained in:
Gennady Lipenkov 2019-03-26 15:48:37 +03:00
parent af333a5de0
commit 9f3884814c
191 changed files with 66866 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
vendor/github.com/c2h5oh/datasize/LICENSE generated vendored Normal file
View File

@ -0,0 +1,21 @@
The MIT License (MIT)
Copyright (c) 2016 Maciej Lisiewski
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

66
vendor/github.com/c2h5oh/datasize/README.md generated vendored Normal file
View File

@ -0,0 +1,66 @@
# datasize [![Build Status](https://travis-ci.org/c2h5oh/datasize.svg?branch=master)](https://travis-ci.org/c2h5oh/datasize)
Golang helpers for data sizes
### Constants
Just like `time` package provides `time.Second`, `time.Day` constants `datasize` provides:
* `datasize.B` 1 byte
* `datasize.KB` 1 kilobyte
* `datasize.MB` 1 megabyte
* `datasize.GB` 1 gigabyte
* `datasize.TB` 1 terabyte
* `datasize.PB` 1 petabyte
* `datasize.EB` 1 exabyte
### Helpers
Just like `time` package provides `duration.Nanoseconds() uint64 `, `duration.Hours() float64` helpers `datasize` has
* `ByteSize.Bytes() uint64`
* `ByteSize.Kilobytes() float4`
* `ByteSize.Megabytes() float64`
* `ByteSize.Gigabytes() float64`
* `ByteSize.Terabytes() float64`
* `ByteSize.Petebytes() float64`
* `ByteSize.Exabytes() float64`
Warning: see limitations at the end of this document about a possible precission loss
### Parsing strings
`datasize.ByteSize` implements `TextUnmarshaler` interface and will automatically parse human readable strings into correct values where it is used:
* `"10 MB"` -> `10* datasize.MB`
* `"10240 g"` -> `10 * datasize.TB`
* `"2000"` -> `2000 * datasize.B`
* `"1tB"` -> `datasize.TB`
* `"5 peta"` -> `5 * datasize.PB`
* `"28 kilobytes"` -> `28 * datasize.KB`
* `"1 gigabyte"` -> `1 * datasize.GB`
You can also do it manually:
```go
var v datasize.ByteSize
err := v.UnmarshalText([]byte("100 mb"))
```
### Printing
`Bytesize.String()` uses largest unit allowing an integer value:
* `(102400 * datasize.MB).String()` -> `"100GB"`
* `(datasize.MB + datasize.KB).String()` -> `"1025KB"`
Use `%d` format string to get value in bytes without a unit
### JSON and other encoding
Both `TextMarshaler` and `TextUnmarshaler` interfaces are implemented - JSON will just work. Other encoders will work provided they use those interfaces.
### Human readable
`ByteSize.HumanReadable()` or `ByteSize.HR()` returns a string with 1-3 digits, followed by 1 decimal place, a space and unit big enough to get 1-3 digits
* `(102400 * datasize.MB).String()` -> `"100.0 GB"`
* `(datasize.MB + 512 * datasize.KB).String()` -> `"1.5 MB"`
### Limitations
* The underlying data type for `data.ByteSize` is `uint64`, so values outside of 0 to 2^64-1 range will overflow
* size helper functions (like `ByteSize.Kilobytes()`) return `float64`, which can't represent all possible values of `uint64` accurately:
* if the returned value is supposed to have no fraction (ie `(10 * datasize.MB).Kilobytes()`) accuracy loss happens when value is more than 2^53 larger than unit: `.Kilobytes()` over 8 petabytes, `.Megabytes()` over 8 exabytes
* if the returned value is supposed to have a fraction (ie `(datasize.PB + datasize.B).Megabytes()`) in addition to the above note accuracy loss may occur in fractional part too - larger integer part leaves fewer bytes to store fractional part, the smaller the remainder vs unit the move bytes are required to store the fractional part
* Parsing a string with `Mb`, `Tb`, etc units will return a syntax error, because capital followed by lower case is commonly used for bits, not bytes
* Parsing a string with value exceeding 2^64-1 bytes will return 2^64-1 and an out of range error

217
vendor/github.com/c2h5oh/datasize/datasize.go generated vendored Normal file
View File

@ -0,0 +1,217 @@
package datasize
import (
"errors"
"fmt"
"strconv"
"strings"
)
type ByteSize uint64
const (
B ByteSize = 1
KB = B << 10
MB = KB << 10
GB = MB << 10
TB = GB << 10
PB = TB << 10
EB = PB << 10
fnUnmarshalText string = "UnmarshalText"
maxUint64 uint64 = (1 << 64) - 1
cutoff uint64 = maxUint64 / 10
)
var ErrBits = errors.New("unit with capital unit prefix and lower case unit (b) - bits, not bytes ")
func (b ByteSize) Bytes() uint64 {
return uint64(b)
}
func (b ByteSize) KBytes() float64 {
v := b / KB
r := b % KB
return float64(v) + float64(r)/float64(KB)
}
func (b ByteSize) MBytes() float64 {
v := b / MB
r := b % MB
return float64(v) + float64(r)/float64(MB)
}
func (b ByteSize) GBytes() float64 {
v := b / GB
r := b % GB
return float64(v) + float64(r)/float64(GB)
}
func (b ByteSize) TBytes() float64 {
v := b / TB
r := b % TB
return float64(v) + float64(r)/float64(TB)
}
func (b ByteSize) PBytes() float64 {
v := b / PB
r := b % PB
return float64(v) + float64(r)/float64(PB)
}
func (b ByteSize) EBytes() float64 {
v := b / EB
r := b % EB
return float64(v) + float64(r)/float64(EB)
}
func (b ByteSize) String() string {
switch {
case b == 0:
return fmt.Sprint("0B")
case b%EB == 0:
return fmt.Sprintf("%dEB", b/EB)
case b%PB == 0:
return fmt.Sprintf("%dPB", b/PB)
case b%TB == 0:
return fmt.Sprintf("%dTB", b/TB)
case b%GB == 0:
return fmt.Sprintf("%dGB", b/GB)
case b%MB == 0:
return fmt.Sprintf("%dMB", b/MB)
case b%KB == 0:
return fmt.Sprintf("%dKB", b/KB)
default:
return fmt.Sprintf("%dB", b)
}
}
func (b ByteSize) HR() string {
return b.HumanReadable()
}
func (b ByteSize) HumanReadable() string {
switch {
case b > EB:
return fmt.Sprintf("%.1f EB", b.EBytes())
case b > PB:
return fmt.Sprintf("%.1f PB", b.PBytes())
case b > TB:
return fmt.Sprintf("%.1f TB", b.TBytes())
case b > GB:
return fmt.Sprintf("%.1f GB", b.GBytes())
case b > MB:
return fmt.Sprintf("%.1f MB", b.MBytes())
case b > KB:
return fmt.Sprintf("%.1f KB", b.KBytes())
default:
return fmt.Sprintf("%d B", b)
}
}
func (b ByteSize) MarshalText() ([]byte, error) {
return []byte(b.String()), nil
}
func (b *ByteSize) UnmarshalText(t []byte) error {
var val uint64
var unit string
// copy for error message
t0 := t
var c byte
var i int
ParseLoop:
for i < len(t) {
c = t[i]
switch {
case '0' <= c && c <= '9':
if val > cutoff {
goto Overflow
}
c = c - '0'
val *= 10
if val > val+uint64(c) {
// val+v overflows
goto Overflow
}
val += uint64(c)
i++
default:
if i == 0 {
goto SyntaxError
}
break ParseLoop
}
}
unit = strings.TrimSpace(string(t[i:]))
switch unit {
case "Kb", "Mb", "Gb", "Tb", "Pb", "Eb":
goto BitsError
}
unit = strings.ToLower(unit)
switch unit {
case "", "b", "byte":
// do nothing - already in bytes
case "k", "kb", "kilo", "kilobyte", "kilobytes":
if val > maxUint64/uint64(KB) {
goto Overflow
}
val *= uint64(KB)
case "m", "mb", "mega", "megabyte", "megabytes":
if val > maxUint64/uint64(MB) {
goto Overflow
}
val *= uint64(MB)
case "g", "gb", "giga", "gigabyte", "gigabytes":
if val > maxUint64/uint64(GB) {
goto Overflow
}
val *= uint64(GB)
case "t", "tb", "tera", "terabyte", "terabytes":
if val > maxUint64/uint64(TB) {
goto Overflow
}
val *= uint64(TB)
case "p", "pb", "peta", "petabyte", "petabytes":
if val > maxUint64/uint64(PB) {
goto Overflow
}
val *= uint64(PB)
case "E", "EB", "e", "eb", "eB":
if val > maxUint64/uint64(EB) {
goto Overflow
}
val *= uint64(EB)
default:
goto SyntaxError
}
*b = ByteSize(val)
return nil
Overflow:
*b = ByteSize(maxUint64)
return &strconv.NumError{fnUnmarshalText, string(t0), strconv.ErrRange}
SyntaxError:
*b = 0
return &strconv.NumError{fnUnmarshalText, string(t0), strconv.ErrSyntax}
BitsError:
*b = 0
return &strconv.NumError{fnUnmarshalText, string(t0), ErrBits}
}

50
vendor/github.com/ghodss/yaml/LICENSE generated vendored Normal file
View File

@ -0,0 +1,50 @@
The MIT License (MIT)
Copyright (c) 2014 Sam Ghods
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Copyright (c) 2012 The Go Authors. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
* Neither the name of Google Inc. nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

121
vendor/github.com/ghodss/yaml/README.md generated vendored Normal file
View File

@ -0,0 +1,121 @@
# YAML marshaling and unmarshaling support for Go
[![Build Status](https://travis-ci.org/ghodss/yaml.svg)](https://travis-ci.org/ghodss/yaml)
## Introduction
A wrapper around [go-yaml](https://github.com/go-yaml/yaml) designed to enable a better way of handling YAML when marshaling to and from structs.
In short, this library first converts YAML to JSON using go-yaml and then uses `json.Marshal` and `json.Unmarshal` to convert to or from the struct. This means that it effectively reuses the JSON struct tags as well as the custom JSON methods `MarshalJSON` and `UnmarshalJSON` unlike go-yaml. For a detailed overview of the rationale behind this method, [see this blog post](http://ghodss.com/2014/the-right-way-to-handle-yaml-in-golang/).
## Compatibility
This package uses [go-yaml](https://github.com/go-yaml/yaml) and therefore supports [everything go-yaml supports](https://github.com/go-yaml/yaml#compatibility).
## Caveats
**Caveat #1:** When using `yaml.Marshal` and `yaml.Unmarshal`, binary data should NOT be preceded with the `!!binary` YAML tag. If you do, go-yaml will convert the binary data from base64 to native binary data, which is not compatible with JSON. You can still use binary in your YAML files though - just store them without the `!!binary` tag and decode the base64 in your code (e.g. in the custom JSON methods `MarshalJSON` and `UnmarshalJSON`). This also has the benefit that your YAML and your JSON binary data will be decoded exactly the same way. As an example:
```
BAD:
exampleKey: !!binary gIGC
GOOD:
exampleKey: gIGC
... and decode the base64 data in your code.
```
**Caveat #2:** When using `YAMLToJSON` directly, maps with keys that are maps will result in an error since this is not supported by JSON. This error will occur in `Unmarshal` as well since you can't unmarshal map keys anyways since struct fields can't be keys.
## Installation and usage
To install, run:
```
$ go get github.com/ghodss/yaml
```
And import using:
```
import "github.com/ghodss/yaml"
```
Usage is very similar to the JSON library:
```go
package main
import (
"fmt"
"github.com/ghodss/yaml"
)
type Person struct {
Name string `json:"name"` // Affects YAML field names too.
Age int `json:"age"`
}
func main() {
// Marshal a Person struct to YAML.
p := Person{"John", 30}
y, err := yaml.Marshal(p)
if err != nil {
fmt.Printf("err: %v\n", err)
return
}
fmt.Println(string(y))
/* Output:
age: 30
name: John
*/
// Unmarshal the YAML back into a Person struct.
var p2 Person
err = yaml.Unmarshal(y, &p2)
if err != nil {
fmt.Printf("err: %v\n", err)
return
}
fmt.Println(p2)
/* Output:
{John 30}
*/
}
```
`yaml.YAMLToJSON` and `yaml.JSONToYAML` methods are also available:
```go
package main
import (
"fmt"
"github.com/ghodss/yaml"
)
func main() {
j := []byte(`{"name": "John", "age": 30}`)
y, err := yaml.JSONToYAML(j)
if err != nil {
fmt.Printf("err: %v\n", err)
return
}
fmt.Println(string(y))
/* Output:
name: John
age: 30
*/
j2, err := yaml.YAMLToJSON(y)
if err != nil {
fmt.Printf("err: %v\n", err)
return
}
fmt.Println(string(j2))
/* Output:
{"age":30,"name":"John"}
*/
}
```

501
vendor/github.com/ghodss/yaml/fields.go generated vendored Normal file
View File

@ -0,0 +1,501 @@
// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package yaml
import (
"bytes"
"encoding"
"encoding/json"
"reflect"
"sort"
"strings"
"sync"
"unicode"
"unicode/utf8"
)
// indirect walks down v allocating pointers as needed,
// until it gets to a non-pointer.
// if it encounters an Unmarshaler, indirect stops and returns that.
// if decodingNull is true, indirect stops at the last pointer so it can be set to nil.
func indirect(v reflect.Value, decodingNull bool) (json.Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
// If v is a named type and is addressable,
// start with its address, so that if the type has pointer methods,
// we find them.
if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
v = v.Addr()
}
for {
// Load value from interface, but only if the result will be
// usefully addressable.
if v.Kind() == reflect.Interface && !v.IsNil() {
e := v.Elem()
if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
v = e
continue
}
}
if v.Kind() != reflect.Ptr {
break
}
if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {
break
}
if v.IsNil() {
if v.CanSet() {
v.Set(reflect.New(v.Type().Elem()))
} else {
v = reflect.New(v.Type().Elem())
}
}
if v.Type().NumMethod() > 0 {
if u, ok := v.Interface().(json.Unmarshaler); ok {
return u, nil, reflect.Value{}
}
if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
return nil, u, reflect.Value{}
}
}
v = v.Elem()
}
return nil, nil, v
}
// A field represents a single field found in a struct.
type field struct {
name string
nameBytes []byte // []byte(name)
equalFold func(s, t []byte) bool // bytes.EqualFold or equivalent
tag bool
index []int
typ reflect.Type
omitEmpty bool
quoted bool
}
func fillField(f field) field {
f.nameBytes = []byte(f.name)
f.equalFold = foldFunc(f.nameBytes)
return f
}
// byName sorts field by name, breaking ties with depth,
// then breaking ties with "name came from json tag", then
// breaking ties with index sequence.
type byName []field
func (x byName) Len() int { return len(x) }
func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
func (x byName) Less(i, j int) bool {
if x[i].name != x[j].name {
return x[i].name < x[j].name
}
if len(x[i].index) != len(x[j].index) {
return len(x[i].index) < len(x[j].index)
}
if x[i].tag != x[j].tag {
return x[i].tag
}
return byIndex(x).Less(i, j)
}
// byIndex sorts field by index sequence.
type byIndex []field
func (x byIndex) Len() int { return len(x) }
func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
func (x byIndex) Less(i, j int) bool {
for k, xik := range x[i].index {
if k >= len(x[j].index) {
return false
}
if xik != x[j].index[k] {
return xik < x[j].index[k]
}
}
return len(x[i].index) < len(x[j].index)
}
// typeFields returns a list of fields that JSON should recognize for the given type.
// The algorithm is breadth-first search over the set of structs to include - the top struct
// and then any reachable anonymous structs.
func typeFields(t reflect.Type) []field {
// Anonymous fields to explore at the current level and the next.
current := []field{}
next := []field{{typ: t}}
// Count of queued names for current level and the next.
count := map[reflect.Type]int{}
nextCount := map[reflect.Type]int{}
// Types already visited at an earlier level.
visited := map[reflect.Type]bool{}
// Fields found.
var fields []field
for len(next) > 0 {
current, next = next, current[:0]
count, nextCount = nextCount, map[reflect.Type]int{}
for _, f := range current {
if visited[f.typ] {
continue
}
visited[f.typ] = true
// Scan f.typ for fields to include.
for i := 0; i < f.typ.NumField(); i++ {
sf := f.typ.Field(i)
if sf.PkgPath != "" { // unexported
continue
}
tag := sf.Tag.Get("json")
if tag == "-" {
continue
}
name, opts := parseTag(tag)
if !isValidTag(name) {
name = ""
}
index := make([]int, len(f.index)+1)
copy(index, f.index)
index[len(f.index)] = i
ft := sf.Type
if ft.Name() == "" && ft.Kind() == reflect.Ptr {
// Follow pointer.
ft = ft.Elem()
}
// Record found field and index sequence.
if name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct {
tagged := name != ""
if name == "" {
name = sf.Name
}
fields = append(fields, fillField(field{
name: name,
tag: tagged,
index: index,
typ: ft,
omitEmpty: opts.Contains("omitempty"),
quoted: opts.Contains("string"),
}))
if count[f.typ] > 1 {
// If there were multiple instances, add a second,
// so that the annihilation code will see a duplicate.
// It only cares about the distinction between 1 or 2,
// so don't bother generating any more copies.
fields = append(fields, fields[len(fields)-1])
}
continue
}
// Record new anonymous struct to explore in next round.
nextCount[ft]++
if nextCount[ft] == 1 {
next = append(next, fillField(field{name: ft.Name(), index: index, typ: ft}))
}
}
}
}
sort.Sort(byName(fields))
// Delete all fields that are hidden by the Go rules for embedded fields,
// except that fields with JSON tags are promoted.
// The fields are sorted in primary order of name, secondary order
// of field index length. Loop over names; for each name, delete
// hidden fields by choosing the one dominant field that survives.
out := fields[:0]
for advance, i := 0, 0; i < len(fields); i += advance {
// One iteration per name.
// Find the sequence of fields with the name of this first field.
fi := fields[i]
name := fi.name
for advance = 1; i+advance < len(fields); advance++ {
fj := fields[i+advance]
if fj.name != name {
break
}
}
if advance == 1 { // Only one field with this name
out = append(out, fi)
continue
}
dominant, ok := dominantField(fields[i : i+advance])
if ok {
out = append(out, dominant)
}
}
fields = out
sort.Sort(byIndex(fields))
return fields
}
// dominantField looks through the fields, all of which are known to
// have the same name, to find the single field that dominates the
// others using Go's embedding rules, modified by the presence of
// JSON tags. If there are multiple top-level fields, the boolean
// will be false: This condition is an error in Go and we skip all
// the fields.
func dominantField(fields []field) (field, bool) {
// The fields are sorted in increasing index-length order. The winner
// must therefore be one with the shortest index length. Drop all
// longer entries, which is easy: just truncate the slice.
length := len(fields[0].index)
tagged := -1 // Index of first tagged field.
for i, f := range fields {
if len(f.index) > length {
fields = fields[:i]
break
}
if f.tag {
if tagged >= 0 {
// Multiple tagged fields at the same level: conflict.
// Return no field.
return field{}, false
}
tagged = i
}
}
if tagged >= 0 {
return fields[tagged], true
}
// All remaining fields have the same length. If there's more than one,
// we have a conflict (two fields named "X" at the same level) and we
// return no field.
if len(fields) > 1 {
return field{}, false
}
return fields[0], true
}
var fieldCache struct {
sync.RWMutex
m map[reflect.Type][]field
}
// cachedTypeFields is like typeFields but uses a cache to avoid repeated work.
func cachedTypeFields(t reflect.Type) []field {
fieldCache.RLock()
f := fieldCache.m[t]
fieldCache.RUnlock()
if f != nil {
return f
}
// Compute fields without lock.
// Might duplicate effort but won't hold other computations back.
f = typeFields(t)
if f == nil {
f = []field{}
}
fieldCache.Lock()
if fieldCache.m == nil {
fieldCache.m = map[reflect.Type][]field{}
}
fieldCache.m[t] = f
fieldCache.Unlock()
return f
}
func isValidTag(s string) bool {
if s == "" {
return false
}
for _, c := range s {
switch {
case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c):
// Backslash and quote chars are reserved, but
// otherwise any punctuation chars are allowed
// in a tag name.
default:
if !unicode.IsLetter(c) && !unicode.IsDigit(c) {
return false
}
}
}
return true
}
const (
caseMask = ^byte(0x20) // Mask to ignore case in ASCII.
kelvin = '\u212a'
smallLongEss = '\u017f'
)
// foldFunc returns one of four different case folding equivalence
// functions, from most general (and slow) to fastest:
//
// 1) bytes.EqualFold, if the key s contains any non-ASCII UTF-8
// 2) equalFoldRight, if s contains special folding ASCII ('k', 'K', 's', 'S')
// 3) asciiEqualFold, no special, but includes non-letters (including _)
// 4) simpleLetterEqualFold, no specials, no non-letters.
//
// The letters S and K are special because they map to 3 runes, not just 2:
// * S maps to s and to U+017F 'ſ' Latin small letter long s
// * k maps to K and to U+212A 'K' Kelvin sign
// See http://play.golang.org/p/tTxjOc0OGo
//
// The returned function is specialized for matching against s and
// should only be given s. It's not curried for performance reasons.
func foldFunc(s []byte) func(s, t []byte) bool {
nonLetter := false
special := false // special letter
for _, b := range s {
if b >= utf8.RuneSelf {
return bytes.EqualFold
}
upper := b & caseMask
if upper < 'A' || upper > 'Z' {
nonLetter = true
} else if upper == 'K' || upper == 'S' {
// See above for why these letters are special.
special = true
}
}
if special {
return equalFoldRight
}
if nonLetter {
return asciiEqualFold
}
return simpleLetterEqualFold
}
// equalFoldRight is a specialization of bytes.EqualFold when s is
// known to be all ASCII (including punctuation), but contains an 's',
// 'S', 'k', or 'K', requiring a Unicode fold on the bytes in t.
// See comments on foldFunc.
func equalFoldRight(s, t []byte) bool {
for _, sb := range s {
if len(t) == 0 {
return false
}
tb := t[0]
if tb < utf8.RuneSelf {
if sb != tb {
sbUpper := sb & caseMask
if 'A' <= sbUpper && sbUpper <= 'Z' {
if sbUpper != tb&caseMask {
return false
}
} else {
return false
}
}
t = t[1:]
continue
}
// sb is ASCII and t is not. t must be either kelvin
// sign or long s; sb must be s, S, k, or K.
tr, size := utf8.DecodeRune(t)
switch sb {
case 's', 'S':
if tr != smallLongEss {
return false
}
case 'k', 'K':
if tr != kelvin {
return false
}
default:
return false
}
t = t[size:]
}
if len(t) > 0 {
return false
}
return true
}
// asciiEqualFold is a specialization of bytes.EqualFold for use when
// s is all ASCII (but may contain non-letters) and contains no
// special-folding letters.
// See comments on foldFunc.
func asciiEqualFold(s, t []byte) bool {
if len(s) != len(t) {
return false
}
for i, sb := range s {
tb := t[i]
if sb == tb {
continue
}
if ('a' <= sb && sb <= 'z') || ('A' <= sb && sb <= 'Z') {
if sb&caseMask != tb&caseMask {
return false
}
} else {
return false
}
}
return true
}
// simpleLetterEqualFold is a specialization of bytes.EqualFold for
// use when s is all ASCII letters (no underscores, etc) and also
// doesn't contain 'k', 'K', 's', or 'S'.
// See comments on foldFunc.
func simpleLetterEqualFold(s, t []byte) bool {
if len(s) != len(t) {
return false
}
for i, b := range s {
if b&caseMask != t[i]&caseMask {
return false
}
}
return true
}
// tagOptions is the string following a comma in a struct field's "json"
// tag, or the empty string. It does not include the leading comma.
type tagOptions string
// parseTag splits a struct field's json tag into its name and
// comma-separated options.
func parseTag(tag string) (string, tagOptions) {
if idx := strings.Index(tag, ","); idx != -1 {
return tag[:idx], tagOptions(tag[idx+1:])
}
return tag, tagOptions("")
}
// Contains reports whether a comma-separated list of options
// contains a particular substr flag. substr must be surrounded by a
// string boundary or commas.
func (o tagOptions) Contains(optionName string) bool {
if len(o) == 0 {
return false
}
s := string(o)
for s != "" {
var next string
i := strings.Index(s, ",")
if i >= 0 {
s, next = s[:i], s[i+1:]
}
if s == optionName {
return true
}
s = next
}
return false
}

3
vendor/github.com/ghodss/yaml/go.mod generated vendored Normal file
View File

@ -0,0 +1,3 @@
module github.com/ghodss/yaml
require gopkg.in/yaml.v2 v2.2.2

3
vendor/github.com/ghodss/yaml/go.sum generated vendored Normal file
View File

@ -0,0 +1,3 @@
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

326
vendor/github.com/ghodss/yaml/yaml.go generated vendored Normal file
View File

@ -0,0 +1,326 @@
// Package yaml provides a wrapper around go-yaml designed to enable a better
// way of handling YAML when marshaling to and from structs.
//
// In short, this package first converts YAML to JSON using go-yaml and then
// uses json.Marshal and json.Unmarshal to convert to or from the struct. This
// means that it effectively reuses the JSON struct tags as well as the custom
// JSON methods MarshalJSON and UnmarshalJSON unlike go-yaml.
//
// See also http://ghodss.com/2014/the-right-way-to-handle-yaml-in-golang
//
package yaml // import "github.com/ghodss/yaml"
import (
"bytes"
"encoding/json"
"fmt"
"io"
"reflect"
"strconv"
"gopkg.in/yaml.v2"
)
// Marshals the object into JSON then converts JSON to YAML and returns the
// YAML.
func Marshal(o interface{}) ([]byte, error) {
j, err := json.Marshal(o)
if err != nil {
return nil, fmt.Errorf("error marshaling into JSON: %v", err)
}
y, err := JSONToYAML(j)
if err != nil {
return nil, fmt.Errorf("error converting JSON to YAML: %v", err)
}
return y, nil
}
// JSONOpt is a decoding option for decoding from JSON format.
type JSONOpt func(*json.Decoder) *json.Decoder
// Unmarshal converts YAML to JSON then uses JSON to unmarshal into an object,
// optionally configuring the behavior of the JSON unmarshal.
func Unmarshal(y []byte, o interface{}, opts ...JSONOpt) error {
return unmarshal(yaml.Unmarshal, y, o, opts)
}
// UnmarshalStrict is like Unmarshal except that any mapping keys that are
// duplicates will result in an error.
// To also be strict about unknown fields, add the DisallowUnknownFields option.
func UnmarshalStrict(y []byte, o interface{}, opts ...JSONOpt) error {
return unmarshal(yaml.UnmarshalStrict, y, o, opts)
}
func unmarshal(f func(in []byte, out interface{}) (err error), y []byte, o interface{}, opts []JSONOpt) error {
vo := reflect.ValueOf(o)
j, err := yamlToJSON(y, &vo, f)
if err != nil {
return fmt.Errorf("error converting YAML to JSON: %v", err)
}
err = jsonUnmarshal(bytes.NewReader(j), o, opts...)
if err != nil {
return fmt.Errorf("error unmarshaling JSON: %v", err)
}
return nil
}
// jsonUnmarshal unmarshals the JSON byte stream from the given reader into the
// object, optionally applying decoder options prior to decoding. We are not
// using json.Unmarshal directly as we want the chance to pass in non-default
// options.
func jsonUnmarshal(r io.Reader, o interface{}, opts ...JSONOpt) error {
d := json.NewDecoder(r)
for _, opt := range opts {
d = opt(d)
}
if err := d.Decode(&o); err != nil {
return fmt.Errorf("while decoding JSON: %v", err)
}
return nil
}
// Convert JSON to YAML.
func JSONToYAML(j []byte) ([]byte, error) {
// Convert the JSON to an object.
var jsonObj interface{}
// We are using yaml.Unmarshal here (instead of json.Unmarshal) because the
// Go JSON library doesn't try to pick the right number type (int, float,
// etc.) when unmarshalling to interface{}, it just picks float64
// universally. go-yaml does go through the effort of picking the right
// number type, so we can preserve number type throughout this process.
err := yaml.Unmarshal(j, &jsonObj)
if err != nil {
return nil, err
}
// Marshal this object into YAML.
return yaml.Marshal(jsonObj)
}
// YAMLToJSON converts YAML to JSON. Since JSON is a subset of YAML,
// passing JSON through this method should be a no-op.
//
// Things YAML can do that are not supported by JSON:
// * In YAML you can have binary and null keys in your maps. These are invalid
// in JSON. (int and float keys are converted to strings.)
// * Binary data in YAML with the !!binary tag is not supported. If you want to
// use binary data with this library, encode the data as base64 as usual but do
// not use the !!binary tag in your YAML. This will ensure the original base64
// encoded data makes it all the way through to the JSON.
//
// For strict decoding of YAML, use YAMLToJSONStrict.
func YAMLToJSON(y []byte) ([]byte, error) {
return yamlToJSON(y, nil, yaml.Unmarshal)
}
// YAMLToJSONStrict is like YAMLToJSON but enables strict YAML decoding,
// returning an error on any duplicate field names.
func YAMLToJSONStrict(y []byte) ([]byte, error) {
return yamlToJSON(y, nil, yaml.UnmarshalStrict)
}
func yamlToJSON(y []byte, jsonTarget *reflect.Value, yamlUnmarshal func([]byte, interface{}) error) ([]byte, error) {
// Convert the YAML to an object.
var yamlObj interface{}
err := yamlUnmarshal(y, &yamlObj)
if err != nil {
return nil, err
}
// YAML objects are not completely compatible with JSON objects (e.g. you
// can have non-string keys in YAML). So, convert the YAML-compatible object
// to a JSON-compatible object, failing with an error if irrecoverable
// incompatibilities happen along the way.
jsonObj, err := convertToJSONableObject(yamlObj, jsonTarget)
if err != nil {
return nil, err
}
// Convert this object to JSON and return the data.
return json.Marshal(jsonObj)
}
func convertToJSONableObject(yamlObj interface{}, jsonTarget *reflect.Value) (interface{}, error) {
var err error
// Resolve jsonTarget to a concrete value (i.e. not a pointer or an
// interface). We pass decodingNull as false because we're not actually
// decoding into the value, we're just checking if the ultimate target is a
// string.
if jsonTarget != nil {
ju, tu, pv := indirect(*jsonTarget, false)
// We have a JSON or Text Umarshaler at this level, so we can't be trying
// to decode into a string.
if ju != nil || tu != nil {
jsonTarget = nil
} else {
jsonTarget = &pv
}
}
// If yamlObj is a number or a boolean, check if jsonTarget is a string -
// if so, coerce. Else return normal.
// If yamlObj is a map or array, find the field that each key is
// unmarshaling to, and when you recurse pass the reflect.Value for that
// field back into this function.
switch typedYAMLObj := yamlObj.(type) {
case map[interface{}]interface{}:
// JSON does not support arbitrary keys in a map, so we must convert
// these keys to strings.
//
// From my reading of go-yaml v2 (specifically the resolve function),
// keys can only have the types string, int, int64, float64, binary
// (unsupported), or null (unsupported).
strMap := make(map[string]interface{})
for k, v := range typedYAMLObj {
// Resolve the key to a string first.
var keyString string
switch typedKey := k.(type) {
case string:
keyString = typedKey
case int:
keyString = strconv.Itoa(typedKey)
case int64:
// go-yaml will only return an int64 as a key if the system
// architecture is 32-bit and the key's value is between 32-bit
// and 64-bit. Otherwise the key type will simply be int.
keyString = strconv.FormatInt(typedKey, 10)
case float64:
// Stolen from go-yaml to use the same conversion to string as
// the go-yaml library uses to convert float to string when
// Marshaling.
s := strconv.FormatFloat(typedKey, 'g', -1, 32)
switch s {
case "+Inf":
s = ".inf"
case "-Inf":
s = "-.inf"
case "NaN":
s = ".nan"
}
keyString = s
case bool:
if typedKey {
keyString = "true"
} else {
keyString = "false"
}
default:
return nil, fmt.Errorf("Unsupported map key of type: %s, key: %+#v, value: %+#v",
reflect.TypeOf(k), k, v)
}
// jsonTarget should be a struct or a map. If it's a struct, find
// the field it's going to map to and pass its reflect.Value. If
// it's a map, find the element type of the map and pass the
// reflect.Value created from that type. If it's neither, just pass
// nil - JSON conversion will error for us if it's a real issue.
if jsonTarget != nil {
t := *jsonTarget
if t.Kind() == reflect.Struct {
keyBytes := []byte(keyString)
// Find the field that the JSON library would use.
var f *field
fields := cachedTypeFields(t.Type())
for i := range fields {
ff := &fields[i]
if bytes.Equal(ff.nameBytes, keyBytes) {
f = ff
break
}
// Do case-insensitive comparison.
if f == nil && ff.equalFold(ff.nameBytes, keyBytes) {
f = ff
}
}
if f != nil {
// Find the reflect.Value of the most preferential
// struct field.
jtf := t.Field(f.index[0])
strMap[keyString], err = convertToJSONableObject(v, &jtf)
if err != nil {
return nil, err
}
continue
}
} else if t.Kind() == reflect.Map {
// Create a zero value of the map's element type to use as
// the JSON target.
jtv := reflect.Zero(t.Type().Elem())
strMap[keyString], err = convertToJSONableObject(v, &jtv)
if err != nil {
return nil, err
}
continue
}
}
strMap[keyString], err = convertToJSONableObject(v, nil)
if err != nil {
return nil, err
}
}
return strMap, nil
case []interface{}:
// We need to recurse into arrays in case there are any
// map[interface{}]interface{}'s inside and to convert any
// numbers to strings.
// If jsonTarget is a slice (which it really should be), find the
// thing it's going to map to. If it's not a slice, just pass nil
// - JSON conversion will error for us if it's a real issue.
var jsonSliceElemValue *reflect.Value
if jsonTarget != nil {
t := *jsonTarget
if t.Kind() == reflect.Slice {
// By default slices point to nil, but we need a reflect.Value
// pointing to a value of the slice type, so we create one here.
ev := reflect.Indirect(reflect.New(t.Type().Elem()))
jsonSliceElemValue = &ev
}
}
// Make and use a new array.
arr := make([]interface{}, len(typedYAMLObj))
for i, v := range typedYAMLObj {
arr[i], err = convertToJSONableObject(v, jsonSliceElemValue)
if err != nil {
return nil, err
}
}
return arr, nil
default:
// If the target type is a string and the YAML type is a number,
// convert the YAML type to a string.
if jsonTarget != nil && (*jsonTarget).Kind() == reflect.String {
// Based on my reading of go-yaml, it may return int, int64,
// float64, or uint64.
var s string
switch typedVal := typedYAMLObj.(type) {
case int:
s = strconv.FormatInt(int64(typedVal), 10)
case int64:
s = strconv.FormatInt(typedVal, 10)
case float64:
s = strconv.FormatFloat(typedVal, 'g', -1, 32)
case uint64:
s = strconv.FormatUint(typedVal, 10)
case bool:
if typedVal {
s = "true"
} else {
s = "false"
}
}
if len(s) > 0 {
yamlObj = interface{}(s)
}
}
return yamlObj, nil
}
return nil, nil
}

14
vendor/github.com/ghodss/yaml/yaml_go110.go generated vendored Normal file
View File

@ -0,0 +1,14 @@
// This file contains changes that are only compatible with go 1.10 and onwards.
// +build go1.10
package yaml
import "encoding/json"
// DisallowUnknownFields configures the JSON decoder to error out if unknown
// fields come along, instead of dropping them by default.
func DisallowUnknownFields(d *json.Decoder) *json.Decoder {
d.DisallowUnknownFields()
return d
}

1271
vendor/github.com/golang/protobuf/jsonpb/jsonpb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1
vendor/github.com/golang/protobuf/proto/decode.go generated vendored
View File

@ -186,7 +186,6 @@ func (p *Buffer) DecodeVarint() (x uint64, err error) {
if b&0x80 == 0 {
goto done
}
// x -= 0x80 << 63 // Always zero.
return 0, errOverflow

63
vendor/github.com/golang/protobuf/proto/deprecated.go generated vendored Normal file
View File

@ -0,0 +1,63 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2018 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
package proto
import "errors"
// Deprecated: do not use.
type Stats struct{ Emalloc, Dmalloc, Encode, Decode, Chit, Cmiss, Size uint64 }
// Deprecated: do not use.
func GetStats() Stats { return Stats{} }
// Deprecated: do not use.
func MarshalMessageSet(interface{}) ([]byte, error) {
return nil, errors.New("proto: not implemented")
}
// Deprecated: do not use.
func UnmarshalMessageSet([]byte, interface{}) error {
return errors.New("proto: not implemented")
}
// Deprecated: do not use.
func MarshalMessageSetJSON(interface{}) ([]byte, error) {
return nil, errors.New("proto: not implemented")
}
// Deprecated: do not use.
func UnmarshalMessageSetJSON([]byte, interface{}) error {
return errors.New("proto: not implemented")
}
// Deprecated: do not use.
func RegisterMessageSetType(Message, int32, string) {}

3
vendor/github.com/golang/protobuf/proto/equal.go generated vendored
View File

@ -246,7 +246,8 @@ func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
return false
}
m1, m2 := e1.value, e2.value
m1 := extensionAsLegacyType(e1.value)
m2 := extensionAsLegacyType(e2.value)
if m1 == nil && m2 == nil {
// Both have only encoded form.

78
vendor/github.com/golang/protobuf/proto/extensions.go generated vendored
View File

@ -185,9 +185,25 @@ type Extension struct {
// extension will have only enc set. When such an extension is
// accessed using GetExtension (or GetExtensions) desc and value
// will be set.
desc *ExtensionDesc
desc *ExtensionDesc
// value is a concrete value for the extension field. Let the type of
// desc.ExtensionType be the "API type" and the type of Extension.value
// be the "storage type". The API type and storage type are the same except:
// * For scalars (except []byte), the API type uses *T,
// while the storage type uses T.
// * For repeated fields, the API type uses []T, while the storage type
// uses *[]T.
//
// The reason for the divergence is so that the storage type more naturally
// matches what is expected of when retrieving the values through the
// protobuf reflection APIs.
//
// The value may only be populated if desc is also populated.
value interface{}
enc []byte
// enc is the raw bytes for the extension field.
enc []byte
}
// SetRawExtension is for testing only.
@ -334,7 +350,7 @@ func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
// descriptors with the same field number.
return nil, errors.New("proto: descriptor conflict")
}
return e.value, nil
return extensionAsLegacyType(e.value), nil
}
if extension.ExtensionType == nil {
@ -349,11 +365,11 @@ func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
// Remember the decoded version and drop the encoded version.
// That way it is safe to mutate what we return.
e.value = v
e.value = extensionAsStorageType(v)
e.desc = extension
e.enc = nil
emap[extension.Field] = e
return e.value, nil
return extensionAsLegacyType(e.value), nil
}
// defaultExtensionValue returns the default value for extension.
@ -488,7 +504,7 @@ func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error
}
typ := reflect.TypeOf(extension.ExtensionType)
if typ != reflect.TypeOf(value) {
return errors.New("proto: bad extension value type")
return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", value, extension.ExtensionType)
}
// nil extension values need to be caught early, because the
// encoder can't distinguish an ErrNil due to a nil extension
@ -500,7 +516,7 @@ func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error
}
extmap := epb.extensionsWrite()
extmap[extension.Field] = Extension{desc: extension, value: value}
extmap[extension.Field] = Extension{desc: extension, value: extensionAsStorageType(value)}
return nil
}
@ -541,3 +557,51 @@ func RegisterExtension(desc *ExtensionDesc) {
func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
return extensionMaps[reflect.TypeOf(pb).Elem()]
}
// extensionAsLegacyType converts an value in the storage type as the API type.
// See Extension.value.
func extensionAsLegacyType(v interface{}) interface{} {
switch rv := reflect.ValueOf(v); rv.Kind() {
case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
// Represent primitive types as a pointer to the value.
rv2 := reflect.New(rv.Type())
rv2.Elem().Set(rv)
v = rv2.Interface()
case reflect.Ptr:
// Represent slice types as the value itself.
switch rv.Type().Elem().Kind() {
case reflect.Slice:
if rv.IsNil() {
v = reflect.Zero(rv.Type().Elem()).Interface()
} else {
v = rv.Elem().Interface()
}
}
}
return v
}
// extensionAsStorageType converts an value in the API type as the storage type.
// See Extension.value.
func extensionAsStorageType(v interface{}) interface{} {
switch rv := reflect.ValueOf(v); rv.Kind() {
case reflect.Ptr:
// Represent slice types as the value itself.
switch rv.Type().Elem().Kind() {
case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
if rv.IsNil() {
v = reflect.Zero(rv.Type().Elem()).Interface()
} else {
v = rv.Elem().Interface()
}
}
case reflect.Slice:
// Represent slice types as a pointer to the value.
if rv.Type().Elem().Kind() != reflect.Uint8 {
rv2 := reflect.New(rv.Type())
rv2.Elem().Set(rv)
v = rv2.Interface()
}
}
return v
}

38
vendor/github.com/golang/protobuf/proto/lib.go generated vendored
View File

@ -341,26 +341,6 @@ type Message interface {
ProtoMessage()
}
// Stats records allocation details about the protocol buffer encoders
// and decoders. Useful for tuning the library itself.
type Stats struct {
Emalloc uint64 // mallocs in encode
Dmalloc uint64 // mallocs in decode
Encode uint64 // number of encodes
Decode uint64 // number of decodes
Chit uint64 // number of cache hits
Cmiss uint64 // number of cache misses
Size uint64 // number of sizes
}
// Set to true to enable stats collection.
const collectStats = false
var stats Stats
// GetStats returns a copy of the global Stats structure.
func GetStats() Stats { return stats }
// A Buffer is a buffer manager for marshaling and unmarshaling
// protocol buffers. It may be reused between invocations to
// reduce memory usage. It is not necessary to use a Buffer;
@ -960,13 +940,19 @@ func isProto3Zero(v reflect.Value) bool {
return false
}
// ProtoPackageIsVersion2 is referenced from generated protocol buffer files
// to assert that that code is compatible with this version of the proto package.
const ProtoPackageIsVersion2 = true
const (
// ProtoPackageIsVersion3 is referenced from generated protocol buffer files
// to assert that that code is compatible with this version of the proto package.
ProtoPackageIsVersion3 = true
// ProtoPackageIsVersion1 is referenced from generated protocol buffer files
// to assert that that code is compatible with this version of the proto package.
const ProtoPackageIsVersion1 = true
// ProtoPackageIsVersion2 is referenced from generated protocol buffer files
// to assert that that code is compatible with this version of the proto package.
ProtoPackageIsVersion2 = true
// ProtoPackageIsVersion1 is referenced from generated protocol buffer files
// to assert that that code is compatible with this version of the proto package.
ProtoPackageIsVersion1 = true
)
// InternalMessageInfo is a type used internally by generated .pb.go files.
// This type is not intended to be used by non-generated code.

137
vendor/github.com/golang/protobuf/proto/message_set.go generated vendored
View File

@ -36,13 +36,7 @@ package proto
*/
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"reflect"
"sort"
"sync"
)
// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.
@ -145,46 +139,9 @@ func skipVarint(buf []byte) []byte {
return buf[i+1:]
}
// MarshalMessageSet encodes the extension map represented by m in the message set wire format.
// It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option.
func MarshalMessageSet(exts interface{}) ([]byte, error) {
return marshalMessageSet(exts, false)
}
// marshaMessageSet implements above function, with the opt to turn on / off deterministic during Marshal.
func marshalMessageSet(exts interface{}, deterministic bool) ([]byte, error) {
switch exts := exts.(type) {
case *XXX_InternalExtensions:
var u marshalInfo
siz := u.sizeMessageSet(exts)
b := make([]byte, 0, siz)
return u.appendMessageSet(b, exts, deterministic)
case map[int32]Extension:
// This is an old-style extension map.
// Wrap it in a new-style XXX_InternalExtensions.
ie := XXX_InternalExtensions{
p: &struct {
mu sync.Mutex
extensionMap map[int32]Extension
}{
extensionMap: exts,
},
}
var u marshalInfo
siz := u.sizeMessageSet(&ie)
b := make([]byte, 0, siz)
return u.appendMessageSet(b, &ie, deterministic)
default:
return nil, errors.New("proto: not an extension map")
}
}
// UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
// unmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
// It is called by Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
func UnmarshalMessageSet(buf []byte, exts interface{}) error {
func unmarshalMessageSet(buf []byte, exts interface{}) error {
var m map[int32]Extension
switch exts := exts.(type) {
case *XXX_InternalExtensions:
@ -222,93 +179,3 @@ func UnmarshalMessageSet(buf []byte, exts interface{}) error {
}
return nil
}
// MarshalMessageSetJSON encodes the extension map represented by m in JSON format.
// It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
func MarshalMessageSetJSON(exts interface{}) ([]byte, error) {
var m map[int32]Extension
switch exts := exts.(type) {
case *XXX_InternalExtensions:
var mu sync.Locker
m, mu = exts.extensionsRead()
if m != nil {
// Keep the extensions map locked until we're done marshaling to prevent
// races between marshaling and unmarshaling the lazily-{en,de}coded
// values.
mu.Lock()
defer mu.Unlock()
}
case map[int32]Extension:
m = exts
default:
return nil, errors.New("proto: not an extension map")
}
var b bytes.Buffer
b.WriteByte('{')
// Process the map in key order for deterministic output.
ids := make([]int32, 0, len(m))
for id := range m {
ids = append(ids, id)
}
sort.Sort(int32Slice(ids)) // int32Slice defined in text.go
for i, id := range ids {
ext := m[id]
msd, ok := messageSetMap[id]
if !ok {
// Unknown type; we can't render it, so skip it.
continue
}
if i > 0 && b.Len() > 1 {
b.WriteByte(',')
}
fmt.Fprintf(&b, `"[%s]":`, msd.name)
x := ext.value
if x == nil {
x = reflect.New(msd.t.Elem()).Interface()
if err := Unmarshal(ext.enc, x.(Message)); err != nil {
return nil, err
}
}
d, err := json.Marshal(x)
if err != nil {
return nil, err
}
b.Write(d)
}
b.WriteByte('}')
return b.Bytes(), nil
}
// UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format.
// It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
func UnmarshalMessageSetJSON(buf []byte, exts interface{}) error {
// Common-case fast path.
if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) {
return nil
}
// This is fairly tricky, and it's not clear that it is needed.
return errors.New("TODO: UnmarshalMessageSetJSON not yet implemented")
}
// A global registry of types that can be used in a MessageSet.
var messageSetMap = make(map[int32]messageSetDesc)
type messageSetDesc struct {
t reflect.Type // pointer to struct
name string
}
// RegisterMessageSetType is called from the generated code.
func RegisterMessageSetType(m Message, fieldNum int32, name string) {
messageSetMap[fieldNum] = messageSetDesc{
t: reflect.TypeOf(m),
name: name,
}
}

5
vendor/github.com/golang/protobuf/proto/pointer_reflect.go generated vendored
View File

@ -79,10 +79,13 @@ func toPointer(i *Message) pointer {
// toAddrPointer converts an interface to a pointer that points to
// the interface data.
func toAddrPointer(i *interface{}, isptr bool) pointer {
func toAddrPointer(i *interface{}, isptr, deref bool) pointer {
v := reflect.ValueOf(*i)
u := reflect.New(v.Type())
u.Elem().Set(v)
if deref {
u = u.Elem()
}
return pointer{v: u}
}

15
vendor/github.com/golang/protobuf/proto/pointer_unsafe.go generated vendored
View File

@ -85,16 +85,21 @@ func toPointer(i *Message) pointer {
// toAddrPointer converts an interface to a pointer that points to
// the interface data.
func toAddrPointer(i *interface{}, isptr bool) pointer {
func toAddrPointer(i *interface{}, isptr, deref bool) (p pointer) {
// Super-tricky - read or get the address of data word of interface value.
if isptr {
// The interface is of pointer type, thus it is a direct interface.
// The data word is the pointer data itself. We take its address.
return pointer{p: unsafe.Pointer(uintptr(unsafe.Pointer(i)) + ptrSize)}
p = pointer{p: unsafe.Pointer(uintptr(unsafe.Pointer(i)) + ptrSize)}
} else {
// The interface is not of pointer type. The data word is the pointer
// to the data.
p = pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
}
// The interface is not of pointer type. The data word is the pointer
// to the data.
return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
if deref {
p.p = *(*unsafe.Pointer)(p.p)
}
return p
}
// valToPointer converts v to a pointer. v must be of pointer type.

31
vendor/github.com/golang/protobuf/proto/properties.go generated vendored
View File

@ -334,9 +334,6 @@ func GetProperties(t reflect.Type) *StructProperties {
sprop, ok := propertiesMap[t]
propertiesMu.RUnlock()
if ok {
if collectStats {
stats.Chit++
}
return sprop
}
@ -346,17 +343,20 @@ func GetProperties(t reflect.Type) *StructProperties {
return sprop
}
type (
oneofFuncsIface interface {
XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
}
oneofWrappersIface interface {
XXX_OneofWrappers() []interface{}
}
)
// getPropertiesLocked requires that propertiesMu is held.
func getPropertiesLocked(t reflect.Type) *StructProperties {
if prop, ok := propertiesMap[t]; ok {
if collectStats {
stats.Chit++
}
return prop
}
if collectStats {
stats.Cmiss++
}
prop := new(StructProperties)
// in case of recursive protos, fill this in now.
@ -391,13 +391,14 @@ func getPropertiesLocked(t reflect.Type) *StructProperties {
// Re-order prop.order.
sort.Sort(prop)
type oneofMessage interface {
XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
var oots []interface{}
switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
case oneofFuncsIface:
_, _, _, oots = m.XXX_OneofFuncs()
case oneofWrappersIface:
oots = m.XXX_OneofWrappers()
}
if om, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok {
var oots []interface{}
_, _, _, oots = om.XXX_OneofFuncs()
if len(oots) > 0 {
// Interpret oneof metadata.
prop.OneofTypes = make(map[string]*OneofProperties)
for _, oot := range oots {

45
vendor/github.com/golang/protobuf/proto/table_marshal.go generated vendored
View File

@ -87,6 +87,7 @@ type marshalElemInfo struct {
sizer sizer
marshaler marshaler
isptr bool // elem is pointer typed, thus interface of this type is a direct interface (extension only)
deref bool // dereference the pointer before operating on it; implies isptr
}
var (
@ -320,8 +321,11 @@ func (u *marshalInfo) computeMarshalInfo() {
// get oneof implementers
var oneofImplementers []interface{}
if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok {
switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
case oneofFuncsIface:
_, _, _, oneofImplementers = m.XXX_OneofFuncs()
case oneofWrappersIface:
oneofImplementers = m.XXX_OneofWrappers()
}
n := t.NumField()
@ -407,13 +411,22 @@ func (u *marshalInfo) getExtElemInfo(desc *ExtensionDesc) *marshalElemInfo {
panic("tag is not an integer")
}
wt := wiretype(tags[0])
if t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct {
t = t.Elem()
}
sizer, marshaler := typeMarshaler(t, tags, false, false)
var deref bool
if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
t = reflect.PtrTo(t)
deref = true
}
e = &marshalElemInfo{
wiretag: uint64(tag)<<3 | wt,
tagsize: SizeVarint(uint64(tag) << 3),
sizer: sizer,
marshaler: marshaler,
isptr: t.Kind() == reflect.Ptr,
deref: deref,
}
// update cache
@ -448,7 +461,7 @@ func (fi *marshalFieldInfo) computeMarshalFieldInfo(f *reflect.StructField) {
func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofImplementers []interface{}) {
fi.field = toField(f)
fi.wiretag = 1<<31 - 1 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire.
fi.wiretag = math.MaxInt32 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire.
fi.isPointer = true
fi.sizer, fi.marshaler = makeOneOfMarshaler(fi, f)
fi.oneofElems = make(map[reflect.Type]*marshalElemInfo)
@ -476,10 +489,6 @@ func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofI
}
}
type oneofMessage interface {
XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
}
// wiretype returns the wire encoding of the type.
func wiretype(encoding string) uint64 {
switch encoding {
@ -2310,8 +2319,8 @@ func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {
for _, k := range m.MapKeys() {
ki := k.Interface()
vi := m.MapIndex(k).Interface()
kaddr := toAddrPointer(&ki, false) // pointer to key
vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value
kaddr := toAddrPointer(&ki, false, false) // pointer to key
vaddr := toAddrPointer(&vi, valIsPtr, false) // pointer to value
siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
n += siz + SizeVarint(uint64(siz)) + tagsize
}
@ -2329,8 +2338,8 @@ func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {
for _, k := range keys {
ki := k.Interface()
vi := m.MapIndex(k).Interface()
kaddr := toAddrPointer(&ki, false) // pointer to key
vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value
kaddr := toAddrPointer(&ki, false, false) // pointer to key
vaddr := toAddrPointer(&vi, valIsPtr, false) // pointer to value
b = appendVarint(b, tag)
siz := keySizer(kaddr, 1) + valCachedSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
b = appendVarint(b, uint64(siz))
@ -2399,7 +2408,7 @@ func (u *marshalInfo) sizeExtensions(ext *XXX_InternalExtensions) int {
// the last time this function was called.
ei := u.getExtElemInfo(e.desc)
v := e.value
p := toAddrPointer(&v, ei.isptr)
p := toAddrPointer(&v, ei.isptr, ei.deref)
n += ei.sizer(p, ei.tagsize)
}
mu.Unlock()
@ -2434,7 +2443,7 @@ func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, de
ei := u.getExtElemInfo(e.desc)
v := e.value
p := toAddrPointer(&v, ei.isptr)
p := toAddrPointer(&v, ei.isptr, ei.deref)
b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
if !nerr.Merge(err) {
return b, err
@ -2465,7 +2474,7 @@ func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, de
ei := u.getExtElemInfo(e.desc)
v := e.value
p := toAddrPointer(&v, ei.isptr)
p := toAddrPointer(&v, ei.isptr, ei.deref)
b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
if !nerr.Merge(err) {
return b, err
@ -2510,7 +2519,7 @@ func (u *marshalInfo) sizeMessageSet(ext *XXX_InternalExtensions) int {
ei := u.getExtElemInfo(e.desc)
v := e.value
p := toAddrPointer(&v, ei.isptr)
p := toAddrPointer(&v, ei.isptr, ei.deref)
n += ei.sizer(p, 1) // message, tag = 3 (size=1)
}
mu.Unlock()
@ -2553,7 +2562,7 @@ func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, de
ei := u.getExtElemInfo(e.desc)
v := e.value
p := toAddrPointer(&v, ei.isptr)
p := toAddrPointer(&v, ei.isptr, ei.deref)
b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
if !nerr.Merge(err) {
return b, err
@ -2591,7 +2600,7 @@ func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, de
ei := u.getExtElemInfo(e.desc)
v := e.value
p := toAddrPointer(&v, ei.isptr)
p := toAddrPointer(&v, ei.isptr, ei.deref)
b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
b = append(b, 1<<3|WireEndGroup)
if !nerr.Merge(err) {
@ -2621,7 +2630,7 @@ func (u *marshalInfo) sizeV1Extensions(m map[int32]Extension) int {
ei := u.getExtElemInfo(e.desc)
v := e.value
p := toAddrPointer(&v, ei.isptr)
p := toAddrPointer(&v, ei.isptr, ei.deref)
n += ei.sizer(p, ei.tagsize)
}
return n
@ -2656,7 +2665,7 @@ func (u *marshalInfo) appendV1Extensions(b []byte, m map[int32]Extension, determ
ei := u.getExtElemInfo(e.desc)
v := e.value
p := toAddrPointer(&v, ei.isptr)
p := toAddrPointer(&v, ei.isptr, ei.deref)
b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
if !nerr.Merge(err) {
return b, err

74
vendor/github.com/golang/protobuf/proto/table_unmarshal.go generated vendored
View File

@ -136,7 +136,7 @@ func (u *unmarshalInfo) unmarshal(m pointer, b []byte) error {
u.computeUnmarshalInfo()
}
if u.isMessageSet {
return UnmarshalMessageSet(b, m.offset(u.extensions).toExtensions())
return unmarshalMessageSet(b, m.offset(u.extensions).toExtensions())
}
var reqMask uint64 // bitmask of required fields we've seen.
var errLater error
@ -362,46 +362,48 @@ func (u *unmarshalInfo) computeUnmarshalInfo() {
}
// Find any types associated with oneof fields.
// TODO: XXX_OneofFuncs returns more info than we need. Get rid of some of it?
fn := reflect.Zero(reflect.PtrTo(t)).MethodByName("XXX_OneofFuncs")
if fn.IsValid() {
res := fn.Call(nil)[3] // last return value from XXX_OneofFuncs: []interface{}
for i := res.Len() - 1; i >= 0; i-- {
v := res.Index(i) // interface{}
tptr := reflect.ValueOf(v.Interface()).Type() // *Msg_X
typ := tptr.Elem() // Msg_X
var oneofImplementers []interface{}
switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
case oneofFuncsIface:
_, _, _, oneofImplementers = m.XXX_OneofFuncs()
case oneofWrappersIface:
oneofImplementers = m.XXX_OneofWrappers()
}
for _, v := range oneofImplementers {
tptr := reflect.TypeOf(v) // *Msg_X
typ := tptr.Elem() // Msg_X
f := typ.Field(0) // oneof implementers have one field
baseUnmarshal := fieldUnmarshaler(&f)
tags := strings.Split(f.Tag.Get("protobuf"), ",")
fieldNum, err := strconv.Atoi(tags[1])
if err != nil {
panic("protobuf tag field not an integer: " + tags[1])
}
var name string
for _, tag := range tags {
if strings.HasPrefix(tag, "name=") {
name = strings.TrimPrefix(tag, "name=")
break
}
}
// Find the oneof field that this struct implements.
// Might take O(n^2) to process all of the oneofs, but who cares.
for _, of := range oneofFields {
if tptr.Implements(of.ityp) {
// We have found the corresponding interface for this struct.
// That lets us know where this struct should be stored
// when we encounter it during unmarshaling.
unmarshal := makeUnmarshalOneof(typ, of.ityp, baseUnmarshal)
u.setTag(fieldNum, of.field, unmarshal, 0, name)
}
f := typ.Field(0) // oneof implementers have one field
baseUnmarshal := fieldUnmarshaler(&f)
tags := strings.Split(f.Tag.Get("protobuf"), ",")
fieldNum, err := strconv.Atoi(tags[1])
if err != nil {
panic("protobuf tag field not an integer: " + tags[1])
}
var name string
for _, tag := range tags {
if strings.HasPrefix(tag, "name=") {
name = strings.TrimPrefix(tag, "name=")
break
}
}
// Find the oneof field that this struct implements.
// Might take O(n^2) to process all of the oneofs, but who cares.
for _, of := range oneofFields {
if tptr.Implements(of.ityp) {
// We have found the corresponding interface for this struct.
// That lets us know where this struct should be stored
// when we encounter it during unmarshaling.
unmarshal := makeUnmarshalOneof(typ, of.ityp, baseUnmarshal)
u.setTag(fieldNum, of.field, unmarshal, 0, name)
}
}
}
// Get extension ranges, if any.
fn = reflect.Zero(reflect.PtrTo(t)).MethodByName("ExtensionRangeArray")
fn := reflect.Zero(reflect.PtrTo(t)).MethodByName("ExtensionRangeArray")
if fn.IsValid() {
if !u.extensions.IsValid() && !u.oldExtensions.IsValid() {
panic("a message with extensions, but no extensions field in " + t.Name())
@ -1948,7 +1950,7 @@ func encodeVarint(b []byte, x uint64) []byte {
// If there is an error, it returns 0,0.
func decodeVarint(b []byte) (uint64, int) {
var x, y uint64
if len(b) <= 0 {
if len(b) == 0 {
goto bad
}
x = uint64(b[0])

83
vendor/github.com/golang/protobuf/ptypes/empty/empty.pb.go generated vendored Normal file
View File

@ -0,0 +1,83 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/protobuf/empty.proto
package empty
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
// A generic empty message that you can re-use to avoid defining duplicated
// empty messages in your APIs. A typical example is to use it as the request
// or the response type of an API method. For instance:
//
// service Foo {
// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
// }
//
// The JSON representation for `Empty` is empty JSON object `{}`.
type Empty struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Empty) Reset() { *m = Empty{} }
func (m *Empty) String() string { return proto.CompactTextString(m) }
func (*Empty) ProtoMessage() {}
func (*Empty) Descriptor() ([]byte, []int) {
return fileDescriptor_900544acb223d5b8, []int{0}
}
func (*Empty) XXX_WellKnownType() string { return "Empty" }
func (m *Empty) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Empty.Unmarshal(m, b)
}
func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
}
func (m *Empty) XXX_Merge(src proto.Message) {
xxx_messageInfo_Empty.Merge(m, src)
}
func (m *Empty) XXX_Size() int {
return xxx_messageInfo_Empty.Size(m)
}
func (m *Empty) XXX_DiscardUnknown() {
xxx_messageInfo_Empty.DiscardUnknown(m)
}
var xxx_messageInfo_Empty proto.InternalMessageInfo
func init() {
proto.RegisterType((*Empty)(nil), "google.protobuf.Empty")
}
func init() { proto.RegisterFile("google/protobuf/empty.proto", fileDescriptor_900544acb223d5b8) }
var fileDescriptor_900544acb223d5b8 = []byte{
// 148 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcd, 0x2d, 0x28,
0xa9, 0xd4, 0x03, 0x73, 0x85, 0xf8, 0x21, 0x92, 0x7a, 0x30, 0x49, 0x25, 0x76, 0x2e, 0x56, 0x57,
0x90, 0xbc, 0x53, 0x19, 0x97, 0x70, 0x72, 0x7e, 0xae, 0x1e, 0x9a, 0xbc, 0x13, 0x17, 0x58, 0x36,
0x00, 0xc4, 0x0d, 0x60, 0x8c, 0x52, 0x4f, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf,
0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0x47, 0x58, 0x53, 0x50, 0x52, 0x59, 0x90, 0x5a, 0x0c,
0xb1, 0xed, 0x07, 0x23, 0xe3, 0x22, 0x26, 0x66, 0xf7, 0x00, 0xa7, 0x55, 0x4c, 0x72, 0xee, 0x10,
0x13, 0x03, 0xa0, 0xea, 0xf4, 0xc2, 0x53, 0x73, 0x72, 0xbc, 0xf3, 0xf2, 0xcb, 0xf3, 0x42, 0x40,
0xea, 0x93, 0xd8, 0xc0, 0x06, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x64, 0xd4, 0xb3, 0xa6,
0xb7, 0x00, 0x00, 0x00,
}

52
vendor/github.com/golang/protobuf/ptypes/empty/empty.proto generated vendored Normal file
View File

@ -0,0 +1,52 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
syntax = "proto3";
package google.protobuf;
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
option go_package = "github.com/golang/protobuf/ptypes/empty";
option java_package = "com.google.protobuf";
option java_outer_classname = "EmptyProto";
option java_multiple_files = true;
option objc_class_prefix = "GPB";
option cc_enable_arenas = true;
// A generic empty message that you can re-use to avoid defining duplicated
// empty messages in your APIs. A typical example is to use it as the request
// or the response type of an API method. For instance:
//
// service Foo {
// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
// }
//
// The JSON representation for `Empty` is empty JSON object `{}`.
message Empty {}

336
vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go generated vendored Normal file
View File

@ -0,0 +1,336 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/protobuf/struct.proto
package structpb
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
// `NullValue` is a singleton enumeration to represent the null value for the
// `Value` type union.
//
// The JSON representation for `NullValue` is JSON `null`.
type NullValue int32
const (
// Null value.
NullValue_NULL_VALUE NullValue = 0
)
var NullValue_name = map[int32]string{
0: "NULL_VALUE",
}
var NullValue_value = map[string]int32{
"NULL_VALUE": 0,
}
func (x NullValue) String() string {
return proto.EnumName(NullValue_name, int32(x))
}
func (NullValue) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_df322afd6c9fb402, []int{0}
}
func (NullValue) XXX_WellKnownType() string { return "NullValue" }
// `Struct` represents a structured data value, consisting of fields
// which map to dynamically typed values. In some languages, `Struct`
// might be supported by a native representation. For example, in
// scripting languages like JS a struct is represented as an
// object. The details of that representation are described together
// with the proto support for the language.
//
// The JSON representation for `Struct` is JSON object.
type Struct struct {
// Unordered map of dynamically typed values.
Fields map[string]*Value `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Struct) Reset() { *m = Struct{} }
func (m *Struct) String() string { return proto.CompactTextString(m) }
func (*Struct) ProtoMessage() {}
func (*Struct) Descriptor() ([]byte, []int) {
return fileDescriptor_df322afd6c9fb402, []int{0}
}
func (*Struct) XXX_WellKnownType() string { return "Struct" }
func (m *Struct) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Struct.Unmarshal(m, b)
}
func (m *Struct) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Struct.Marshal(b, m, deterministic)
}
func (m *Struct) XXX_Merge(src proto.Message) {
xxx_messageInfo_Struct.Merge(m, src)
}
func (m *Struct) XXX_Size() int {
return xxx_messageInfo_Struct.Size(m)
}
func (m *Struct) XXX_DiscardUnknown() {
xxx_messageInfo_Struct.DiscardUnknown(m)
}
var xxx_messageInfo_Struct proto.InternalMessageInfo
func (m *Struct) GetFields() map[string]*Value {
if m != nil {
return m.Fields
}
return nil
}
// `Value` represents a dynamically typed value which can be either
// null, a number, a string, a boolean, a recursive struct value, or a
// list of values. A producer of value is expected to set one of that
// variants, absence of any variant indicates an error.
//
// The JSON representation for `Value` is JSON value.
type Value struct {
// The kind of value.
//
// Types that are valid to be assigned to Kind:
// *Value_NullValue
// *Value_NumberValue
// *Value_StringValue
// *Value_BoolValue
// *Value_StructValue
// *Value_ListValue
Kind isValue_Kind `protobuf_oneof:"kind"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Value) Reset() { *m = Value{} }
func (m *Value) String() string { return proto.CompactTextString(m) }
func (*Value) ProtoMessage() {}
func (*Value) Descriptor() ([]byte, []int) {
return fileDescriptor_df322afd6c9fb402, []int{1}
}
func (*Value) XXX_WellKnownType() string { return "Value" }
func (m *Value) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Value.Unmarshal(m, b)
}
func (m *Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Value.Marshal(b, m, deterministic)
}
func (m *Value) XXX_Merge(src proto.Message) {
xxx_messageInfo_Value.Merge(m, src)
}
func (m *Value) XXX_Size() int {
return xxx_messageInfo_Value.Size(m)
}
func (m *Value) XXX_DiscardUnknown() {
xxx_messageInfo_Value.DiscardUnknown(m)
}
var xxx_messageInfo_Value proto.InternalMessageInfo
type isValue_Kind interface {
isValue_Kind()
}
type Value_NullValue struct {
NullValue NullValue `protobuf:"varint,1,opt,name=null_value,json=nullValue,proto3,enum=google.protobuf.NullValue,oneof"`
}
type Value_NumberValue struct {
NumberValue float64 `protobuf:"fixed64,2,opt,name=number_value,json=numberValue,proto3,oneof"`
}
type Value_StringValue struct {
StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,proto3,oneof"`
}
type Value_BoolValue struct {
BoolValue bool `protobuf:"varint,4,opt,name=bool_value,json=boolValue,proto3,oneof"`
}
type Value_StructValue struct {
StructValue *Struct `protobuf:"bytes,5,opt,name=struct_value,json=structValue,proto3,oneof"`
}
type Value_ListValue struct {
ListValue *ListValue `protobuf:"bytes,6,opt,name=list_value,json=listValue,proto3,oneof"`
}
func (*Value_NullValue) isValue_Kind() {}
func (*Value_NumberValue) isValue_Kind() {}
func (*Value_StringValue) isValue_Kind() {}
func (*Value_BoolValue) isValue_Kind() {}
func (*Value_StructValue) isValue_Kind() {}
func (*Value_ListValue) isValue_Kind() {}
func (m *Value) GetKind() isValue_Kind {
if m != nil {
return m.Kind
}
return nil
}
func (m *Value) GetNullValue() NullValue {
if x, ok := m.GetKind().(*Value_NullValue); ok {
return x.NullValue
}
return NullValue_NULL_VALUE
}
func (m *Value) GetNumberValue() float64 {
if x, ok := m.GetKind().(*Value_NumberValue); ok {
return x.NumberValue
}
return 0
}
func (m *Value) GetStringValue() string {
if x, ok := m.GetKind().(*Value_StringValue); ok {
return x.StringValue
}
return ""
}
func (m *Value) GetBoolValue() bool {
if x, ok := m.GetKind().(*Value_BoolValue); ok {
return x.BoolValue
}
return false
}
func (m *Value) GetStructValue() *Struct {
if x, ok := m.GetKind().(*Value_StructValue); ok {
return x.StructValue
}
return nil
}
func (m *Value) GetListValue() *ListValue {
if x, ok := m.GetKind().(*Value_ListValue); ok {
return x.ListValue
}
return nil
}
// XXX_OneofWrappers is for the internal use of the proto package.
func (*Value) XXX_OneofWrappers() []interface{} {
return []interface{}{
(*Value_NullValue)(nil),
(*Value_NumberValue)(nil),
(*Value_StringValue)(nil),
(*Value_BoolValue)(nil),
(*Value_StructValue)(nil),
(*Value_ListValue)(nil),
}
}
// `ListValue` is a wrapper around a repeated field of values.
//
// The JSON representation for `ListValue` is JSON array.
type ListValue struct {
// Repeated field of dynamically typed values.
Values []*Value `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListValue) Reset() { *m = ListValue{} }
func (m *ListValue) String() string { return proto.CompactTextString(m) }
func (*ListValue) ProtoMessage() {}
func (*ListValue) Descriptor() ([]byte, []int) {
return fileDescriptor_df322afd6c9fb402, []int{2}
}
func (*ListValue) XXX_WellKnownType() string { return "ListValue" }
func (m *ListValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListValue.Unmarshal(m, b)
}
func (m *ListValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListValue.Marshal(b, m, deterministic)
}
func (m *ListValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListValue.Merge(m, src)
}
func (m *ListValue) XXX_Size() int {
return xxx_messageInfo_ListValue.Size(m)
}
func (m *ListValue) XXX_DiscardUnknown() {
xxx_messageInfo_ListValue.DiscardUnknown(m)
}
var xxx_messageInfo_ListValue proto.InternalMessageInfo
func (m *ListValue) GetValues() []*Value {
if m != nil {
return m.Values
}
return nil
}
func init() {
proto.RegisterEnum("google.protobuf.NullValue", NullValue_name, NullValue_value)
proto.RegisterType((*Struct)(nil), "google.protobuf.Struct")
proto.RegisterMapType((map[string]*Value)(nil), "google.protobuf.Struct.FieldsEntry")
proto.RegisterType((*Value)(nil), "google.protobuf.Value")
proto.RegisterType((*ListValue)(nil), "google.protobuf.ListValue")
}
func init() { proto.RegisterFile("google/protobuf/struct.proto", fileDescriptor_df322afd6c9fb402) }
var fileDescriptor_df322afd6c9fb402 = []byte{
// 417 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0x41, 0x8b, 0xd3, 0x40,
0x14, 0xc7, 0x3b, 0xc9, 0x36, 0x98, 0x17, 0x59, 0x97, 0x11, 0xb4, 0xac, 0xa2, 0xa1, 0x7b, 0x09,
0x22, 0x29, 0xd6, 0x8b, 0x18, 0x2f, 0x06, 0xd6, 0x5d, 0x30, 0x2c, 0x31, 0xba, 0x15, 0xbc, 0x94,
0x26, 0x4d, 0x63, 0xe8, 0x74, 0x26, 0x24, 0x33, 0x4a, 0x8f, 0x7e, 0x0b, 0xcf, 0x1e, 0x3d, 0xfa,
0xe9, 0x3c, 0xca, 0xcc, 0x24, 0xa9, 0xb4, 0xf4, 0x94, 0xbc, 0xf7, 0x7e, 0xef, 0x3f, 0xef, 0xff,
0x66, 0xe0, 0x71, 0xc1, 0x58, 0x41, 0xf2, 0x49, 0x55, 0x33, 0xce, 0x52, 0xb1, 0x9a, 0x34, 0xbc,
0x16, 0x19, 0xf7, 0x55, 0x8c, 0xef, 0xe9, 0xaa, 0xdf, 0x55, 0xc7, 0x3f, 0x11, 0x58, 0x1f, 0x15,
0x81, 0x03, 0xb0, 0x56, 0x65, 0x4e, 0x96, 0xcd, 0x08, 0xb9, 0xa6, 0xe7, 0x4c, 0x2f, 0xfc, 0x3d,
0xd8, 0xd7, 0xa0, 0xff, 0x4e, 0x51, 0x97, 0x94, 0xd7, 0xdb, 0xa4, 0x6d, 0x39, 0xff, 0x00, 0xce,
0x7f, 0x69, 0x7c, 0x06, 0xe6, 0x3a, 0xdf, 0x8e, 0x90, 0x8b, 0x3c, 0x3b, 0x91, 0xbf, 0xf8, 0x39,
0x0c, 0xbf, 0x2d, 0x88, 0xc8, 0x47, 0x86, 0x8b, 0x3c, 0x67, 0xfa, 0xe0, 0x40, 0x7c, 0x26, 0xab,
0x89, 0x86, 0x5e, 0x1b, 0xaf, 0xd0, 0xf8, 0x8f, 0x01, 0x43, 0x95, 0xc4, 0x01, 0x00, 0x15, 0x84,
0xcc, 0xb5, 0x80, 0x14, 0x3d, 0x9d, 0x9e, 0x1f, 0x08, 0xdc, 0x08, 0x42, 0x14, 0x7f, 0x3d, 0x48,
0x6c, 0xda, 0x05, 0xf8, 0x02, 0xee, 0x52, 0xb1, 0x49, 0xf3, 0x7a, 0xbe, 0x3b, 0x1f, 0x5d, 0x0f,
0x12, 0x47, 0x67, 0x7b, 0xa8, 0xe1, 0x75, 0x49, 0x8b, 0x16, 0x32, 0xe5, 0xe0, 0x12, 0xd2, 0x59,
0x0d, 0x3d, 0x05, 0x48, 0x19, 0xeb, 0xc6, 0x38, 0x71, 0x91, 0x77, 0x47, 0x1e, 0x25, 0x73, 0x1a,
0x78, 0xa3, 0x54, 0x44, 0xc6, 0x5b, 0x64, 0xa8, 0xac, 0x3e, 0x3c, 0xb2, 0xc7, 0x56, 0x5e, 0x64,
0xbc, 0x77, 0x49, 0xca, 0xa6, 0xeb, 0xb5, 0x54, 0xef, 0xa1, 0xcb, 0xa8, 0x6c, 0x78, 0xef, 0x92,
0x74, 0x41, 0x68, 0xc1, 0xc9, 0xba, 0xa4, 0xcb, 0x71, 0x00, 0x76, 0x4f, 0x60, 0x1f, 0x2c, 0x25,
0xd6, 0xdd, 0xe8, 0xb1, 0xa5, 0xb7, 0xd4, 0xb3, 0x47, 0x60, 0xf7, 0x4b, 0xc4, 0xa7, 0x00, 0x37,
0xb7, 0x51, 0x34, 0x9f, 0xbd, 0x8d, 0x6e, 0x2f, 0xcf, 0x06, 0xe1, 0x0f, 0x04, 0xf7, 0x33, 0xb6,
0xd9, 0x97, 0x08, 0x1d, 0xed, 0x26, 0x96, 0x71, 0x8c, 0xbe, 0xbc, 0x28, 0x4a, 0xfe, 0x55, 0xa4,
0x7e, 0xc6, 0x36, 0x93, 0x82, 0x91, 0x05, 0x2d, 0x76, 0x4f, 0xb1, 0xe2, 0xdb, 0x2a, 0x6f, 0xda,
0x17, 0x19, 0xe8, 0x4f, 0x95, 0xfe, 0x45, 0xe8, 0x97, 0x61, 0x5e, 0xc5, 0xe1, 0x6f, 0xe3, 0xc9,
0x95, 0x16, 0x8f, 0xbb, 0xf9, 0x3e, 0xe7, 0x84, 0xbc, 0xa7, 0xec, 0x3b, 0xfd, 0x24, 0x3b, 0x53,
0x4b, 0x49, 0xbd, 0xfc, 0x17, 0x00, 0x00, 0xff, 0xff, 0xe8, 0x1b, 0x59, 0xf8, 0xe5, 0x02, 0x00,
0x00,
}

96
vendor/github.com/golang/protobuf/ptypes/struct/struct.proto generated vendored Normal file
View File

@ -0,0 +1,96 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
syntax = "proto3";
package google.protobuf;
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
option cc_enable_arenas = true;
option go_package = "github.com/golang/protobuf/ptypes/struct;structpb";
option java_package = "com.google.protobuf";
option java_outer_classname = "StructProto";
option java_multiple_files = true;
option objc_class_prefix = "GPB";
// `Struct` represents a structured data value, consisting of fields
// which map to dynamically typed values. In some languages, `Struct`
// might be supported by a native representation. For example, in
// scripting languages like JS a struct is represented as an
// object. The details of that representation are described together
// with the proto support for the language.
//
// The JSON representation for `Struct` is JSON object.
message Struct {
// Unordered map of dynamically typed values.
map<string, Value> fields = 1;
}
// `Value` represents a dynamically typed value which can be either
// null, a number, a string, a boolean, a recursive struct value, or a
// list of values. A producer of value is expected to set one of that
// variants, absence of any variant indicates an error.
//
// The JSON representation for `Value` is JSON value.
message Value {
// The kind of value.
oneof kind {
// Represents a null value.
NullValue null_value = 1;
// Represents a double value.
double number_value = 2;
// Represents a string value.
string string_value = 3;
// Represents a boolean value.
bool bool_value = 4;
// Represents a structured value.
Struct struct_value = 5;
// Represents a repeated `Value`.
ListValue list_value = 6;
}
}
// `NullValue` is a singleton enumeration to represent the null value for the
// `Value` type union.
//
// The JSON representation for `NullValue` is JSON `null`.
enum NullValue {
// Null value.
NULL_VALUE = 0;
}
// `ListValue` is a wrapper around a repeated field of values.
//
// The JSON representation for `ListValue` is JSON array.
message ListValue {
// Repeated field of dynamically typed values.
repeated Value values = 1;
}

461
vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.pb.go generated vendored Normal file
View File

@ -0,0 +1,461 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/protobuf/wrappers.proto
package wrappers
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
// Wrapper message for `double`.
//
// The JSON representation for `DoubleValue` is JSON number.
type DoubleValue struct {
// The double value.
Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DoubleValue) Reset() { *m = DoubleValue{} }
func (m *DoubleValue) String() string { return proto.CompactTextString(m) }
func (*DoubleValue) ProtoMessage() {}
func (*DoubleValue) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{0}
}
func (*DoubleValue) XXX_WellKnownType() string { return "DoubleValue" }
func (m *DoubleValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DoubleValue.Unmarshal(m, b)
}
func (m *DoubleValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DoubleValue.Marshal(b, m, deterministic)
}
func (m *DoubleValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_DoubleValue.Merge(m, src)
}
func (m *DoubleValue) XXX_Size() int {
return xxx_messageInfo_DoubleValue.Size(m)
}
func (m *DoubleValue) XXX_DiscardUnknown() {
xxx_messageInfo_DoubleValue.DiscardUnknown(m)
}
var xxx_messageInfo_DoubleValue proto.InternalMessageInfo
func (m *DoubleValue) GetValue() float64 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `float`.
//
// The JSON representation for `FloatValue` is JSON number.
type FloatValue struct {
// The float value.
Value float32 `protobuf:"fixed32,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *FloatValue) Reset() { *m = FloatValue{} }
func (m *FloatValue) String() string { return proto.CompactTextString(m) }
func (*FloatValue) ProtoMessage() {}
func (*FloatValue) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{1}
}
func (*FloatValue) XXX_WellKnownType() string { return "FloatValue" }
func (m *FloatValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FloatValue.Unmarshal(m, b)
}
func (m *FloatValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_FloatValue.Marshal(b, m, deterministic)
}
func (m *FloatValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_FloatValue.Merge(m, src)
}
func (m *FloatValue) XXX_Size() int {
return xxx_messageInfo_FloatValue.Size(m)
}
func (m *FloatValue) XXX_DiscardUnknown() {
xxx_messageInfo_FloatValue.DiscardUnknown(m)
}
var xxx_messageInfo_FloatValue proto.InternalMessageInfo
func (m *FloatValue) GetValue() float32 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `int64`.
//
// The JSON representation for `Int64Value` is JSON string.
type Int64Value struct {
// The int64 value.
Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Int64Value) Reset() { *m = Int64Value{} }
func (m *Int64Value) String() string { return proto.CompactTextString(m) }
func (*Int64Value) ProtoMessage() {}
func (*Int64Value) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{2}
}
func (*Int64Value) XXX_WellKnownType() string { return "Int64Value" }
func (m *Int64Value) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Int64Value.Unmarshal(m, b)
}
func (m *Int64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Int64Value.Marshal(b, m, deterministic)
}
func (m *Int64Value) XXX_Merge(src proto.Message) {
xxx_messageInfo_Int64Value.Merge(m, src)
}
func (m *Int64Value) XXX_Size() int {
return xxx_messageInfo_Int64Value.Size(m)
}
func (m *Int64Value) XXX_DiscardUnknown() {
xxx_messageInfo_Int64Value.DiscardUnknown(m)
}
var xxx_messageInfo_Int64Value proto.InternalMessageInfo
func (m *Int64Value) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `uint64`.
//
// The JSON representation for `UInt64Value` is JSON string.
type UInt64Value struct {
// The uint64 value.
Value uint64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UInt64Value) Reset() { *m = UInt64Value{} }
func (m *UInt64Value) String() string { return proto.CompactTextString(m) }
func (*UInt64Value) ProtoMessage() {}
func (*UInt64Value) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{3}
}
func (*UInt64Value) XXX_WellKnownType() string { return "UInt64Value" }
func (m *UInt64Value) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UInt64Value.Unmarshal(m, b)
}
func (m *UInt64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UInt64Value.Marshal(b, m, deterministic)
}
func (m *UInt64Value) XXX_Merge(src proto.Message) {
xxx_messageInfo_UInt64Value.Merge(m, src)
}
func (m *UInt64Value) XXX_Size() int {
return xxx_messageInfo_UInt64Value.Size(m)
}
func (m *UInt64Value) XXX_DiscardUnknown() {
xxx_messageInfo_UInt64Value.DiscardUnknown(m)
}
var xxx_messageInfo_UInt64Value proto.InternalMessageInfo
func (m *UInt64Value) GetValue() uint64 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `int32`.
//
// The JSON representation for `Int32Value` is JSON number.
type Int32Value struct {
// The int32 value.
Value int32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Int32Value) Reset() { *m = Int32Value{} }
func (m *Int32Value) String() string { return proto.CompactTextString(m) }
func (*Int32Value) ProtoMessage() {}
func (*Int32Value) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{4}
}
func (*Int32Value) XXX_WellKnownType() string { return "Int32Value" }
func (m *Int32Value) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Int32Value.Unmarshal(m, b)
}
func (m *Int32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Int32Value.Marshal(b, m, deterministic)
}
func (m *Int32Value) XXX_Merge(src proto.Message) {
xxx_messageInfo_Int32Value.Merge(m, src)
}
func (m *Int32Value) XXX_Size() int {
return xxx_messageInfo_Int32Value.Size(m)
}
func (m *Int32Value) XXX_DiscardUnknown() {
xxx_messageInfo_Int32Value.DiscardUnknown(m)
}
var xxx_messageInfo_Int32Value proto.InternalMessageInfo
func (m *Int32Value) GetValue() int32 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `uint32`.
//
// The JSON representation for `UInt32Value` is JSON number.
type UInt32Value struct {
// The uint32 value.
Value uint32 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UInt32Value) Reset() { *m = UInt32Value{} }
func (m *UInt32Value) String() string { return proto.CompactTextString(m) }
func (*UInt32Value) ProtoMessage() {}
func (*UInt32Value) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{5}
}
func (*UInt32Value) XXX_WellKnownType() string { return "UInt32Value" }
func (m *UInt32Value) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UInt32Value.Unmarshal(m, b)
}
func (m *UInt32Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UInt32Value.Marshal(b, m, deterministic)
}
func (m *UInt32Value) XXX_Merge(src proto.Message) {
xxx_messageInfo_UInt32Value.Merge(m, src)
}
func (m *UInt32Value) XXX_Size() int {
return xxx_messageInfo_UInt32Value.Size(m)
}
func (m *UInt32Value) XXX_DiscardUnknown() {
xxx_messageInfo_UInt32Value.DiscardUnknown(m)
}
var xxx_messageInfo_UInt32Value proto.InternalMessageInfo
func (m *UInt32Value) GetValue() uint32 {
if m != nil {
return m.Value
}
return 0
}
// Wrapper message for `bool`.
//
// The JSON representation for `BoolValue` is JSON `true` and `false`.
type BoolValue struct {
// The bool value.
Value bool `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *BoolValue) Reset() { *m = BoolValue{} }
func (m *BoolValue) String() string { return proto.CompactTextString(m) }
func (*BoolValue) ProtoMessage() {}
func (*BoolValue) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{6}
}
func (*BoolValue) XXX_WellKnownType() string { return "BoolValue" }
func (m *BoolValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_BoolValue.Unmarshal(m, b)
}
func (m *BoolValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_BoolValue.Marshal(b, m, deterministic)
}
func (m *BoolValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_BoolValue.Merge(m, src)
}
func (m *BoolValue) XXX_Size() int {
return xxx_messageInfo_BoolValue.Size(m)
}
func (m *BoolValue) XXX_DiscardUnknown() {
xxx_messageInfo_BoolValue.DiscardUnknown(m)
}
var xxx_messageInfo_BoolValue proto.InternalMessageInfo
func (m *BoolValue) GetValue() bool {
if m != nil {
return m.Value
}
return false
}
// Wrapper message for `string`.
//
// The JSON representation for `StringValue` is JSON string.
type StringValue struct {
// The string value.
Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *StringValue) Reset() { *m = StringValue{} }
func (m *StringValue) String() string { return proto.CompactTextString(m) }
func (*StringValue) ProtoMessage() {}
func (*StringValue) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{7}
}
func (*StringValue) XXX_WellKnownType() string { return "StringValue" }
func (m *StringValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_StringValue.Unmarshal(m, b)
}
func (m *StringValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_StringValue.Marshal(b, m, deterministic)
}
func (m *StringValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_StringValue.Merge(m, src)
}
func (m *StringValue) XXX_Size() int {
return xxx_messageInfo_StringValue.Size(m)
}
func (m *StringValue) XXX_DiscardUnknown() {
xxx_messageInfo_StringValue.DiscardUnknown(m)
}
var xxx_messageInfo_StringValue proto.InternalMessageInfo
func (m *StringValue) GetValue() string {
if m != nil {
return m.Value
}
return ""
}
// Wrapper message for `bytes`.
//
// The JSON representation for `BytesValue` is JSON string.
type BytesValue struct {
// The bytes value.
Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *BytesValue) Reset() { *m = BytesValue{} }
func (m *BytesValue) String() string { return proto.CompactTextString(m) }
func (*BytesValue) ProtoMessage() {}
func (*BytesValue) Descriptor() ([]byte, []int) {
return fileDescriptor_5377b62bda767935, []int{8}
}
func (*BytesValue) XXX_WellKnownType() string { return "BytesValue" }
func (m *BytesValue) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_BytesValue.Unmarshal(m, b)
}
func (m *BytesValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_BytesValue.Marshal(b, m, deterministic)
}
func (m *BytesValue) XXX_Merge(src proto.Message) {
xxx_messageInfo_BytesValue.Merge(m, src)
}
func (m *BytesValue) XXX_Size() int {
return xxx_messageInfo_BytesValue.Size(m)
}
func (m *BytesValue) XXX_DiscardUnknown() {
xxx_messageInfo_BytesValue.DiscardUnknown(m)
}
var xxx_messageInfo_BytesValue proto.InternalMessageInfo
func (m *BytesValue) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
func init() {
proto.RegisterType((*DoubleValue)(nil), "google.protobuf.DoubleValue")
proto.RegisterType((*FloatValue)(nil), "google.protobuf.FloatValue")
proto.RegisterType((*Int64Value)(nil), "google.protobuf.Int64Value")
proto.RegisterType((*UInt64Value)(nil), "google.protobuf.UInt64Value")
proto.RegisterType((*Int32Value)(nil), "google.protobuf.Int32Value")
proto.RegisterType((*UInt32Value)(nil), "google.protobuf.UInt32Value")
proto.RegisterType((*BoolValue)(nil), "google.protobuf.BoolValue")
proto.RegisterType((*StringValue)(nil), "google.protobuf.StringValue")
proto.RegisterType((*BytesValue)(nil), "google.protobuf.BytesValue")
}
func init() { proto.RegisterFile("google/protobuf/wrappers.proto", fileDescriptor_5377b62bda767935) }
var fileDescriptor_5377b62bda767935 = []byte{
// 259 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x2f, 0x4a, 0x2c,
0x28, 0x48, 0x2d, 0x2a, 0xd6, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0xca,
0x5c, 0xdc, 0x2e, 0xf9, 0xa5, 0x49, 0x39, 0xa9, 0x61, 0x89, 0x39, 0xa5, 0xa9, 0x42, 0x22, 0x5c,
0xac, 0x65, 0x20, 0x86, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x63, 0x10, 0x84, 0xa3, 0xa4, 0xc4, 0xc5,
0xe5, 0x96, 0x93, 0x9f, 0x58, 0x82, 0x45, 0x0d, 0x13, 0x92, 0x1a, 0xcf, 0xbc, 0x12, 0x33, 0x13,
0x2c, 0x6a, 0x98, 0x61, 0x6a, 0x94, 0xb9, 0xb8, 0x43, 0x71, 0x29, 0x62, 0x41, 0x35, 0xc8, 0xd8,
0x08, 0x8b, 0x1a, 0x56, 0x34, 0x83, 0xb0, 0x2a, 0xe2, 0x85, 0x29, 0x52, 0xe4, 0xe2, 0x74, 0xca,
0xcf, 0xcf, 0xc1, 0xa2, 0x84, 0x03, 0xc9, 0x9c, 0xe0, 0x92, 0xa2, 0xcc, 0xbc, 0x74, 0x2c, 0x8a,
0x38, 0x91, 0x1c, 0xe4, 0x54, 0x59, 0x92, 0x5a, 0x8c, 0x45, 0x0d, 0x0f, 0x54, 0x8d, 0x53, 0x0d,
0x97, 0x70, 0x72, 0x7e, 0xae, 0x1e, 0x5a, 0xe8, 0x3a, 0xf1, 0x86, 0x43, 0x83, 0x3f, 0x00, 0x24,
0x12, 0xc0, 0x18, 0xa5, 0x95, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x9f,
0x9e, 0x9f, 0x93, 0x98, 0x97, 0x8e, 0x88, 0xaa, 0x82, 0x92, 0xca, 0x82, 0xd4, 0x62, 0x78, 0x8c,
0xfd, 0x60, 0x64, 0x5c, 0xc4, 0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0x62, 0x6e,
0x00, 0x54, 0xa9, 0x5e, 0x78, 0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x4b,
0x12, 0x1b, 0xd8, 0x0c, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x19, 0x6c, 0xb9, 0xb8, 0xfe,
0x01, 0x00, 0x00,
}

118
vendor/github.com/golang/protobuf/ptypes/wrappers/wrappers.proto generated vendored Normal file
View File

@ -0,0 +1,118 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Wrappers for primitive (non-message) types. These types are useful
// for embedding primitives in the `google.protobuf.Any` type and for places
// where we need to distinguish between the absence of a primitive
// typed field and its default value.
syntax = "proto3";
package google.protobuf;
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
option cc_enable_arenas = true;
option go_package = "github.com/golang/protobuf/ptypes/wrappers";
option java_package = "com.google.protobuf";
option java_outer_classname = "WrappersProto";
option java_multiple_files = true;
option objc_class_prefix = "GPB";
// Wrapper message for `double`.
//
// The JSON representation for `DoubleValue` is JSON number.
message DoubleValue {
// The double value.
double value = 1;
}
// Wrapper message for `float`.
//
// The JSON representation for `FloatValue` is JSON number.
message FloatValue {
// The float value.
float value = 1;
}
// Wrapper message for `int64`.
//
// The JSON representation for `Int64Value` is JSON string.
message Int64Value {
// The int64 value.
int64 value = 1;
}
// Wrapper message for `uint64`.
//
// The JSON representation for `UInt64Value` is JSON string.
message UInt64Value {
// The uint64 value.
uint64 value = 1;
}
// Wrapper message for `int32`.
//
// The JSON representation for `Int32Value` is JSON number.
message Int32Value {
// The int32 value.
int32 value = 1;
}
// Wrapper message for `uint32`.
//
// The JSON representation for `UInt32Value` is JSON number.
message UInt32Value {
// The uint32 value.
uint32 value = 1;
}
// Wrapper message for `bool`.
//
// The JSON representation for `BoolValue` is JSON `true` and `false`.
message BoolValue {
// The bool value.
bool value = 1;
}
// Wrapper message for `string`.
//
// The JSON representation for `StringValue` is JSON string.
message StringValue {
// The string value.
string value = 1;
}
// Wrapper message for `bytes`.
//
// The JSON representation for `BytesValue` is JSON string.
message BytesValue {
// The bytes value.
bytes value = 1;
}

21
vendor/github.com/yandex-cloud/go-genproto/LICENSE generated vendored Normal file
View File

@ -0,0 +1,21 @@
The MIT License (MIT)
Copyright (c) 2018 YANDEX LLC
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

109
vendor/github.com/yandex-cloud/go-genproto/yandex/api/operation.pb.go generated vendored Normal file
View File

@ -0,0 +1,109 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/api/operation.proto
package api // import "github.com/yandex-cloud/go-genproto/yandex/api"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Operation is annotation for rpc that returns longrunning operation, describes
// message types that will be returned in metadata [google.protobuf.Any], and
// in response [google.protobuf.Any] (for successful operation).
type Operation struct {
// Optional. If present, rpc returns operation which metadata field will
// contains message of specified type.
Metadata string `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
// Required. rpc returns operation, in case of success response will contains message of
// specified field.
Response string `protobuf:"bytes,2,opt,name=response,proto3" json:"response,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Operation) Reset() { *m = Operation{} }
func (m *Operation) String() string { return proto.CompactTextString(m) }
func (*Operation) ProtoMessage() {}
func (*Operation) Descriptor() ([]byte, []int) {
return fileDescriptor_operation_743b45b46a739ce6, []int{0}
}
func (m *Operation) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Operation.Unmarshal(m, b)
}
func (m *Operation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Operation.Marshal(b, m, deterministic)
}
func (dst *Operation) XXX_Merge(src proto.Message) {
xxx_messageInfo_Operation.Merge(dst, src)
}
func (m *Operation) XXX_Size() int {
return xxx_messageInfo_Operation.Size(m)
}
func (m *Operation) XXX_DiscardUnknown() {
xxx_messageInfo_Operation.DiscardUnknown(m)
}
var xxx_messageInfo_Operation proto.InternalMessageInfo
func (m *Operation) GetMetadata() string {
if m != nil {
return m.Metadata
}
return ""
}
func (m *Operation) GetResponse() string {
if m != nil {
return m.Response
}
return ""
}
var E_Operation = &proto.ExtensionDesc{
ExtendedType: (*descriptor.MethodOptions)(nil),
ExtensionType: (*Operation)(nil),
Field: 87334,
Name: "yandex.api.operation",
Tag: "bytes,87334,opt,name=operation",
Filename: "yandex/api/operation.proto",
}
func init() {
proto.RegisterType((*Operation)(nil), "yandex.api.Operation")
proto.RegisterExtension(E_Operation)
}
func init() {
proto.RegisterFile("yandex/api/operation.proto", fileDescriptor_operation_743b45b46a739ce6)
}
var fileDescriptor_operation_743b45b46a739ce6 = []byte{
// 217 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x44, 0x90, 0x31, 0x4b, 0xc4, 0x40,
0x10, 0x85, 0x89, 0xa0, 0x98, 0xb5, 0x0b, 0x08, 0x21, 0x85, 0x04, 0xab, 0x6b, 0x6e, 0x16, 0x4e,
0x2b, 0xed, 0xb4, 0x96, 0x83, 0x03, 0x1b, 0xbb, 0x49, 0x76, 0xdc, 0x5b, 0xb8, 0xdb, 0x19, 0x76,
0x37, 0xa0, 0x7f, 0xc8, 0xc2, 0x5f, 0x79, 0x24, 0x4b, 0x92, 0xf2, 0xcd, 0xf7, 0x78, 0xef, 0x31,
0xaa, 0xf9, 0x45, 0x6f, 0xe8, 0x47, 0xa3, 0x38, 0xcd, 0x42, 0x01, 0x93, 0x63, 0x0f, 0x12, 0x38,
0x71, 0xa5, 0x32, 0x03, 0x14, 0xd7, 0xb4, 0x96, 0xd9, 0x9e, 0x48, 0x4f, 0xa4, 0x1b, 0xbe, 0xb5,
0xa1, 0xd8, 0x07, 0x27, 0x89, 0x43, 0x76, 0x3f, 0xbe, 0xab, 0x72, 0x3f, 0x07, 0x54, 0x8d, 0xba,
0x3d, 0x53, 0x42, 0x83, 0x09, 0xeb, 0xa2, 0x2d, 0x36, 0xe5, 0x61, 0xd1, 0x23, 0x0b, 0x14, 0x85,
0x7d, 0xa4, 0xfa, 0x2a, 0xb3, 0x59, 0xbf, 0x7c, 0xaa, 0x72, 0x59, 0x51, 0x3d, 0x40, 0x2e, 0x85,
0xb9, 0x14, 0x3e, 0x28, 0x1d, 0xd9, 0xec, 0x65, 0xc4, 0xb1, 0xfe, 0xfb, 0xbf, 0x6e, 0x8b, 0xcd,
0xdd, 0xee, 0x1e, 0xd6, 0xa1, 0xb0, 0x6c, 0x38, 0xac, 0x49, 0x6f, 0xcf, 0x5f, 0x3b, 0xeb, 0xd2,
0x71, 0xe8, 0xa0, 0xe7, 0xb3, 0xce, 0xee, 0x6d, 0x7f, 0xe2, 0xc1, 0x68, 0xcb, 0x5b, 0x4b, 0x7e,
0x6a, 0xd0, 0xeb, 0x2f, 0x5e, 0x51, 0x5c, 0x77, 0x33, 0x5d, 0x9f, 0x2e, 0x01, 0x00, 0x00, 0xff,
0xff, 0x47, 0x3d, 0x10, 0x6e, 0x24, 0x01, 0x00, 0x00,
}

560
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/access/access.pb.go generated vendored Normal file
View File

@ -0,0 +1,560 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/access/access.proto
package access // import "github.com/yandex-cloud/go-genproto/yandex/cloud/access"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type AccessBindingAction int32
const (
AccessBindingAction_ACCESS_BINDING_ACTION_UNSPECIFIED AccessBindingAction = 0
// Addition of an access binding.
AccessBindingAction_ADD AccessBindingAction = 1
// Removal of an access binding.
AccessBindingAction_REMOVE AccessBindingAction = 2
)
var AccessBindingAction_name = map[int32]string{
0: "ACCESS_BINDING_ACTION_UNSPECIFIED",
1: "ADD",
2: "REMOVE",
}
var AccessBindingAction_value = map[string]int32{
"ACCESS_BINDING_ACTION_UNSPECIFIED": 0,
"ADD": 1,
"REMOVE": 2,
}
func (x AccessBindingAction) String() string {
return proto.EnumName(AccessBindingAction_name, int32(x))
}
func (AccessBindingAction) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{0}
}
type Subject struct {
// ID of the subject.
//
// It can contain one of the following values:
// * `allAuthenticatedUsers`: A special system identifier that represents anyone
// who is authenticated. It can be used only if the [type] is `system`.
//
// * `<cloud generated id>`: An identifier that represents a user account.
// It can be used only if the [type] is `userAccount` or `serviceAccount`.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// Type of the subject.
//
// It can contain one of the following values:
// * `system`: System group. This type represents several accounts with a common system identifier.
// * `userAccount`: An user account (for example, "alice.the.girl@yandex.ru"). This type represents the [yandex.cloud.iam.v1.UserAccount] resource.
// * `serviceAccount`: A service account. This type represents the [yandex.cloud.iam.v1.ServiceAccount] resource.
//
// For more information, see [Subject to which the role is assigned](/docs/iam/concepts/access-control/#subject).
Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Subject) Reset() { *m = Subject{} }
func (m *Subject) String() string { return proto.CompactTextString(m) }
func (*Subject) ProtoMessage() {}
func (*Subject) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{0}
}
func (m *Subject) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Subject.Unmarshal(m, b)
}
func (m *Subject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Subject.Marshal(b, m, deterministic)
}
func (dst *Subject) XXX_Merge(src proto.Message) {
xxx_messageInfo_Subject.Merge(dst, src)
}
func (m *Subject) XXX_Size() int {
return xxx_messageInfo_Subject.Size(m)
}
func (m *Subject) XXX_DiscardUnknown() {
xxx_messageInfo_Subject.DiscardUnknown(m)
}
var xxx_messageInfo_Subject proto.InternalMessageInfo
func (m *Subject) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Subject) GetType() string {
if m != nil {
return m.Type
}
return ""
}
type AccessBinding struct {
// ID of the [yandex.cloud.iam.v1.Role] that is assigned to the [subject].
RoleId string `protobuf:"bytes,1,opt,name=role_id,json=roleId,proto3" json:"role_id,omitempty"`
// Identity for which access binding is being created.
// It can represent an account with a unique ID or several accounts with a system identifier.
Subject *Subject `protobuf:"bytes,2,opt,name=subject,proto3" json:"subject,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AccessBinding) Reset() { *m = AccessBinding{} }
func (m *AccessBinding) String() string { return proto.CompactTextString(m) }
func (*AccessBinding) ProtoMessage() {}
func (*AccessBinding) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{1}
}
func (m *AccessBinding) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AccessBinding.Unmarshal(m, b)
}
func (m *AccessBinding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AccessBinding.Marshal(b, m, deterministic)
}
func (dst *AccessBinding) XXX_Merge(src proto.Message) {
xxx_messageInfo_AccessBinding.Merge(dst, src)
}
func (m *AccessBinding) XXX_Size() int {
return xxx_messageInfo_AccessBinding.Size(m)
}
func (m *AccessBinding) XXX_DiscardUnknown() {
xxx_messageInfo_AccessBinding.DiscardUnknown(m)
}
var xxx_messageInfo_AccessBinding proto.InternalMessageInfo
func (m *AccessBinding) GetRoleId() string {
if m != nil {
return m.RoleId
}
return ""
}
func (m *AccessBinding) GetSubject() *Subject {
if m != nil {
return m.Subject
}
return nil
}
type ListAccessBindingsRequest struct {
// ID of the resource to list access bindings for.
//
// To get the resource ID, use a corresponding List request.
// For example, use the [yandex.cloud.resourcemanager.v1.CloudService.List] request to get the Cloud resource ID.
ResourceId string `protobuf:"bytes,1,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
// The maximum number of results per page that should be returned. If the number of available
// results is larger than [page_size],
// the service returns a [ListAccessBindingsResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
// Default value: 100.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. Set [page_token]
// to the [ListAccessBindingsResponse.next_page_token]
// returned by a previous list request to get the next page of results.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListAccessBindingsRequest) Reset() { *m = ListAccessBindingsRequest{} }
func (m *ListAccessBindingsRequest) String() string { return proto.CompactTextString(m) }
func (*ListAccessBindingsRequest) ProtoMessage() {}
func (*ListAccessBindingsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{2}
}
func (m *ListAccessBindingsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListAccessBindingsRequest.Unmarshal(m, b)
}
func (m *ListAccessBindingsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListAccessBindingsRequest.Marshal(b, m, deterministic)
}
func (dst *ListAccessBindingsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListAccessBindingsRequest.Merge(dst, src)
}
func (m *ListAccessBindingsRequest) XXX_Size() int {
return xxx_messageInfo_ListAccessBindingsRequest.Size(m)
}
func (m *ListAccessBindingsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListAccessBindingsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListAccessBindingsRequest proto.InternalMessageInfo
func (m *ListAccessBindingsRequest) GetResourceId() string {
if m != nil {
return m.ResourceId
}
return ""
}
func (m *ListAccessBindingsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListAccessBindingsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListAccessBindingsResponse struct {
// List of access bindings for the specified resource.
AccessBindings []*AccessBinding `protobuf:"bytes,1,rep,name=access_bindings,json=accessBindings,proto3" json:"access_bindings,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListAccessBindingsRequest.page_size], use
// the [next_page_token] as the value
// for the [ListAccessBindingsRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListAccessBindingsResponse) Reset() { *m = ListAccessBindingsResponse{} }
func (m *ListAccessBindingsResponse) String() string { return proto.CompactTextString(m) }
func (*ListAccessBindingsResponse) ProtoMessage() {}
func (*ListAccessBindingsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{3}
}
func (m *ListAccessBindingsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListAccessBindingsResponse.Unmarshal(m, b)
}
func (m *ListAccessBindingsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListAccessBindingsResponse.Marshal(b, m, deterministic)
}
func (dst *ListAccessBindingsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListAccessBindingsResponse.Merge(dst, src)
}
func (m *ListAccessBindingsResponse) XXX_Size() int {
return xxx_messageInfo_ListAccessBindingsResponse.Size(m)
}
func (m *ListAccessBindingsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListAccessBindingsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListAccessBindingsResponse proto.InternalMessageInfo
func (m *ListAccessBindingsResponse) GetAccessBindings() []*AccessBinding {
if m != nil {
return m.AccessBindings
}
return nil
}
func (m *ListAccessBindingsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type SetAccessBindingsRequest struct {
// ID of the resource for which access bindings are being set.
//
// To get the resource ID, use a corresponding List request.
ResourceId string `protobuf:"bytes,1,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
// Access bindings to be set. For more information, see [Access Bindings](/docs/iam/concepts/access-control/#access-bindings).
AccessBindings []*AccessBinding `protobuf:"bytes,2,rep,name=access_bindings,json=accessBindings,proto3" json:"access_bindings,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SetAccessBindingsRequest) Reset() { *m = SetAccessBindingsRequest{} }
func (m *SetAccessBindingsRequest) String() string { return proto.CompactTextString(m) }
func (*SetAccessBindingsRequest) ProtoMessage() {}
func (*SetAccessBindingsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{4}
}
func (m *SetAccessBindingsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetAccessBindingsRequest.Unmarshal(m, b)
}
func (m *SetAccessBindingsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SetAccessBindingsRequest.Marshal(b, m, deterministic)
}
func (dst *SetAccessBindingsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_SetAccessBindingsRequest.Merge(dst, src)
}
func (m *SetAccessBindingsRequest) XXX_Size() int {
return xxx_messageInfo_SetAccessBindingsRequest.Size(m)
}
func (m *SetAccessBindingsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_SetAccessBindingsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_SetAccessBindingsRequest proto.InternalMessageInfo
func (m *SetAccessBindingsRequest) GetResourceId() string {
if m != nil {
return m.ResourceId
}
return ""
}
func (m *SetAccessBindingsRequest) GetAccessBindings() []*AccessBinding {
if m != nil {
return m.AccessBindings
}
return nil
}
type SetAccessBindingsMetadata struct {
// ID of the resource for which access bindings are being set.
ResourceId string `protobuf:"bytes,1,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SetAccessBindingsMetadata) Reset() { *m = SetAccessBindingsMetadata{} }
func (m *SetAccessBindingsMetadata) String() string { return proto.CompactTextString(m) }
func (*SetAccessBindingsMetadata) ProtoMessage() {}
func (*SetAccessBindingsMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{5}
}
func (m *SetAccessBindingsMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SetAccessBindingsMetadata.Unmarshal(m, b)
}
func (m *SetAccessBindingsMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SetAccessBindingsMetadata.Marshal(b, m, deterministic)
}
func (dst *SetAccessBindingsMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_SetAccessBindingsMetadata.Merge(dst, src)
}
func (m *SetAccessBindingsMetadata) XXX_Size() int {
return xxx_messageInfo_SetAccessBindingsMetadata.Size(m)
}
func (m *SetAccessBindingsMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_SetAccessBindingsMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_SetAccessBindingsMetadata proto.InternalMessageInfo
func (m *SetAccessBindingsMetadata) GetResourceId() string {
if m != nil {
return m.ResourceId
}
return ""
}
type UpdateAccessBindingsRequest struct {
// ID of the resource for which access bindings are being updated.
ResourceId string `protobuf:"bytes,1,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
// Updates to access bindings.
AccessBindingDeltas []*AccessBindingDelta `protobuf:"bytes,2,rep,name=access_binding_deltas,json=accessBindingDeltas,proto3" json:"access_binding_deltas,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UpdateAccessBindingsRequest) Reset() { *m = UpdateAccessBindingsRequest{} }
func (m *UpdateAccessBindingsRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateAccessBindingsRequest) ProtoMessage() {}
func (*UpdateAccessBindingsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{6}
}
func (m *UpdateAccessBindingsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateAccessBindingsRequest.Unmarshal(m, b)
}
func (m *UpdateAccessBindingsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UpdateAccessBindingsRequest.Marshal(b, m, deterministic)
}
func (dst *UpdateAccessBindingsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_UpdateAccessBindingsRequest.Merge(dst, src)
}
func (m *UpdateAccessBindingsRequest) XXX_Size() int {
return xxx_messageInfo_UpdateAccessBindingsRequest.Size(m)
}
func (m *UpdateAccessBindingsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_UpdateAccessBindingsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_UpdateAccessBindingsRequest proto.InternalMessageInfo
func (m *UpdateAccessBindingsRequest) GetResourceId() string {
if m != nil {
return m.ResourceId
}
return ""
}
func (m *UpdateAccessBindingsRequest) GetAccessBindingDeltas() []*AccessBindingDelta {
if m != nil {
return m.AccessBindingDeltas
}
return nil
}
type UpdateAccessBindingsMetadata struct {
// ID of the resource for which access bindings are being updated.
ResourceId string `protobuf:"bytes,1,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UpdateAccessBindingsMetadata) Reset() { *m = UpdateAccessBindingsMetadata{} }
func (m *UpdateAccessBindingsMetadata) String() string { return proto.CompactTextString(m) }
func (*UpdateAccessBindingsMetadata) ProtoMessage() {}
func (*UpdateAccessBindingsMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{7}
}
func (m *UpdateAccessBindingsMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateAccessBindingsMetadata.Unmarshal(m, b)
}
func (m *UpdateAccessBindingsMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UpdateAccessBindingsMetadata.Marshal(b, m, deterministic)
}
func (dst *UpdateAccessBindingsMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_UpdateAccessBindingsMetadata.Merge(dst, src)
}
func (m *UpdateAccessBindingsMetadata) XXX_Size() int {
return xxx_messageInfo_UpdateAccessBindingsMetadata.Size(m)
}
func (m *UpdateAccessBindingsMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_UpdateAccessBindingsMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_UpdateAccessBindingsMetadata proto.InternalMessageInfo
func (m *UpdateAccessBindingsMetadata) GetResourceId() string {
if m != nil {
return m.ResourceId
}
return ""
}
type AccessBindingDelta struct {
// The action that is being performed on an access binding.
Action AccessBindingAction `protobuf:"varint,1,opt,name=action,proto3,enum=yandex.cloud.access.AccessBindingAction" json:"action,omitempty"`
// Access binding. For more information, see [Access Bindings](/docs/iam/concepts/access-control/#access-bindings).
AccessBinding *AccessBinding `protobuf:"bytes,2,opt,name=access_binding,json=accessBinding,proto3" json:"access_binding,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AccessBindingDelta) Reset() { *m = AccessBindingDelta{} }
func (m *AccessBindingDelta) String() string { return proto.CompactTextString(m) }
func (*AccessBindingDelta) ProtoMessage() {}
func (*AccessBindingDelta) Descriptor() ([]byte, []int) {
return fileDescriptor_access_6c04a92fd5da6f4f, []int{8}
}
func (m *AccessBindingDelta) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AccessBindingDelta.Unmarshal(m, b)
}
func (m *AccessBindingDelta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AccessBindingDelta.Marshal(b, m, deterministic)
}
func (dst *AccessBindingDelta) XXX_Merge(src proto.Message) {
xxx_messageInfo_AccessBindingDelta.Merge(dst, src)
}
func (m *AccessBindingDelta) XXX_Size() int {
return xxx_messageInfo_AccessBindingDelta.Size(m)
}
func (m *AccessBindingDelta) XXX_DiscardUnknown() {
xxx_messageInfo_AccessBindingDelta.DiscardUnknown(m)
}
var xxx_messageInfo_AccessBindingDelta proto.InternalMessageInfo
func (m *AccessBindingDelta) GetAction() AccessBindingAction {
if m != nil {
return m.Action
}
return AccessBindingAction_ACCESS_BINDING_ACTION_UNSPECIFIED
}
func (m *AccessBindingDelta) GetAccessBinding() *AccessBinding {
if m != nil {
return m.AccessBinding
}
return nil
}
func init() {
proto.RegisterType((*Subject)(nil), "yandex.cloud.access.Subject")
proto.RegisterType((*AccessBinding)(nil), "yandex.cloud.access.AccessBinding")
proto.RegisterType((*ListAccessBindingsRequest)(nil), "yandex.cloud.access.ListAccessBindingsRequest")
proto.RegisterType((*ListAccessBindingsResponse)(nil), "yandex.cloud.access.ListAccessBindingsResponse")
proto.RegisterType((*SetAccessBindingsRequest)(nil), "yandex.cloud.access.SetAccessBindingsRequest")
proto.RegisterType((*SetAccessBindingsMetadata)(nil), "yandex.cloud.access.SetAccessBindingsMetadata")
proto.RegisterType((*UpdateAccessBindingsRequest)(nil), "yandex.cloud.access.UpdateAccessBindingsRequest")
proto.RegisterType((*UpdateAccessBindingsMetadata)(nil), "yandex.cloud.access.UpdateAccessBindingsMetadata")
proto.RegisterType((*AccessBindingDelta)(nil), "yandex.cloud.access.AccessBindingDelta")
proto.RegisterEnum("yandex.cloud.access.AccessBindingAction", AccessBindingAction_name, AccessBindingAction_value)
}
func init() {
proto.RegisterFile("yandex/cloud/access/access.proto", fileDescriptor_access_6c04a92fd5da6f4f)
}
var fileDescriptor_access_6c04a92fd5da6f4f = []byte{
// 579 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0xcf, 0x6e, 0xd3, 0x4c,
0x14, 0xc5, 0x3f, 0x27, 0xfd, 0x92, 0xe6, 0x86, 0xa4, 0xd1, 0x44, 0x48, 0x6e, 0x29, 0x22, 0xb5,
0x04, 0x8d, 0x90, 0xe2, 0xfc, 0x41, 0x88, 0x05, 0x29, 0x10, 0x27, 0x29, 0xb2, 0xa0, 0x49, 0x6b,
0xb7, 0x2c, 0xd8, 0x58, 0x13, 0xcf, 0x28, 0x18, 0x82, 0x6d, 0x32, 0x13, 0xd4, 0xf6, 0x11, 0xba,
0x63, 0x0f, 0x8f, 0x80, 0x78, 0x8c, 0xf6, 0x51, 0x78, 0x06, 0x56, 0xc8, 0x63, 0xa7, 0x8a, 0x89,
0xa5, 0x66, 0xd1, 0xd5, 0x58, 0xbe, 0xe7, 0x9e, 0xfb, 0x3b, 0x33, 0x9a, 0x81, 0xca, 0x19, 0x76,
0x09, 0x3d, 0xad, 0xdb, 0x13, 0x6f, 0x46, 0xea, 0xd8, 0xb6, 0x29, 0x63, 0xd1, 0xa2, 0xfa, 0x53,
0x8f, 0x7b, 0xa8, 0x1c, 0x2a, 0x54, 0xa1, 0x50, 0xc3, 0xd2, 0xd6, 0xfd, 0x58, 0xdb, 0x57, 0x3c,
0x71, 0x08, 0xe6, 0x8e, 0xe7, 0x86, 0x3d, 0xca, 0x33, 0xc8, 0x9a, 0xb3, 0xd1, 0x47, 0x6a, 0x73,
0x24, 0x43, 0xca, 0x21, 0xb2, 0x54, 0x91, 0xaa, 0x39, 0x6d, 0xfd, 0xe2, 0xaa, 0xb9, 0xd6, 0xde,
0x7b, 0xda, 0x30, 0x52, 0x0e, 0x41, 0x08, 0xd6, 0xf8, 0x99, 0x4f, 0xe5, 0x54, 0x50, 0x33, 0xc4,
0xb7, 0xe2, 0x43, 0xa1, 0x23, 0x26, 0x68, 0x8e, 0x4b, 0x1c, 0x77, 0x8c, 0x76, 0x20, 0x3b, 0xf5,
0x26, 0xd4, 0x4a, 0xf0, 0xc8, 0x04, 0x05, 0x9d, 0xa0, 0x36, 0x64, 0x59, 0x38, 0x4c, 0x58, 0xe5,
0x5b, 0xdb, 0x6a, 0x02, 0xb2, 0x1a, 0x01, 0x69, 0x6b, 0xbf, 0x2f, 0x9b, 0x92, 0x31, 0x6f, 0x51,
0x7e, 0x48, 0xb0, 0xf9, 0xd6, 0x61, 0x3c, 0x36, 0x96, 0x19, 0xf4, 0xcb, 0x8c, 0x32, 0x8e, 0x6a,
0x90, 0x9f, 0x52, 0xe6, 0xcd, 0xa6, 0xf6, 0x02, 0xc2, 0x9d, 0xc0, 0xe1, 0x1a, 0x03, 0xe6, 0x02,
0x9d, 0xa0, 0x5d, 0xc8, 0xf9, 0x78, 0x4c, 0x2d, 0xe6, 0x9c, 0x87, 0xb9, 0xd2, 0x1a, 0xfc, 0xb9,
0x6c, 0x66, 0xda, 0x7b, 0xcd, 0x46, 0xa3, 0x61, 0xac, 0x07, 0x45, 0xd3, 0x39, 0xa7, 0xa8, 0x0a,
0x20, 0x84, 0xdc, 0xfb, 0x44, 0x5d, 0x39, 0x2d, 0x6c, 0x73, 0x17, 0x57, 0xcd, 0xff, 0x85, 0xd2,
0x10, 0x2e, 0xc7, 0x41, 0x4d, 0xf9, 0x26, 0xc1, 0x56, 0x12, 0x1f, 0xf3, 0x3d, 0x97, 0x51, 0xf4,
0x06, 0x36, 0xc2, 0x7c, 0xd6, 0x28, 0x2a, 0xc9, 0x52, 0x25, 0x5d, 0xcd, 0xb7, 0x94, 0xc4, 0x4d,
0x88, 0xb9, 0x18, 0x45, 0x1c, 0x33, 0x45, 0x8f, 0x60, 0xc3, 0xa5, 0xa7, 0xdc, 0x5a, 0x40, 0x0b,
0x0f, 0xa7, 0x10, 0xfc, 0x3e, 0xbc, 0x66, 0xfa, 0x2e, 0x81, 0x6c, 0xd2, 0xdb, 0xd9, 0xb2, 0xa3,
0xe5, 0x00, 0xa9, 0x55, 0x03, 0x44, 0x67, 0xf9, 0x4f, 0x0c, 0xa5, 0x0d, 0x9b, 0x4b, 0x74, 0x07,
0x94, 0x63, 0x82, 0x39, 0x46, 0x0f, 0x12, 0xf0, 0x16, 0x81, 0x94, 0x5f, 0x12, 0xdc, 0x3b, 0xf1,
0x09, 0xe6, 0xf4, 0x56, 0xf2, 0x61, 0xb8, 0x1b, 0xcf, 0x67, 0x11, 0x3a, 0xe1, 0x78, 0x9e, 0x72,
0xf7, 0xe6, 0x94, 0xbd, 0x40, 0x1f, 0x45, 0x2d, 0xe3, 0xa5, 0x0a, 0x53, 0x5e, 0xc2, 0x76, 0x12,
0xf0, 0xea, 0x91, 0x7f, 0x4a, 0x80, 0x96, 0x47, 0xa2, 0x7d, 0xc8, 0x60, 0x3b, 0xb8, 0xd5, 0xa2,
0xa5, 0xd8, 0xaa, 0xde, 0xcc, 0xda, 0x11, 0xfa, 0x08, 0x36, 0xea, 0x46, 0x43, 0x28, 0xc6, 0xb7,
0x20, 0xba, 0xa7, 0xab, 0x9f, 0x70, 0x21, 0x16, 0xfb, 0xf1, 0x11, 0x94, 0x13, 0xa6, 0xa2, 0x87,
0xb0, 0xd3, 0xe9, 0x76, 0xfb, 0xa6, 0x69, 0x69, 0xfa, 0xa0, 0xa7, 0x0f, 0x5e, 0x5b, 0x9d, 0xee,
0xb1, 0x3e, 0x1c, 0x58, 0x27, 0x03, 0xf3, 0xb0, 0xdf, 0xd5, 0xf7, 0xf5, 0x7e, 0xaf, 0xf4, 0x1f,
0xca, 0x42, 0xba, 0xd3, 0xeb, 0x95, 0x24, 0x04, 0x90, 0x31, 0xfa, 0x07, 0xc3, 0x77, 0xfd, 0x52,
0x4a, 0x7b, 0xf5, 0xfe, 0xc5, 0xd8, 0xe1, 0x1f, 0x66, 0x23, 0xd5, 0xf6, 0x3e, 0xd7, 0x43, 0xae,
0x5a, 0xf8, 0xba, 0x8d, 0xbd, 0xda, 0x98, 0xba, 0xe2, 0x61, 0xab, 0x27, 0xbc, 0x96, 0xcf, 0xc3,
0x65, 0x94, 0x11, 0x8a, 0x27, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xc3, 0xce, 0x12, 0xcf, 0x52,
0x05, 0x00, 0x00,
}

357
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk.pb.go generated vendored Normal file
View File

@ -0,0 +1,357 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/disk.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type Disk_Status int32
const (
Disk_STATUS_UNSPECIFIED Disk_Status = 0
// Disk is being created.
Disk_CREATING Disk_Status = 1
// Disk is ready to use.
Disk_READY Disk_Status = 2
// Disk encountered a problem and cannot operate.
Disk_ERROR Disk_Status = 3
// Disk is being deleted.
Disk_DELETING Disk_Status = 4
)
var Disk_Status_name = map[int32]string{
0: "STATUS_UNSPECIFIED",
1: "CREATING",
2: "READY",
3: "ERROR",
4: "DELETING",
}
var Disk_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
"CREATING": 1,
"READY": 2,
"ERROR": 3,
"DELETING": 4,
}
func (x Disk_Status) String() string {
return proto.EnumName(Disk_Status_name, int32(x))
}
func (Disk_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_disk_d27a2bc800477bf5, []int{0, 0}
}
// A Disk resource. For more information, see [Disks](/docs/compute/concepts/disk).
type Disk struct {
// ID of the disk.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the disk belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Name of the disk. 1-63 characters long.
Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
// Description of the disk. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
// Resource labels as `` key:value `` pairs. Maximum of 64 per resource.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// ID of the disk type.
TypeId string `protobuf:"bytes,7,opt,name=type_id,json=typeId,proto3" json:"type_id,omitempty"`
// ID of the availability zone where the disk resides.
ZoneId string `protobuf:"bytes,8,opt,name=zone_id,json=zoneId,proto3" json:"zone_id,omitempty"`
// Size of the disk, specified in bytes.
Size int64 `protobuf:"varint,9,opt,name=size,proto3" json:"size,omitempty"`
// License IDs that indicate which licenses are attached to this resource.
// License IDs are used to calculate additional charges for the use of the virtual machine.
//
// The correct license ID is generated by Yandex.Cloud. IDs are inherited by new resources created from this resource.
//
// If you know the license IDs, specify them when you create the image.
// For example, if you create a disk image using a third-party utility and load it into Yandex Object Storage, the license IDs will be lost.
// You can specify them in the [yandex.cloud.compute.v1.ImageService.Create] request.
ProductIds []string `protobuf:"bytes,10,rep,name=product_ids,json=productIds,proto3" json:"product_ids,omitempty"`
// Current status of the disk.
Status Disk_Status `protobuf:"varint,11,opt,name=status,proto3,enum=yandex.cloud.compute.v1.Disk_Status" json:"status,omitempty"`
// Types that are valid to be assigned to Source:
// *Disk_SourceImageId
// *Disk_SourceSnapshotId
Source isDisk_Source `protobuf_oneof:"source"`
// Array of instances to which the disk is attached.
InstanceIds []string `protobuf:"bytes,14,rep,name=instance_ids,json=instanceIds,proto3" json:"instance_ids,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Disk) Reset() { *m = Disk{} }
func (m *Disk) String() string { return proto.CompactTextString(m) }
func (*Disk) ProtoMessage() {}
func (*Disk) Descriptor() ([]byte, []int) {
return fileDescriptor_disk_d27a2bc800477bf5, []int{0}
}
func (m *Disk) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Disk.Unmarshal(m, b)
}
func (m *Disk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Disk.Marshal(b, m, deterministic)
}
func (dst *Disk) XXX_Merge(src proto.Message) {
xxx_messageInfo_Disk.Merge(dst, src)
}
func (m *Disk) XXX_Size() int {
return xxx_messageInfo_Disk.Size(m)
}
func (m *Disk) XXX_DiscardUnknown() {
xxx_messageInfo_Disk.DiscardUnknown(m)
}
var xxx_messageInfo_Disk proto.InternalMessageInfo
func (m *Disk) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Disk) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Disk) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Disk) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Disk) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Disk) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *Disk) GetTypeId() string {
if m != nil {
return m.TypeId
}
return ""
}
func (m *Disk) GetZoneId() string {
if m != nil {
return m.ZoneId
}
return ""
}
func (m *Disk) GetSize() int64 {
if m != nil {
return m.Size
}
return 0
}
func (m *Disk) GetProductIds() []string {
if m != nil {
return m.ProductIds
}
return nil
}
func (m *Disk) GetStatus() Disk_Status {
if m != nil {
return m.Status
}
return Disk_STATUS_UNSPECIFIED
}
type isDisk_Source interface {
isDisk_Source()
}
type Disk_SourceImageId struct {
SourceImageId string `protobuf:"bytes,12,opt,name=source_image_id,json=sourceImageId,proto3,oneof"`
}
type Disk_SourceSnapshotId struct {
SourceSnapshotId string `protobuf:"bytes,13,opt,name=source_snapshot_id,json=sourceSnapshotId,proto3,oneof"`
}
func (*Disk_SourceImageId) isDisk_Source() {}
func (*Disk_SourceSnapshotId) isDisk_Source() {}
func (m *Disk) GetSource() isDisk_Source {
if m != nil {
return m.Source
}
return nil
}
func (m *Disk) GetSourceImageId() string {
if x, ok := m.GetSource().(*Disk_SourceImageId); ok {
return x.SourceImageId
}
return ""
}
func (m *Disk) GetSourceSnapshotId() string {
if x, ok := m.GetSource().(*Disk_SourceSnapshotId); ok {
return x.SourceSnapshotId
}
return ""
}
func (m *Disk) GetInstanceIds() []string {
if m != nil {
return m.InstanceIds
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*Disk) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _Disk_OneofMarshaler, _Disk_OneofUnmarshaler, _Disk_OneofSizer, []interface{}{
(*Disk_SourceImageId)(nil),
(*Disk_SourceSnapshotId)(nil),
}
}
func _Disk_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Disk)
// source
switch x := m.Source.(type) {
case *Disk_SourceImageId:
b.EncodeVarint(12<<3 | proto.WireBytes)
b.EncodeStringBytes(x.SourceImageId)
case *Disk_SourceSnapshotId:
b.EncodeVarint(13<<3 | proto.WireBytes)
b.EncodeStringBytes(x.SourceSnapshotId)
case nil:
default:
return fmt.Errorf("Disk.Source has unexpected type %T", x)
}
return nil
}
func _Disk_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Disk)
switch tag {
case 12: // source.source_image_id
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Source = &Disk_SourceImageId{x}
return true, err
case 13: // source.source_snapshot_id
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Source = &Disk_SourceSnapshotId{x}
return true, err
default:
return false, nil
}
}
func _Disk_OneofSizer(msg proto.Message) (n int) {
m := msg.(*Disk)
// source
switch x := m.Source.(type) {
case *Disk_SourceImageId:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.SourceImageId)))
n += len(x.SourceImageId)
case *Disk_SourceSnapshotId:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.SourceSnapshotId)))
n += len(x.SourceSnapshotId)
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
func init() {
proto.RegisterType((*Disk)(nil), "yandex.cloud.compute.v1.Disk")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.compute.v1.Disk.LabelsEntry")
proto.RegisterEnum("yandex.cloud.compute.v1.Disk_Status", Disk_Status_name, Disk_Status_value)
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/disk.proto", fileDescriptor_disk_d27a2bc800477bf5)
}
var fileDescriptor_disk_d27a2bc800477bf5 = []byte{
// 533 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0x41, 0x4f, 0xdb, 0x3e,
0x18, 0xc6, 0x49, 0xd3, 0x86, 0xe6, 0x0d, 0xf0, 0x8f, 0xac, 0xbf, 0x46, 0xc4, 0x0e, 0x64, 0x68,
0x87, 0xec, 0x40, 0x22, 0xd8, 0x65, 0x6c, 0xbb, 0x14, 0x9a, 0x6d, 0x91, 0x10, 0x9b, 0xdc, 0x72,
0xd8, 0x2e, 0x55, 0x1a, 0x9b, 0x60, 0x35, 0x8d, 0xa3, 0xd8, 0xa9, 0x56, 0x3e, 0xce, 0x3e, 0xe9,
0x64, 0x3b, 0x95, 0xb8, 0xb0, 0xdb, 0xeb, 0xe7, 0xf9, 0xd9, 0xef, 0xf3, 0x5a, 0x36, 0x9c, 0x6d,
0xf3, 0x9a, 0xd0, 0xdf, 0x49, 0x51, 0xf1, 0x8e, 0x24, 0x05, 0x5f, 0x37, 0x9d, 0xa4, 0xc9, 0xe6,
0x22, 0x21, 0x4c, 0xac, 0xe2, 0xa6, 0xe5, 0x92, 0xa3, 0x63, 0xc3, 0xc4, 0x9a, 0x89, 0x7b, 0x26,
0xde, 0x5c, 0x9c, 0x9c, 0x96, 0x9c, 0x97, 0x15, 0x4d, 0x34, 0xb6, 0xec, 0x1e, 0x12, 0xc9, 0xd6,
0x54, 0xc8, 0x7c, 0xdd, 0x98, 0x9d, 0x67, 0x7f, 0x46, 0x30, 0x9c, 0x32, 0xb1, 0x42, 0x47, 0x30,
0x60, 0x24, 0xb0, 0x42, 0x2b, 0x72, 0xf1, 0x80, 0x11, 0xf4, 0x1a, 0xdc, 0x07, 0x5e, 0x11, 0xda,
0x2e, 0x18, 0x09, 0x06, 0x5a, 0x1e, 0x1b, 0x21, 0x23, 0xe8, 0x0a, 0xa0, 0x68, 0x69, 0x2e, 0x29,
0x59, 0xe4, 0x32, 0xb0, 0x43, 0x2b, 0xf2, 0x2e, 0x4f, 0x62, 0xd3, 0x2b, 0xde, 0xf5, 0x8a, 0xe7,
0xbb, 0x5e, 0xd8, 0xed, 0xe9, 0x89, 0x44, 0x08, 0x86, 0x75, 0xbe, 0xa6, 0xc1, 0x50, 0x1f, 0xa9,
0x6b, 0x14, 0x82, 0x47, 0xa8, 0x28, 0x5a, 0xd6, 0x48, 0xc6, 0xeb, 0x60, 0xa4, 0xad, 0xe7, 0x12,
0x9a, 0x80, 0x53, 0xe5, 0x4b, 0x5a, 0x89, 0xc0, 0x09, 0xed, 0xc8, 0xbb, 0x7c, 0x17, 0xbf, 0x30,
0x71, 0xac, 0x86, 0x89, 0x6f, 0x35, 0x9b, 0xd6, 0xb2, 0xdd, 0xe2, 0x7e, 0x23, 0x3a, 0x86, 0x7d,
0xb9, 0x6d, 0xa8, 0x1a, 0x67, 0x5f, 0x37, 0x70, 0xd4, 0x32, 0x23, 0xca, 0x78, 0xe2, 0xb5, 0x36,
0xc6, 0xc6, 0x50, 0xcb, 0x8c, 0xa8, 0xa8, 0x82, 0x3d, 0xd1, 0xc0, 0x0d, 0xad, 0xc8, 0xc6, 0xba,
0x46, 0xa7, 0xe0, 0x35, 0x2d, 0x27, 0x5d, 0x21, 0x17, 0x8c, 0x88, 0x00, 0x42, 0x3b, 0x72, 0x31,
0xf4, 0x52, 0x46, 0x04, 0xfa, 0x0c, 0x8e, 0x90, 0xb9, 0xec, 0x44, 0xe0, 0x85, 0x56, 0x74, 0x74,
0xf9, 0xf6, 0xdf, 0x49, 0x67, 0x9a, 0xc5, 0xfd, 0x1e, 0x14, 0xc1, 0x7f, 0x82, 0x77, 0x6d, 0x41,
0x17, 0x6c, 0x9d, 0x97, 0x3a, 0xd3, 0x81, 0xca, 0xf4, 0x6d, 0x0f, 0x1f, 0x1a, 0x23, 0x53, 0x7a,
0x46, 0x50, 0x0c, 0xa8, 0x27, 0x45, 0x9d, 0x37, 0xe2, 0x91, 0xab, 0x40, 0xc1, 0x61, 0x0f, 0xfb,
0xc6, 0x9b, 0xf5, 0x56, 0x46, 0xd0, 0x1b, 0x38, 0x60, 0xb5, 0x90, 0x79, 0xad, 0xce, 0x26, 0x22,
0x38, 0xd2, 0xc9, 0xbd, 0x9d, 0x96, 0x11, 0x71, 0x72, 0x05, 0xde, 0xb3, 0x8b, 0x43, 0x3e, 0xd8,
0x2b, 0xba, 0xed, 0x9f, 0x84, 0x2a, 0xd1, 0xff, 0x30, 0xda, 0xe4, 0x55, 0x47, 0xfb, 0xf7, 0x60,
0x16, 0x1f, 0x07, 0x1f, 0xac, 0x33, 0x0c, 0x8e, 0x99, 0x04, 0xbd, 0x02, 0x34, 0x9b, 0x4f, 0xe6,
0xf7, 0xb3, 0xc5, 0xfd, 0xdd, 0xec, 0x47, 0x7a, 0x93, 0x7d, 0xc9, 0xd2, 0xa9, 0xbf, 0x87, 0x0e,
0x60, 0x7c, 0x83, 0xd3, 0xc9, 0x3c, 0xbb, 0xfb, 0xea, 0x5b, 0xc8, 0x85, 0x11, 0x4e, 0x27, 0xd3,
0x9f, 0xfe, 0x40, 0x95, 0x29, 0xc6, 0xdf, 0xb1, 0x6f, 0x2b, 0x66, 0x9a, 0xde, 0xa6, 0x9a, 0x19,
0x5e, 0x8f, 0xc1, 0x31, 0x53, 0x5c, 0xa7, 0xbf, 0x6e, 0x4a, 0x26, 0x1f, 0xbb, 0xa5, 0xba, 0xbe,
0xc4, 0xdc, 0xe7, 0xb9, 0xf9, 0x0f, 0x25, 0x3f, 0x2f, 0x69, 0xad, 0x9f, 0x5c, 0xf2, 0xc2, 0x47,
0xf9, 0xd4, 0x97, 0x4b, 0x47, 0x63, 0xef, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x9d, 0xe9, 0x4b,
0xc4, 0x52, 0x03, 0x00, 0x00,
}

1118
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

100
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk_type.pb.go generated vendored Normal file
View File

@ -0,0 +1,100 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/disk_type.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type DiskType struct {
// ID of the disk type.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// Description of the disk type. 0-256 characters long.
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
// Array of availability zones where the disk type is available.
ZoneIds []string `protobuf:"bytes,3,rep,name=zone_ids,json=zoneIds,proto3" json:"zone_ids,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DiskType) Reset() { *m = DiskType{} }
func (m *DiskType) String() string { return proto.CompactTextString(m) }
func (*DiskType) ProtoMessage() {}
func (*DiskType) Descriptor() ([]byte, []int) {
return fileDescriptor_disk_type_5be272c1e4d4338f, []int{0}
}
func (m *DiskType) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DiskType.Unmarshal(m, b)
}
func (m *DiskType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DiskType.Marshal(b, m, deterministic)
}
func (dst *DiskType) XXX_Merge(src proto.Message) {
xxx_messageInfo_DiskType.Merge(dst, src)
}
func (m *DiskType) XXX_Size() int {
return xxx_messageInfo_DiskType.Size(m)
}
func (m *DiskType) XXX_DiscardUnknown() {
xxx_messageInfo_DiskType.DiscardUnknown(m)
}
var xxx_messageInfo_DiskType proto.InternalMessageInfo
func (m *DiskType) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *DiskType) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *DiskType) GetZoneIds() []string {
if m != nil {
return m.ZoneIds
}
return nil
}
func init() {
proto.RegisterType((*DiskType)(nil), "yandex.cloud.compute.v1.DiskType")
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/disk_type.proto", fileDescriptor_disk_type_5be272c1e4d4338f)
}
var fileDescriptor_disk_type_5be272c1e4d4338f = []byte{
// 190 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xaf, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0x4f, 0xce, 0xcf, 0x2d, 0x28, 0x2d, 0x49,
0xd5, 0x2f, 0x33, 0xd4, 0x4f, 0xc9, 0x2c, 0xce, 0x8e, 0x2f, 0xa9, 0x2c, 0x48, 0xd5, 0x2b, 0x28,
0xca, 0x2f, 0xc9, 0x17, 0x12, 0x87, 0x28, 0xd4, 0x03, 0x2b, 0xd4, 0x83, 0x2a, 0xd4, 0x2b, 0x33,
0x54, 0x0a, 0xe7, 0xe2, 0x70, 0xc9, 0x2c, 0xce, 0x0e, 0xa9, 0x2c, 0x48, 0x15, 0xe2, 0xe3, 0x62,
0xca, 0x4c, 0x91, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0x62, 0xca, 0x4c, 0x11, 0x52, 0xe0, 0xe2,
0x4e, 0x49, 0x2d, 0x4e, 0x2e, 0xca, 0x2c, 0x28, 0xc9, 0xcc, 0xcf, 0x93, 0x60, 0x02, 0x4b, 0x20,
0x0b, 0x09, 0x49, 0x72, 0x71, 0x54, 0xe5, 0xe7, 0xa5, 0xc6, 0x67, 0xa6, 0x14, 0x4b, 0x30, 0x2b,
0x30, 0x6b, 0x70, 0x06, 0xb1, 0x83, 0xf8, 0x9e, 0x29, 0xc5, 0x4e, 0xae, 0x51, 0xce, 0xe9, 0x99,
0x25, 0x19, 0xa5, 0x49, 0x20, 0xdb, 0xf4, 0x21, 0xd6, 0xeb, 0x42, 0xdc, 0x99, 0x9e, 0xaf, 0x9b,
0x9e, 0x9a, 0x07, 0x76, 0x98, 0x3e, 0x0e, 0x0f, 0x58, 0x43, 0x99, 0x49, 0x6c, 0x60, 0x65, 0xc6,
0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x42, 0x85, 0x4f, 0x91, 0xea, 0x00, 0x00, 0x00,
}

325
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/disk_type_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,325 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/disk_type_service.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetDiskTypeRequest struct {
// ID of the disk type to return information about.
// To get the disk type ID use a [DiskTypeService.List] request.
DiskTypeId string `protobuf:"bytes,1,opt,name=disk_type_id,json=diskTypeId,proto3" json:"disk_type_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetDiskTypeRequest) Reset() { *m = GetDiskTypeRequest{} }
func (m *GetDiskTypeRequest) String() string { return proto.CompactTextString(m) }
func (*GetDiskTypeRequest) ProtoMessage() {}
func (*GetDiskTypeRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_disk_type_service_42656155dbce67c7, []int{0}
}
func (m *GetDiskTypeRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetDiskTypeRequest.Unmarshal(m, b)
}
func (m *GetDiskTypeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetDiskTypeRequest.Marshal(b, m, deterministic)
}
func (dst *GetDiskTypeRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetDiskTypeRequest.Merge(dst, src)
}
func (m *GetDiskTypeRequest) XXX_Size() int {
return xxx_messageInfo_GetDiskTypeRequest.Size(m)
}
func (m *GetDiskTypeRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetDiskTypeRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetDiskTypeRequest proto.InternalMessageInfo
func (m *GetDiskTypeRequest) GetDiskTypeId() string {
if m != nil {
return m.DiskTypeId
}
return ""
}
type ListDiskTypesRequest struct {
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListDiskTypesResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListDiskTypesResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListDiskTypesRequest) Reset() { *m = ListDiskTypesRequest{} }
func (m *ListDiskTypesRequest) String() string { return proto.CompactTextString(m) }
func (*ListDiskTypesRequest) ProtoMessage() {}
func (*ListDiskTypesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_disk_type_service_42656155dbce67c7, []int{1}
}
func (m *ListDiskTypesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListDiskTypesRequest.Unmarshal(m, b)
}
func (m *ListDiskTypesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListDiskTypesRequest.Marshal(b, m, deterministic)
}
func (dst *ListDiskTypesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListDiskTypesRequest.Merge(dst, src)
}
func (m *ListDiskTypesRequest) XXX_Size() int {
return xxx_messageInfo_ListDiskTypesRequest.Size(m)
}
func (m *ListDiskTypesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListDiskTypesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListDiskTypesRequest proto.InternalMessageInfo
func (m *ListDiskTypesRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListDiskTypesRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListDiskTypesResponse struct {
// List of disk types.
DiskTypes []*DiskType `protobuf:"bytes,1,rep,name=disk_types,json=diskTypes,proto3" json:"disk_types,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListDiskTypesRequest.page_size], use
// the [next_page_token] as the value
// for the [ListDiskTypesRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListDiskTypesResponse) Reset() { *m = ListDiskTypesResponse{} }
func (m *ListDiskTypesResponse) String() string { return proto.CompactTextString(m) }
func (*ListDiskTypesResponse) ProtoMessage() {}
func (*ListDiskTypesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_disk_type_service_42656155dbce67c7, []int{2}
}
func (m *ListDiskTypesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListDiskTypesResponse.Unmarshal(m, b)
}
func (m *ListDiskTypesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListDiskTypesResponse.Marshal(b, m, deterministic)
}
func (dst *ListDiskTypesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListDiskTypesResponse.Merge(dst, src)
}
func (m *ListDiskTypesResponse) XXX_Size() int {
return xxx_messageInfo_ListDiskTypesResponse.Size(m)
}
func (m *ListDiskTypesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListDiskTypesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListDiskTypesResponse proto.InternalMessageInfo
func (m *ListDiskTypesResponse) GetDiskTypes() []*DiskType {
if m != nil {
return m.DiskTypes
}
return nil
}
func (m *ListDiskTypesResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetDiskTypeRequest)(nil), "yandex.cloud.compute.v1.GetDiskTypeRequest")
proto.RegisterType((*ListDiskTypesRequest)(nil), "yandex.cloud.compute.v1.ListDiskTypesRequest")
proto.RegisterType((*ListDiskTypesResponse)(nil), "yandex.cloud.compute.v1.ListDiskTypesResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// DiskTypeServiceClient is the client API for DiskTypeService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DiskTypeServiceClient interface {
// Returns the information about specified disk type.
//
// To get the list of available disk types, make a [List] request.
Get(ctx context.Context, in *GetDiskTypeRequest, opts ...grpc.CallOption) (*DiskType, error)
// Retrieves the list of disk types for the specified folder.
List(ctx context.Context, in *ListDiskTypesRequest, opts ...grpc.CallOption) (*ListDiskTypesResponse, error)
}
type diskTypeServiceClient struct {
cc *grpc.ClientConn
}
func NewDiskTypeServiceClient(cc *grpc.ClientConn) DiskTypeServiceClient {
return &diskTypeServiceClient{cc}
}
func (c *diskTypeServiceClient) Get(ctx context.Context, in *GetDiskTypeRequest, opts ...grpc.CallOption) (*DiskType, error) {
out := new(DiskType)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.DiskTypeService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *diskTypeServiceClient) List(ctx context.Context, in *ListDiskTypesRequest, opts ...grpc.CallOption) (*ListDiskTypesResponse, error) {
out := new(ListDiskTypesResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.DiskTypeService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// DiskTypeServiceServer is the server API for DiskTypeService service.
type DiskTypeServiceServer interface {
// Returns the information about specified disk type.
//
// To get the list of available disk types, make a [List] request.
Get(context.Context, *GetDiskTypeRequest) (*DiskType, error)
// Retrieves the list of disk types for the specified folder.
List(context.Context, *ListDiskTypesRequest) (*ListDiskTypesResponse, error)
}
func RegisterDiskTypeServiceServer(s *grpc.Server, srv DiskTypeServiceServer) {
s.RegisterService(&_DiskTypeService_serviceDesc, srv)
}
func _DiskTypeService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetDiskTypeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DiskTypeServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.DiskTypeService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DiskTypeServiceServer).Get(ctx, req.(*GetDiskTypeRequest))
}
return interceptor(ctx, in, info, handler)
}
func _DiskTypeService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListDiskTypesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DiskTypeServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.DiskTypeService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DiskTypeServiceServer).List(ctx, req.(*ListDiskTypesRequest))
}
return interceptor(ctx, in, info, handler)
}
var _DiskTypeService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.compute.v1.DiskTypeService",
HandlerType: (*DiskTypeServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _DiskTypeService_Get_Handler,
},
{
MethodName: "List",
Handler: _DiskTypeService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/compute/v1/disk_type_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/disk_type_service.proto", fileDescriptor_disk_type_service_42656155dbce67c7)
}
var fileDescriptor_disk_type_service_42656155dbce67c7 = []byte{
// 427 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xcf, 0xaa, 0xd3, 0x40,
0x14, 0xc6, 0x49, 0x7b, 0xbd, 0x98, 0xa3, 0x72, 0x61, 0xf0, 0x72, 0x4b, 0xf0, 0xc2, 0x35, 0x48,
0x5b, 0xd0, 0x66, 0x9a, 0xba, 0xb4, 0x82, 0x54, 0xa5, 0x08, 0x2e, 0x24, 0xed, 0xca, 0x4d, 0x48,
0x9b, 0x43, 0x1c, 0x5a, 0x67, 0x62, 0x67, 0x12, 0xda, 0x8a, 0x0b, 0xff, 0xac, 0xdc, 0xba, 0xf7,
0x75, 0xea, 0xde, 0x57, 0x70, 0xe1, 0x33, 0xb8, 0x92, 0x4c, 0x92, 0xaa, 0xb5, 0xa1, 0x77, 0x17,
0x72, 0xbe, 0xef, 0x9c, 0xdf, 0x9c, 0x6f, 0x06, 0xe8, 0x2a, 0xe0, 0x21, 0x2e, 0xe9, 0x74, 0x2e,
0x92, 0x90, 0x4e, 0xc5, 0xeb, 0x38, 0x51, 0x48, 0x53, 0x97, 0x86, 0x4c, 0xce, 0x7c, 0xb5, 0x8a,
0xd1, 0x97, 0xb8, 0x48, 0xd9, 0x14, 0x9d, 0x78, 0x21, 0x94, 0x20, 0x67, 0xb9, 0xc1, 0xd1, 0x06,
0xa7, 0x30, 0x38, 0xa9, 0x6b, 0xdd, 0x8a, 0x84, 0x88, 0xe6, 0x48, 0x83, 0x98, 0xd1, 0x80, 0x73,
0xa1, 0x02, 0xc5, 0x04, 0x97, 0xb9, 0xcd, 0x6a, 0x1d, 0x9c, 0x53, 0x08, 0xcf, 0xff, 0x11, 0xa6,
0xc1, 0x9c, 0x85, 0xba, 0x51, 0x5e, 0xb6, 0xfb, 0x40, 0x86, 0xa8, 0x9e, 0x30, 0x39, 0x1b, 0xaf,
0x62, 0xf4, 0xf0, 0x4d, 0x82, 0x52, 0x91, 0x26, 0x5c, 0xff, 0xc3, 0xcb, 0xc2, 0x86, 0x71, 0x61,
0xb4, 0xcd, 0xc1, 0xd1, 0xcf, 0x8d, 0x6b, 0x78, 0x10, 0x16, 0xe2, 0x67, 0xa1, 0xcd, 0xe0, 0xe6,
0x73, 0x26, 0xb7, 0x76, 0x59, 0xfa, 0x5b, 0x60, 0xc6, 0x41, 0x84, 0xbe, 0x64, 0x6b, 0xd4, 0xe6,
0xfa, 0x00, 0x7e, 0x6d, 0xdc, 0xe3, 0xfe, 0x43, 0xb7, 0xdb, 0xed, 0x7a, 0x57, 0xb3, 0xe2, 0x88,
0xad, 0x91, 0xb4, 0x01, 0xb4, 0x50, 0x89, 0x19, 0xf2, 0x46, 0x4d, 0x8f, 0x31, 0x3f, 0x7f, 0x73,
0xaf, 0x68, 0xa5, 0xa7, 0xbb, 0x8c, 0xb3, 0x9a, 0xfd, 0xde, 0x80, 0xd3, 0x9d, 0x59, 0x32, 0x16,
0x5c, 0x22, 0x79, 0x04, 0xb0, 0x85, 0x95, 0x0d, 0xe3, 0xa2, 0xde, 0xbe, 0xd6, 0xbb, 0xed, 0x54,
0xac, 0xd5, 0xd9, 0x1e, 0xd5, 0x2c, 0xcf, 0x21, 0x49, 0x13, 0x4e, 0x38, 0x2e, 0x95, 0xbf, 0x8b,
0xe2, 0xdd, 0xc8, 0x7e, 0xbf, 0x28, 0x19, 0x7a, 0x5f, 0x6b, 0x70, 0x52, 0xfa, 0x47, 0x79, 0x8a,
0xe4, 0xa3, 0x01, 0xf5, 0x21, 0x2a, 0x72, 0xb7, 0x72, 0xe2, 0xff, 0xfb, 0xb5, 0x0e, 0xe3, 0xd9,
0xf7, 0x3e, 0x7c, 0xff, 0xf1, 0xa5, 0xd6, 0x24, 0x77, 0x76, 0xc3, 0xd5, 0xc8, 0xf4, 0xed, 0xdf,
0xf9, 0xbc, 0x23, 0x9f, 0x0c, 0x38, 0xca, 0xb6, 0x43, 0x3a, 0x95, 0x9d, 0xf7, 0x05, 0x65, 0x39,
0x97, 0x95, 0xe7, 0xbb, 0xb6, 0xcf, 0x35, 0xd5, 0x19, 0x39, 0xdd, 0x4b, 0x35, 0x78, 0xfa, 0xf2,
0x71, 0xc4, 0xd4, 0xab, 0x64, 0x92, 0x75, 0x2a, 0x9e, 0x42, 0x27, 0xbf, 0x79, 0x91, 0xe8, 0x44,
0xc8, 0xf5, 0xa5, 0xab, 0x7a, 0x23, 0x0f, 0x8a, 0xcf, 0xc9, 0xb1, 0x96, 0xdd, 0xff, 0x1d, 0x00,
0x00, 0xff, 0xff, 0xf1, 0x82, 0x37, 0x5b, 0x4d, 0x03, 0x00, 0x00,
}

324
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/image.pb.go generated vendored Normal file
View File

@ -0,0 +1,324 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/image.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type Image_Status int32
const (
Image_STATUS_UNSPECIFIED Image_Status = 0
// Image is being created.
Image_CREATING Image_Status = 1
// Image is ready to use.
Image_READY Image_Status = 2
// Image encountered a problem and cannot operate.
Image_ERROR Image_Status = 3
// Image is being deleted.
Image_DELETING Image_Status = 4
)
var Image_Status_name = map[int32]string{
0: "STATUS_UNSPECIFIED",
1: "CREATING",
2: "READY",
3: "ERROR",
4: "DELETING",
}
var Image_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
"CREATING": 1,
"READY": 2,
"ERROR": 3,
"DELETING": 4,
}
func (x Image_Status) String() string {
return proto.EnumName(Image_Status_name, int32(x))
}
func (Image_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_image_b90d09089d7c657a, []int{0, 0}
}
type Os_Type int32
const (
Os_TYPE_UNSPECIFIED Os_Type = 0
// Linux operating system.
Os_LINUX Os_Type = 1
// Windows operating system.
Os_WINDOWS Os_Type = 2
)
var Os_Type_name = map[int32]string{
0: "TYPE_UNSPECIFIED",
1: "LINUX",
2: "WINDOWS",
}
var Os_Type_value = map[string]int32{
"TYPE_UNSPECIFIED": 0,
"LINUX": 1,
"WINDOWS": 2,
}
func (x Os_Type) String() string {
return proto.EnumName(Os_Type_name, int32(x))
}
func (Os_Type) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_image_b90d09089d7c657a, []int{1, 0}
}
// An Image resource.
type Image struct {
// ID of the image.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the image belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Name of the image. 1-63 characters long.
Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
// Description of the image. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
// Resource labels as `` key:value `` pairs. Maximum of 64 per resource.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The name of the image family to which this image belongs.
//
// You can get the most recent image from a family by using
// the [yandex.cloud.compute.v1.ImageService.GetLatestByFamily] request
// and create the disk from this image.
Family string `protobuf:"bytes,7,opt,name=family,proto3" json:"family,omitempty"`
// The size of the image, specified in bytes.
StorageSize int64 `protobuf:"varint,8,opt,name=storage_size,json=storageSize,proto3" json:"storage_size,omitempty"`
// Minimum size of the disk which will be created from this image.
MinDiskSize int64 `protobuf:"varint,9,opt,name=min_disk_size,json=minDiskSize,proto3" json:"min_disk_size,omitempty"`
// License IDs that indicate which licenses are attached to this resource.
// License IDs are used to calculate additional charges for the use of the virtual machine.
//
// The correct license ID is generated by Yandex.Cloud. IDs are inherited by new resources created from this resource.
//
// If you know the license IDs, specify them when you create the image.
// For example, if you create a disk image using a third-party utility and load it into Yandex Object Storage, the license IDs will be lost.
// You can specify them in the [yandex.cloud.compute.v1.ImageService.Create] request.
ProductIds []string `protobuf:"bytes,10,rep,name=product_ids,json=productIds,proto3" json:"product_ids,omitempty"`
// Current status of the image.
Status Image_Status `protobuf:"varint,11,opt,name=status,proto3,enum=yandex.cloud.compute.v1.Image_Status" json:"status,omitempty"`
// Operating system that is contained in the image.
Os *Os `protobuf:"bytes,12,opt,name=os,proto3" json:"os,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Image) Reset() { *m = Image{} }
func (m *Image) String() string { return proto.CompactTextString(m) }
func (*Image) ProtoMessage() {}
func (*Image) Descriptor() ([]byte, []int) {
return fileDescriptor_image_b90d09089d7c657a, []int{0}
}
func (m *Image) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Image.Unmarshal(m, b)
}
func (m *Image) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Image.Marshal(b, m, deterministic)
}
func (dst *Image) XXX_Merge(src proto.Message) {
xxx_messageInfo_Image.Merge(dst, src)
}
func (m *Image) XXX_Size() int {
return xxx_messageInfo_Image.Size(m)
}
func (m *Image) XXX_DiscardUnknown() {
xxx_messageInfo_Image.DiscardUnknown(m)
}
var xxx_messageInfo_Image proto.InternalMessageInfo
func (m *Image) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Image) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Image) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Image) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Image) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Image) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *Image) GetFamily() string {
if m != nil {
return m.Family
}
return ""
}
func (m *Image) GetStorageSize() int64 {
if m != nil {
return m.StorageSize
}
return 0
}
func (m *Image) GetMinDiskSize() int64 {
if m != nil {
return m.MinDiskSize
}
return 0
}
func (m *Image) GetProductIds() []string {
if m != nil {
return m.ProductIds
}
return nil
}
func (m *Image) GetStatus() Image_Status {
if m != nil {
return m.Status
}
return Image_STATUS_UNSPECIFIED
}
func (m *Image) GetOs() *Os {
if m != nil {
return m.Os
}
return nil
}
type Os struct {
// Operating system type.
Type Os_Type `protobuf:"varint,1,opt,name=type,proto3,enum=yandex.cloud.compute.v1.Os_Type" json:"type,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Os) Reset() { *m = Os{} }
func (m *Os) String() string { return proto.CompactTextString(m) }
func (*Os) ProtoMessage() {}
func (*Os) Descriptor() ([]byte, []int) {
return fileDescriptor_image_b90d09089d7c657a, []int{1}
}
func (m *Os) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Os.Unmarshal(m, b)
}
func (m *Os) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Os.Marshal(b, m, deterministic)
}
func (dst *Os) XXX_Merge(src proto.Message) {
xxx_messageInfo_Os.Merge(dst, src)
}
func (m *Os) XXX_Size() int {
return xxx_messageInfo_Os.Size(m)
}
func (m *Os) XXX_DiscardUnknown() {
xxx_messageInfo_Os.DiscardUnknown(m)
}
var xxx_messageInfo_Os proto.InternalMessageInfo
func (m *Os) GetType() Os_Type {
if m != nil {
return m.Type
}
return Os_TYPE_UNSPECIFIED
}
func init() {
proto.RegisterType((*Image)(nil), "yandex.cloud.compute.v1.Image")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.compute.v1.Image.LabelsEntry")
proto.RegisterType((*Os)(nil), "yandex.cloud.compute.v1.Os")
proto.RegisterEnum("yandex.cloud.compute.v1.Image_Status", Image_Status_name, Image_Status_value)
proto.RegisterEnum("yandex.cloud.compute.v1.Os_Type", Os_Type_name, Os_Type_value)
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/image.proto", fileDescriptor_image_b90d09089d7c657a)
}
var fileDescriptor_image_b90d09089d7c657a = []byte{
// 555 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0xdf, 0x6b, 0x9c, 0x40,
0x10, 0xc7, 0xab, 0xf7, 0x23, 0x71, 0x4c, 0x83, 0x2c, 0x21, 0x95, 0xe4, 0x21, 0xf6, 0x4a, 0xe1,
0x68, 0x89, 0x92, 0x6b, 0x1e, 0x9a, 0x96, 0x3e, 0x5c, 0x72, 0xb6, 0x08, 0xe1, 0x2e, 0xec, 0x19,
0xd2, 0xf4, 0x45, 0xbc, 0xdb, 0x8d, 0x5d, 0xa2, 0xae, 0xb8, 0x6b, 0xa8, 0xf9, 0x7b, 0xfb, 0x87,
0x14, 0x57, 0x03, 0xa1, 0x70, 0xed, 0xdb, 0xcc, 0xd7, 0xcf, 0xcc, 0x77, 0x67, 0xd7, 0x81, 0x37,
0x75, 0x9c, 0x13, 0xfa, 0xcb, 0x5b, 0xa7, 0xbc, 0x22, 0xde, 0x9a, 0x67, 0x45, 0x25, 0xa9, 0xf7,
0x70, 0xe2, 0xb1, 0x2c, 0x4e, 0xa8, 0x5b, 0x94, 0x5c, 0x72, 0xf4, 0xaa, 0x85, 0x5c, 0x05, 0xb9,
0x1d, 0xe4, 0x3e, 0x9c, 0x1c, 0x1c, 0x25, 0x9c, 0x27, 0x29, 0xf5, 0x14, 0xb6, 0xaa, 0xee, 0x3c,
0xc9, 0x32, 0x2a, 0x64, 0x9c, 0x15, 0x6d, 0xe5, 0xe8, 0x77, 0x1f, 0x06, 0x41, 0xd3, 0x09, 0xed,
0x82, 0xce, 0x88, 0xad, 0x39, 0xda, 0xd8, 0xc0, 0x3a, 0x23, 0xe8, 0x10, 0x8c, 0x3b, 0x9e, 0x12,
0x5a, 0x46, 0x8c, 0xd8, 0xba, 0x92, 0xb7, 0x5b, 0x21, 0x20, 0xe8, 0x0c, 0x60, 0x5d, 0xd2, 0x58,
0x52, 0x12, 0xc5, 0xd2, 0xee, 0x39, 0xda, 0xd8, 0x9c, 0x1c, 0xb8, 0xad, 0x99, 0xfb, 0x64, 0xe6,
0x86, 0x4f, 0x66, 0xd8, 0xe8, 0xe8, 0xa9, 0x44, 0x08, 0xfa, 0x79, 0x9c, 0x51, 0xbb, 0xaf, 0x5a,
0xaa, 0x18, 0x39, 0x60, 0x12, 0x2a, 0xd6, 0x25, 0x2b, 0x24, 0xe3, 0xb9, 0x3d, 0x50, 0x9f, 0x9e,
0x4b, 0xe8, 0x1c, 0x86, 0x69, 0xbc, 0xa2, 0xa9, 0xb0, 0x87, 0x4e, 0x6f, 0x6c, 0x4e, 0xde, 0xb9,
0x1b, 0x46, 0x76, 0xd5, 0x34, 0xee, 0xa5, 0x82, 0xfd, 0x5c, 0x96, 0x35, 0xee, 0x2a, 0xd1, 0x3e,
0x0c, 0xef, 0xe2, 0x8c, 0xa5, 0xb5, 0xbd, 0xa5, 0x0c, 0xba, 0x0c, 0xbd, 0x86, 0x1d, 0x21, 0x79,
0x19, 0x27, 0x34, 0x12, 0xec, 0x91, 0xda, 0xdb, 0x8e, 0x36, 0xee, 0x61, 0xb3, 0xd3, 0x96, 0xec,
0x91, 0xa2, 0x11, 0xbc, 0xcc, 0x58, 0x1e, 0x11, 0x26, 0xee, 0x5b, 0xc6, 0x68, 0x99, 0x8c, 0xe5,
0x33, 0x26, 0xee, 0x15, 0x73, 0x04, 0x66, 0x51, 0x72, 0x52, 0xad, 0x65, 0xc4, 0x88, 0xb0, 0xc1,
0xe9, 0x8d, 0x0d, 0x0c, 0x9d, 0x14, 0x10, 0x81, 0xbe, 0xc0, 0x50, 0xc8, 0x58, 0x56, 0xc2, 0x36,
0x1d, 0x6d, 0xbc, 0x3b, 0x79, 0xfb, 0x9f, 0x19, 0x96, 0x0a, 0xc6, 0x5d, 0x11, 0x7a, 0x0f, 0x3a,
0x17, 0xf6, 0x8e, 0xba, 0xeb, 0xc3, 0x8d, 0xa5, 0x0b, 0x81, 0x75, 0x2e, 0x0e, 0xce, 0xc0, 0x7c,
0x76, 0x05, 0xc8, 0x82, 0xde, 0x3d, 0xad, 0xbb, 0xd7, 0x6d, 0x42, 0xb4, 0x07, 0x83, 0x87, 0x38,
0xad, 0x68, 0xf7, 0xb4, 0x6d, 0xf2, 0x49, 0xff, 0xa8, 0x8d, 0x30, 0x0c, 0x5b, 0x67, 0xb4, 0x0f,
0x68, 0x19, 0x4e, 0xc3, 0xeb, 0x65, 0x74, 0x3d, 0x5f, 0x5e, 0xf9, 0x17, 0xc1, 0xd7, 0xc0, 0x9f,
0x59, 0x2f, 0xd0, 0x0e, 0x6c, 0x5f, 0x60, 0x7f, 0x1a, 0x06, 0xf3, 0x6f, 0x96, 0x86, 0x0c, 0x18,
0x60, 0x7f, 0x3a, 0xbb, 0xb5, 0xf4, 0x26, 0xf4, 0x31, 0x5e, 0x60, 0xab, 0xd7, 0x30, 0x33, 0xff,
0xd2, 0x57, 0x4c, 0x7f, 0x54, 0x80, 0xbe, 0x10, 0xe8, 0x14, 0xfa, 0xb2, 0x2e, 0xa8, 0x3a, 0xc6,
0xee, 0xc4, 0xf9, 0xc7, 0x0c, 0x6e, 0x58, 0x17, 0x14, 0x2b, 0x7a, 0x74, 0x0a, 0xfd, 0x26, 0x43,
0x7b, 0x60, 0x85, 0xb7, 0x57, 0xfe, 0x5f, 0x67, 0x31, 0x60, 0x70, 0x19, 0xcc, 0xaf, 0xbf, 0x5b,
0x1a, 0x32, 0x61, 0xeb, 0x26, 0x98, 0xcf, 0x16, 0x37, 0x4b, 0x4b, 0x3f, 0xf7, 0x7f, 0x5c, 0x24,
0x4c, 0xfe, 0xac, 0x56, 0x4d, 0x63, 0xaf, 0x75, 0x3a, 0x6e, 0x97, 0x28, 0xe1, 0xc7, 0x09, 0xcd,
0xd5, 0x5f, 0xea, 0x6d, 0xd8, 0xae, 0xcf, 0x5d, 0xb8, 0x1a, 0x2a, 0xec, 0xc3, 0x9f, 0x00, 0x00,
0x00, 0xff, 0xff, 0xee, 0xdc, 0xf1, 0x6f, 0x87, 0x03, 0x00, 0x00,
}

1278
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/image_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

744
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/instance.pb.go generated vendored Normal file
View File

@ -0,0 +1,744 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/instance.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type IpVersion int32
const (
IpVersion_IP_VERSION_UNSPECIFIED IpVersion = 0
// IPv4 address, for example 192.0.2.235.
IpVersion_IPV4 IpVersion = 1
// IPv6 address: not available yet.
IpVersion_IPV6 IpVersion = 2
)
var IpVersion_name = map[int32]string{
0: "IP_VERSION_UNSPECIFIED",
1: "IPV4",
2: "IPV6",
}
var IpVersion_value = map[string]int32{
"IP_VERSION_UNSPECIFIED": 0,
"IPV4": 1,
"IPV6": 2,
}
func (x IpVersion) String() string {
return proto.EnumName(IpVersion_name, int32(x))
}
func (IpVersion) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_instance_9ed228c16f2b2625, []int{0}
}
type Instance_Status int32
const (
Instance_STATUS_UNSPECIFIED Instance_Status = 0
// Instance is waiting for resources to be allocated.
Instance_PROVISIONING Instance_Status = 1
// Instance is running normally.
Instance_RUNNING Instance_Status = 2
// Instance is being stopped.
Instance_STOPPING Instance_Status = 3
// Instance stopped.
Instance_STOPPED Instance_Status = 4
// Instance is being started.
Instance_STARTING Instance_Status = 5
// Instance is being restarted.
Instance_RESTARTING Instance_Status = 6
// Instance is being updated.
Instance_UPDATING Instance_Status = 7
// Instance encountered a problem and cannot operate.
Instance_ERROR Instance_Status = 8
// Instance crashed and will be restarted automatically.
Instance_CRASHED Instance_Status = 9
// Instance is being deleted.
Instance_DELETING Instance_Status = 10
)
var Instance_Status_name = map[int32]string{
0: "STATUS_UNSPECIFIED",
1: "PROVISIONING",
2: "RUNNING",
3: "STOPPING",
4: "STOPPED",
5: "STARTING",
6: "RESTARTING",
7: "UPDATING",
8: "ERROR",
9: "CRASHED",
10: "DELETING",
}
var Instance_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
"PROVISIONING": 1,
"RUNNING": 2,
"STOPPING": 3,
"STOPPED": 4,
"STARTING": 5,
"RESTARTING": 6,
"UPDATING": 7,
"ERROR": 8,
"CRASHED": 9,
"DELETING": 10,
}
func (x Instance_Status) String() string {
return proto.EnumName(Instance_Status_name, int32(x))
}
func (Instance_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_instance_9ed228c16f2b2625, []int{0, 0}
}
type AttachedDisk_Mode int32
const (
AttachedDisk_MODE_UNSPECIFIED AttachedDisk_Mode = 0
// Read-only access.
AttachedDisk_READ_ONLY AttachedDisk_Mode = 1
// Read/Write access.
AttachedDisk_READ_WRITE AttachedDisk_Mode = 2
)
var AttachedDisk_Mode_name = map[int32]string{
0: "MODE_UNSPECIFIED",
1: "READ_ONLY",
2: "READ_WRITE",
}
var AttachedDisk_Mode_value = map[string]int32{
"MODE_UNSPECIFIED": 0,
"READ_ONLY": 1,
"READ_WRITE": 2,
}
func (x AttachedDisk_Mode) String() string {
return proto.EnumName(AttachedDisk_Mode_name, int32(x))
}
func (AttachedDisk_Mode) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_instance_9ed228c16f2b2625, []int{2, 0}
}
// An Instance resource. For more information, see [Instances](/docs/compute/concepts/vm).
type Instance struct {
// ID of the instance.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the instance belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Name of the instance. 1-63 characters long.
Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
// Description of the instance. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
// Resource labels as `` key:value `` pairs. Maximum of 64 per resource.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// ID of the availability zone where the instance resides.
ZoneId string `protobuf:"bytes,7,opt,name=zone_id,json=zoneId,proto3" json:"zone_id,omitempty"`
// ID of the hardware platform configuration for the instance.
PlatformId string `protobuf:"bytes,8,opt,name=platform_id,json=platformId,proto3" json:"platform_id,omitempty"`
// Computing resources of the instance such as the amount of memory and number of cores.
Resources *Resources `protobuf:"bytes,9,opt,name=resources,proto3" json:"resources,omitempty"`
// Status of the instance.
Status Instance_Status `protobuf:"varint,10,opt,name=status,proto3,enum=yandex.cloud.compute.v1.Instance_Status" json:"status,omitempty"`
// The metadata key/value pairs assigned to this instance. This includes custom metadata and predefined keys.
//
// For example, you may use the metadata in order to provide your public SSH key to the instance.
// For more information, see [Metadata](/docs/compute/concepts/vm-metadata).
Metadata map[string]string `protobuf:"bytes,11,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Boot disk that is attached to the instance.
BootDisk *AttachedDisk `protobuf:"bytes,12,opt,name=boot_disk,json=bootDisk,proto3" json:"boot_disk,omitempty"`
// Array of secondary disks that are attached to the instance.
SecondaryDisks []*AttachedDisk `protobuf:"bytes,13,rep,name=secondary_disks,json=secondaryDisks,proto3" json:"secondary_disks,omitempty"`
// Array of network interfaces that are attached to the instance.
NetworkInterfaces []*NetworkInterface `protobuf:"bytes,14,rep,name=network_interfaces,json=networkInterfaces,proto3" json:"network_interfaces,omitempty"`
// A domain name of the instance. FQDN is defined by the server
// in the format `<hostname>.<region_id>.internal` when the instance is created.
// If the hostname were not specified when the instance was created, FQDN would be `<id>.auto.internal`.
Fqdn string `protobuf:"bytes,16,opt,name=fqdn,proto3" json:"fqdn,omitempty"`
// Scheduling policy configuration.
SchedulingPolicy *SchedulingPolicy `protobuf:"bytes,17,opt,name=scheduling_policy,json=schedulingPolicy,proto3" json:"scheduling_policy,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Instance) Reset() { *m = Instance{} }
func (m *Instance) String() string { return proto.CompactTextString(m) }
func (*Instance) ProtoMessage() {}
func (*Instance) Descriptor() ([]byte, []int) {
return fileDescriptor_instance_9ed228c16f2b2625, []int{0}
}
func (m *Instance) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Instance.Unmarshal(m, b)
}
func (m *Instance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Instance.Marshal(b, m, deterministic)
}
func (dst *Instance) XXX_Merge(src proto.Message) {
xxx_messageInfo_Instance.Merge(dst, src)
}
func (m *Instance) XXX_Size() int {
return xxx_messageInfo_Instance.Size(m)
}
func (m *Instance) XXX_DiscardUnknown() {
xxx_messageInfo_Instance.DiscardUnknown(m)
}
var xxx_messageInfo_Instance proto.InternalMessageInfo
func (m *Instance) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Instance) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Instance) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Instance) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Instance) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Instance) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *Instance) GetZoneId() string {
if m != nil {
return m.ZoneId
}
return ""
}
func (m *Instance) GetPlatformId() string {
if m != nil {
return m.PlatformId
}
return ""
}
func (m *Instance) GetResources() *Resources {
if m != nil {
return m.Resources
}
return nil
}
func (m *Instance) GetStatus() Instance_Status {
if m != nil {
return m.Status
}
return Instance_STATUS_UNSPECIFIED
}
func (m *Instance) GetMetadata() map[string]string {
if m != nil {
return m.Metadata
}
return nil
}
func (m *Instance) GetBootDisk() *AttachedDisk {
if m != nil {
return m.BootDisk
}
return nil
}
func (m *Instance) GetSecondaryDisks() []*AttachedDisk {
if m != nil {
return m.SecondaryDisks
}
return nil
}
func (m *Instance) GetNetworkInterfaces() []*NetworkInterface {
if m != nil {
return m.NetworkInterfaces
}
return nil
}
func (m *Instance) GetFqdn() string {
if m != nil {
return m.Fqdn
}
return ""
}
func (m *Instance) GetSchedulingPolicy() *SchedulingPolicy {
if m != nil {
return m.SchedulingPolicy
}
return nil
}
type Resources struct {
// The amount of memory available to the instance, specified in bytes.
Memory int64 `protobuf:"varint,1,opt,name=memory,proto3" json:"memory,omitempty"`
// The number of cores available to the instance.
Cores int64 `protobuf:"varint,2,opt,name=cores,proto3" json:"cores,omitempty"`
// Baseline level of CPU performance with the ability to burst performance above that baseline level.
// This field sets baseline performance for each core.
CoreFraction int64 `protobuf:"varint,3,opt,name=core_fraction,json=coreFraction,proto3" json:"core_fraction,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Resources) Reset() { *m = Resources{} }
func (m *Resources) String() string { return proto.CompactTextString(m) }
func (*Resources) ProtoMessage() {}
func (*Resources) Descriptor() ([]byte, []int) {
return fileDescriptor_instance_9ed228c16f2b2625, []int{1}
}
func (m *Resources) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Resources.Unmarshal(m, b)
}
func (m *Resources) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Resources.Marshal(b, m, deterministic)
}
func (dst *Resources) XXX_Merge(src proto.Message) {
xxx_messageInfo_Resources.Merge(dst, src)
}
func (m *Resources) XXX_Size() int {
return xxx_messageInfo_Resources.Size(m)
}
func (m *Resources) XXX_DiscardUnknown() {
xxx_messageInfo_Resources.DiscardUnknown(m)
}
var xxx_messageInfo_Resources proto.InternalMessageInfo
func (m *Resources) GetMemory() int64 {
if m != nil {
return m.Memory
}
return 0
}
func (m *Resources) GetCores() int64 {
if m != nil {
return m.Cores
}
return 0
}
func (m *Resources) GetCoreFraction() int64 {
if m != nil {
return m.CoreFraction
}
return 0
}
type AttachedDisk struct {
// Access mode to the Disk resource.
Mode AttachedDisk_Mode `protobuf:"varint,1,opt,name=mode,proto3,enum=yandex.cloud.compute.v1.AttachedDisk_Mode" json:"mode,omitempty"`
// Serial number that is reflected into the /dev/disk/by-id/ tree
// of a Linux operating system running within the instance.
//
// This value can be used to reference the device for mounting, resizing, and so on, from within the instance.
DeviceName string `protobuf:"bytes,2,opt,name=device_name,json=deviceName,proto3" json:"device_name,omitempty"`
// Specifies whether the disk will be auto-deleted when the instance is deleted.
AutoDelete bool `protobuf:"varint,3,opt,name=auto_delete,json=autoDelete,proto3" json:"auto_delete,omitempty"`
// ID of the disk that is attached to the instance.
DiskId string `protobuf:"bytes,4,opt,name=disk_id,json=diskId,proto3" json:"disk_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AttachedDisk) Reset() { *m = AttachedDisk{} }
func (m *AttachedDisk) String() string { return proto.CompactTextString(m) }
func (*AttachedDisk) ProtoMessage() {}
func (*AttachedDisk) Descriptor() ([]byte, []int) {
return fileDescriptor_instance_9ed228c16f2b2625, []int{2}
}
func (m *AttachedDisk) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AttachedDisk.Unmarshal(m, b)
}
func (m *AttachedDisk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AttachedDisk.Marshal(b, m, deterministic)
}
func (dst *AttachedDisk) XXX_Merge(src proto.Message) {
xxx_messageInfo_AttachedDisk.Merge(dst, src)
}
func (m *AttachedDisk) XXX_Size() int {
return xxx_messageInfo_AttachedDisk.Size(m)
}
func (m *AttachedDisk) XXX_DiscardUnknown() {
xxx_messageInfo_AttachedDisk.DiscardUnknown(m)
}
var xxx_messageInfo_AttachedDisk proto.InternalMessageInfo
func (m *AttachedDisk) GetMode() AttachedDisk_Mode {
if m != nil {
return m.Mode
}
return AttachedDisk_MODE_UNSPECIFIED
}
func (m *AttachedDisk) GetDeviceName() string {
if m != nil {
return m.DeviceName
}
return ""
}
func (m *AttachedDisk) GetAutoDelete() bool {
if m != nil {
return m.AutoDelete
}
return false
}
func (m *AttachedDisk) GetDiskId() string {
if m != nil {
return m.DiskId
}
return ""
}
type NetworkInterface struct {
// The index of the network interface, generated by the server, 0,1,2... etc.
// Currently only one network interface is supported per instance.
Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
// MAC address that is assigned to the network interface.
MacAddress string `protobuf:"bytes,2,opt,name=mac_address,json=macAddress,proto3" json:"mac_address,omitempty"`
// ID of the subnet.
SubnetId string `protobuf:"bytes,3,opt,name=subnet_id,json=subnetId,proto3" json:"subnet_id,omitempty"`
// Primary IPv4 address that is assigned to the instance for this network interface.
PrimaryV4Address *PrimaryAddress `protobuf:"bytes,4,opt,name=primary_v4_address,json=primaryV4Address,proto3" json:"primary_v4_address,omitempty"`
// Primary IPv6 address that is assigned to the instance for this network interface. IPv6 not available yet.
PrimaryV6Address *PrimaryAddress `protobuf:"bytes,5,opt,name=primary_v6_address,json=primaryV6Address,proto3" json:"primary_v6_address,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *NetworkInterface) Reset() { *m = NetworkInterface{} }
func (m *NetworkInterface) String() string { return proto.CompactTextString(m) }
func (*NetworkInterface) ProtoMessage() {}
func (*NetworkInterface) Descriptor() ([]byte, []int) {
return fileDescriptor_instance_9ed228c16f2b2625, []int{3}
}
func (m *NetworkInterface) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_NetworkInterface.Unmarshal(m, b)
}
func (m *NetworkInterface) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_NetworkInterface.Marshal(b, m, deterministic)
}
func (dst *NetworkInterface) XXX_Merge(src proto.Message) {
xxx_messageInfo_NetworkInterface.Merge(dst, src)
}
func (m *NetworkInterface) XXX_Size() int {
return xxx_messageInfo_NetworkInterface.Size(m)
}
func (m *NetworkInterface) XXX_DiscardUnknown() {
xxx_messageInfo_NetworkInterface.DiscardUnknown(m)
}
var xxx_messageInfo_NetworkInterface proto.InternalMessageInfo
func (m *NetworkInterface) GetIndex() string {
if m != nil {
return m.Index
}
return ""
}
func (m *NetworkInterface) GetMacAddress() string {
if m != nil {
return m.MacAddress
}
return ""
}
func (m *NetworkInterface) GetSubnetId() string {
if m != nil {
return m.SubnetId
}
return ""
}
func (m *NetworkInterface) GetPrimaryV4Address() *PrimaryAddress {
if m != nil {
return m.PrimaryV4Address
}
return nil
}
func (m *NetworkInterface) GetPrimaryV6Address() *PrimaryAddress {
if m != nil {
return m.PrimaryV6Address
}
return nil
}
type PrimaryAddress struct {
// An IPv4 internal network address that is assigned to the instance for this network interface.
Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
// One-to-one NAT configuration. If missing, NAT has not been set up.
OneToOneNat *OneToOneNat `protobuf:"bytes,2,opt,name=one_to_one_nat,json=oneToOneNat,proto3" json:"one_to_one_nat,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PrimaryAddress) Reset() { *m = PrimaryAddress{} }
func (m *PrimaryAddress) String() string { return proto.CompactTextString(m) }
func (*PrimaryAddress) ProtoMessage() {}
func (*PrimaryAddress) Descriptor() ([]byte, []int) {
return fileDescriptor_instance_9ed228c16f2b2625, []int{4}
}
func (m *PrimaryAddress) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PrimaryAddress.Unmarshal(m, b)
}
func (m *PrimaryAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PrimaryAddress.Marshal(b, m, deterministic)
}
func (dst *PrimaryAddress) XXX_Merge(src proto.Message) {
xxx_messageInfo_PrimaryAddress.Merge(dst, src)
}
func (m *PrimaryAddress) XXX_Size() int {
return xxx_messageInfo_PrimaryAddress.Size(m)
}
func (m *PrimaryAddress) XXX_DiscardUnknown() {
xxx_messageInfo_PrimaryAddress.DiscardUnknown(m)
}
var xxx_messageInfo_PrimaryAddress proto.InternalMessageInfo
func (m *PrimaryAddress) GetAddress() string {
if m != nil {
return m.Address
}
return ""
}
func (m *PrimaryAddress) GetOneToOneNat() *OneToOneNat {
if m != nil {
return m.OneToOneNat
}
return nil
}
type OneToOneNat struct {
// An external IP address associated with this instance.
Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
// IP version for the external IP address.
IpVersion IpVersion `protobuf:"varint,2,opt,name=ip_version,json=ipVersion,proto3,enum=yandex.cloud.compute.v1.IpVersion" json:"ip_version,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *OneToOneNat) Reset() { *m = OneToOneNat{} }
func (m *OneToOneNat) String() string { return proto.CompactTextString(m) }
func (*OneToOneNat) ProtoMessage() {}
func (*OneToOneNat) Descriptor() ([]byte, []int) {
return fileDescriptor_instance_9ed228c16f2b2625, []int{5}
}
func (m *OneToOneNat) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_OneToOneNat.Unmarshal(m, b)
}
func (m *OneToOneNat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_OneToOneNat.Marshal(b, m, deterministic)
}
func (dst *OneToOneNat) XXX_Merge(src proto.Message) {
xxx_messageInfo_OneToOneNat.Merge(dst, src)
}
func (m *OneToOneNat) XXX_Size() int {
return xxx_messageInfo_OneToOneNat.Size(m)
}
func (m *OneToOneNat) XXX_DiscardUnknown() {
xxx_messageInfo_OneToOneNat.DiscardUnknown(m)
}
var xxx_messageInfo_OneToOneNat proto.InternalMessageInfo
func (m *OneToOneNat) GetAddress() string {
if m != nil {
return m.Address
}
return ""
}
func (m *OneToOneNat) GetIpVersion() IpVersion {
if m != nil {
return m.IpVersion
}
return IpVersion_IP_VERSION_UNSPECIFIED
}
type SchedulingPolicy struct {
// Set if instance is preemptible.
Preemptible bool `protobuf:"varint,1,opt,name=preemptible,proto3" json:"preemptible,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SchedulingPolicy) Reset() { *m = SchedulingPolicy{} }
func (m *SchedulingPolicy) String() string { return proto.CompactTextString(m) }
func (*SchedulingPolicy) ProtoMessage() {}
func (*SchedulingPolicy) Descriptor() ([]byte, []int) {
return fileDescriptor_instance_9ed228c16f2b2625, []int{6}
}
func (m *SchedulingPolicy) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SchedulingPolicy.Unmarshal(m, b)
}
func (m *SchedulingPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SchedulingPolicy.Marshal(b, m, deterministic)
}
func (dst *SchedulingPolicy) XXX_Merge(src proto.Message) {
xxx_messageInfo_SchedulingPolicy.Merge(dst, src)
}
func (m *SchedulingPolicy) XXX_Size() int {
return xxx_messageInfo_SchedulingPolicy.Size(m)
}
func (m *SchedulingPolicy) XXX_DiscardUnknown() {
xxx_messageInfo_SchedulingPolicy.DiscardUnknown(m)
}
var xxx_messageInfo_SchedulingPolicy proto.InternalMessageInfo
func (m *SchedulingPolicy) GetPreemptible() bool {
if m != nil {
return m.Preemptible
}
return false
}
func init() {
proto.RegisterType((*Instance)(nil), "yandex.cloud.compute.v1.Instance")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.compute.v1.Instance.LabelsEntry")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.compute.v1.Instance.MetadataEntry")
proto.RegisterType((*Resources)(nil), "yandex.cloud.compute.v1.Resources")
proto.RegisterType((*AttachedDisk)(nil), "yandex.cloud.compute.v1.AttachedDisk")
proto.RegisterType((*NetworkInterface)(nil), "yandex.cloud.compute.v1.NetworkInterface")
proto.RegisterType((*PrimaryAddress)(nil), "yandex.cloud.compute.v1.PrimaryAddress")
proto.RegisterType((*OneToOneNat)(nil), "yandex.cloud.compute.v1.OneToOneNat")
proto.RegisterType((*SchedulingPolicy)(nil), "yandex.cloud.compute.v1.SchedulingPolicy")
proto.RegisterEnum("yandex.cloud.compute.v1.IpVersion", IpVersion_name, IpVersion_value)
proto.RegisterEnum("yandex.cloud.compute.v1.Instance_Status", Instance_Status_name, Instance_Status_value)
proto.RegisterEnum("yandex.cloud.compute.v1.AttachedDisk_Mode", AttachedDisk_Mode_name, AttachedDisk_Mode_value)
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/instance.proto", fileDescriptor_instance_9ed228c16f2b2625)
}
var fileDescriptor_instance_9ed228c16f2b2625 = []byte{
// 1058 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0x6d, 0x6f, 0xe3, 0x44,
0x10, 0x26, 0x2f, 0x4d, 0xe3, 0x49, 0x1b, 0xdc, 0xd5, 0xa9, 0x67, 0x95, 0x0f, 0xad, 0xc2, 0x5b,
0x39, 0xa9, 0x8e, 0xae, 0x54, 0x15, 0x47, 0x25, 0x74, 0xb9, 0xc6, 0x07, 0x16, 0x6d, 0x12, 0x6d,
0xd2, 0xf0, 0xf2, 0x01, 0x6b, 0xe3, 0xdd, 0xe4, 0x4c, 0x6d, 0xaf, 0xb1, 0xd7, 0x81, 0xf2, 0x3b,
0xf8, 0x19, 0xfc, 0x2e, 0xfe, 0x04, 0x5f, 0xd0, 0xee, 0xda, 0xb9, 0x5c, 0xa4, 0x70, 0x07, 0x9f,
0xb2, 0xf3, 0xcc, 0xcc, 0x33, 0x2f, 0x99, 0x9d, 0x35, 0x7c, 0xf2, 0x40, 0x62, 0xca, 0x7e, 0xeb,
0xfa, 0x21, 0xcf, 0x69, 0xd7, 0xe7, 0x51, 0x92, 0x0b, 0xd6, 0x5d, 0x3e, 0xed, 0x06, 0x71, 0x26,
0x48, 0xec, 0x33, 0x3b, 0x49, 0xb9, 0xe0, 0xe8, 0xb1, 0xb6, 0xb3, 0x95, 0x9d, 0x5d, 0xd8, 0xd9,
0xcb, 0xa7, 0x47, 0xc7, 0x0b, 0xce, 0x17, 0x21, 0xeb, 0x2a, 0xb3, 0x59, 0x3e, 0xef, 0x8a, 0x20,
0x62, 0x99, 0x20, 0x51, 0xa2, 0x3d, 0x3b, 0x7f, 0x37, 0xa1, 0xe9, 0x16, 0x64, 0xa8, 0x0d, 0xd5,
0x80, 0x5a, 0x95, 0x93, 0xca, 0xa9, 0x81, 0xab, 0x01, 0x45, 0x1f, 0x80, 0x31, 0xe7, 0x21, 0x65,
0xa9, 0x17, 0x50, 0xab, 0xaa, 0xe0, 0xa6, 0x06, 0x5c, 0x8a, 0x9e, 0x01, 0xf8, 0x29, 0x23, 0x82,
0x51, 0x8f, 0x08, 0xab, 0x76, 0x52, 0x39, 0x6d, 0x9d, 0x1f, 0xd9, 0x3a, 0x9e, 0x5d, 0xc6, 0xb3,
0x27, 0x65, 0x3c, 0x6c, 0x14, 0xd6, 0x3d, 0x81, 0x10, 0xd4, 0x63, 0x12, 0x31, 0xab, 0xae, 0x28,
0xd5, 0x19, 0x9d, 0x40, 0x8b, 0xb2, 0xcc, 0x4f, 0x83, 0x44, 0x04, 0x3c, 0xb6, 0x76, 0x94, 0x6a,
0x1d, 0x42, 0x0e, 0x34, 0x42, 0x32, 0x63, 0x61, 0x66, 0x35, 0x4e, 0x6a, 0xa7, 0xad, 0xf3, 0x33,
0x7b, 0x4b, 0xd5, 0x76, 0x59, 0x90, 0x7d, 0xa3, 0xec, 0x9d, 0x58, 0xa4, 0x0f, 0xb8, 0x70, 0x46,
0x8f, 0x61, 0xf7, 0x77, 0x1e, 0x33, 0x59, 0xd2, 0xae, 0x0a, 0xd2, 0x90, 0xa2, 0x4b, 0xd1, 0x31,
0xb4, 0x92, 0x90, 0x88, 0x39, 0x4f, 0x23, 0xa9, 0x6c, 0x2a, 0x25, 0x94, 0x90, 0x4b, 0xd1, 0x73,
0x30, 0x52, 0x96, 0xf1, 0x3c, 0xf5, 0x59, 0x66, 0x19, 0xaa, 0xe0, 0xce, 0xd6, 0x1c, 0x70, 0x69,
0x89, 0x5f, 0x3b, 0xa1, 0xe7, 0xd0, 0xc8, 0x04, 0x11, 0x79, 0x66, 0xc1, 0x49, 0xe5, 0xb4, 0x7d,
0x7e, 0xfa, 0xf6, 0x12, 0xc6, 0xca, 0x1e, 0x17, 0x7e, 0xe8, 0x5b, 0x68, 0x46, 0x4c, 0x10, 0x4a,
0x04, 0xb1, 0x5a, 0xaa, 0x0d, 0xdd, 0xb7, 0x73, 0xdc, 0x16, 0x1e, 0xba, 0x11, 0x2b, 0x02, 0xf4,
0x02, 0x8c, 0x19, 0xe7, 0xc2, 0xa3, 0x41, 0x76, 0x6f, 0xed, 0xa9, 0x82, 0x3e, 0xde, 0xca, 0xd6,
0x13, 0x82, 0xf8, 0xaf, 0x18, 0xed, 0x07, 0xd9, 0x3d, 0x6e, 0x4a, 0x3f, 0x79, 0x42, 0x03, 0x78,
0x3f, 0x63, 0x3e, 0x8f, 0x29, 0x49, 0x1f, 0x14, 0x51, 0x66, 0xed, 0xab, 0xbc, 0xde, 0x91, 0xa9,
0xbd, 0xf2, 0x96, 0x62, 0x86, 0xbe, 0x07, 0x14, 0x33, 0xf1, 0x2b, 0x4f, 0xef, 0xbd, 0x20, 0x16,
0x2c, 0x9d, 0x13, 0xd9, 0xed, 0xb6, 0xa2, 0xfc, 0x6c, 0x2b, 0xe5, 0x40, 0xbb, 0xb8, 0xa5, 0x07,
0x3e, 0x88, 0x37, 0x90, 0x4c, 0x4e, 0xdd, 0xfc, 0x17, 0x1a, 0x5b, 0xa6, 0x9e, 0x3a, 0x79, 0x46,
0x53, 0x38, 0xc8, 0x64, 0x2a, 0x79, 0x18, 0xc4, 0x0b, 0x2f, 0xe1, 0x61, 0xe0, 0x3f, 0x58, 0x07,
0xaa, 0x13, 0xdb, 0x83, 0x8d, 0x57, 0x1e, 0x23, 0xe5, 0x80, 0xcd, 0x6c, 0x03, 0x39, 0x7a, 0x06,
0xad, 0xb5, 0xd9, 0x43, 0x26, 0xd4, 0xee, 0xd9, 0x43, 0x71, 0xb3, 0xe4, 0x11, 0x3d, 0x82, 0x9d,
0x25, 0x09, 0x73, 0x56, 0x5c, 0x2b, 0x2d, 0x7c, 0x59, 0xfd, 0xa2, 0x72, 0x74, 0x05, 0xfb, 0x6f,
0xfc, 0x5f, 0xff, 0xc5, 0xb9, 0xf3, 0x67, 0x05, 0x1a, 0x7a, 0x62, 0xd0, 0x21, 0xa0, 0xf1, 0xa4,
0x37, 0xb9, 0x1b, 0x7b, 0x77, 0x83, 0xf1, 0xc8, 0xb9, 0x76, 0x5f, 0xba, 0x4e, 0xdf, 0x7c, 0x0f,
0x99, 0xb0, 0x37, 0xc2, 0xc3, 0xa9, 0x3b, 0x76, 0x87, 0x03, 0x77, 0xf0, 0xb5, 0x59, 0x41, 0x2d,
0xd8, 0xc5, 0x77, 0x03, 0x25, 0x54, 0xd1, 0x1e, 0x34, 0xc7, 0x93, 0xe1, 0x68, 0x24, 0xa5, 0x9a,
0x54, 0x29, 0xc9, 0xe9, 0x9b, 0x75, 0xad, 0xea, 0xe1, 0x89, 0x54, 0xed, 0xa0, 0x36, 0x00, 0x76,
0x56, 0x72, 0x43, 0x6a, 0xef, 0x46, 0xfd, 0x9e, 0x92, 0x76, 0x91, 0x01, 0x3b, 0x0e, 0xc6, 0x43,
0x6c, 0x36, 0x25, 0xc7, 0x35, 0xee, 0x8d, 0xbf, 0x71, 0xfa, 0xa6, 0x21, 0xad, 0xfa, 0xce, 0x8d,
0xa3, 0xac, 0xa0, 0xf3, 0x13, 0x18, 0xab, 0x7b, 0x82, 0x0e, 0xa1, 0x11, 0xb1, 0x88, 0xa7, 0xba,
0xd4, 0x1a, 0x2e, 0x24, 0x59, 0xad, 0xcf, 0x53, 0x96, 0xa9, 0x6a, 0x6b, 0x58, 0x0b, 0xe8, 0x43,
0xd8, 0x97, 0x07, 0x6f, 0x9e, 0x12, 0x5f, 0x6d, 0x8c, 0x9a, 0xd2, 0xee, 0x49, 0xf0, 0x65, 0x81,
0x75, 0xfe, 0xaa, 0xc0, 0xde, 0xfa, 0xb4, 0xa1, 0xaf, 0xa0, 0x1e, 0x71, 0xca, 0x54, 0x84, 0xf6,
0xf9, 0x93, 0x77, 0x1a, 0x51, 0xfb, 0x96, 0x53, 0x86, 0x95, 0x9f, 0xdc, 0x11, 0x94, 0x2d, 0x03,
0x9f, 0x79, 0x6a, 0x81, 0xe9, 0xfe, 0x83, 0x86, 0x06, 0x72, 0x8d, 0x1d, 0x43, 0x8b, 0xe4, 0x82,
0x7b, 0x94, 0x85, 0x4c, 0x30, 0x95, 0x54, 0x13, 0x83, 0x84, 0xfa, 0x0a, 0x91, 0xeb, 0x47, 0xde,
0x12, 0xb9, 0x61, 0xf4, 0xfa, 0x6b, 0x48, 0xd1, 0xa5, 0x9d, 0x2b, 0xa8, 0xcb, 0x40, 0xe8, 0x11,
0x98, 0xb7, 0xc3, 0xbe, 0xb3, 0xf1, 0xaf, 0xed, 0x83, 0x81, 0x9d, 0x5e, 0xdf, 0x1b, 0x0e, 0x6e,
0x7e, 0x30, 0x2b, 0xba, 0xf9, 0xbd, 0xbe, 0xf7, 0x1d, 0x76, 0x27, 0x8e, 0x59, 0xed, 0xfc, 0x51,
0x05, 0x73, 0xf3, 0x0e, 0xc8, 0xc6, 0x05, 0xb2, 0xbc, 0x62, 0x74, 0xb4, 0x20, 0x33, 0x8c, 0x88,
0xef, 0x11, 0x4a, 0x53, 0x96, 0x65, 0x65, 0x09, 0x11, 0xf1, 0x7b, 0x1a, 0x91, 0x5b, 0x3f, 0xcb,
0x67, 0x31, 0x13, 0x32, 0xc7, 0x9a, 0xde, 0xfa, 0x1a, 0x70, 0x29, 0xba, 0x03, 0x94, 0xa4, 0x41,
0x24, 0x2f, 0xfb, 0xf2, 0x62, 0x45, 0x52, 0x57, 0x37, 0xe6, 0xd3, 0xad, 0xed, 0x1c, 0x69, 0x97,
0x22, 0x02, 0x36, 0x0b, 0x8a, 0xe9, 0x45, 0x19, 0x73, 0x9d, 0xf6, 0x72, 0x45, 0xbb, 0xf3, 0x3f,
0x69, 0x2f, 0x0b, 0xa4, 0x93, 0x43, 0xfb, 0x4d, 0x1b, 0x64, 0xc1, 0x6e, 0xc9, 0xae, 0xbb, 0x52,
0x8a, 0xc8, 0x85, 0xb6, 0x7c, 0x16, 0x04, 0xf7, 0xe4, 0x4f, 0x4c, 0x84, 0x6a, 0x4d, 0xeb, 0xfc,
0xa3, 0xad, 0xe1, 0x87, 0x31, 0x9b, 0xf0, 0x61, 0xcc, 0x06, 0x44, 0xe0, 0x16, 0x7f, 0x2d, 0x74,
0x7e, 0x86, 0xd6, 0x9a, 0xee, 0x5f, 0x62, 0xf6, 0x00, 0x82, 0xc4, 0x5b, 0xb2, 0x34, 0x93, 0x13,
0x5c, 0x55, 0x43, 0xb9, 0xfd, 0x49, 0x71, 0x93, 0xa9, 0xb6, 0xc4, 0x46, 0x50, 0x1e, 0x3b, 0x17,
0x60, 0x6e, 0xee, 0x23, 0xf9, 0x96, 0x26, 0x29, 0x63, 0x51, 0x22, 0x82, 0x59, 0xa8, 0x87, 0xbd,
0x89, 0xd7, 0xa1, 0x27, 0x57, 0x60, 0xac, 0xd8, 0xd0, 0x11, 0x1c, 0xba, 0x23, 0x6f, 0xea, 0x60,
0xb9, 0x12, 0x36, 0xe6, 0xae, 0x09, 0x75, 0x77, 0x34, 0xbd, 0x30, 0x2b, 0xc5, 0xe9, 0xd2, 0xac,
0xbe, 0x70, 0x7e, 0xbc, 0x5e, 0x04, 0xe2, 0x55, 0x3e, 0x93, 0xc9, 0x75, 0x75, 0xb6, 0x67, 0xfa,
0x13, 0x65, 0xc1, 0xcf, 0x16, 0x2c, 0x56, 0xaf, 0x7f, 0x77, 0xcb, 0xb7, 0xcb, 0x55, 0x71, 0x9c,
0x35, 0x94, 0xd9, 0xe7, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0x78, 0x8d, 0xb6, 0x7a, 0xe5, 0x08,
0x00, 0x00,
}

2766
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/instance_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

238
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/snapshot.pb.go generated vendored Normal file
View File

@ -0,0 +1,238 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/snapshot.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type Snapshot_Status int32
const (
Snapshot_STATUS_UNSPECIFIED Snapshot_Status = 0
// Snapshot is being created.
Snapshot_CREATING Snapshot_Status = 1
// Snapshot is ready to use.
Snapshot_READY Snapshot_Status = 2
// Snapshot encountered a problem and cannot operate.
Snapshot_ERROR Snapshot_Status = 3
// Snapshot is being deleted.
Snapshot_DELETING Snapshot_Status = 4
)
var Snapshot_Status_name = map[int32]string{
0: "STATUS_UNSPECIFIED",
1: "CREATING",
2: "READY",
3: "ERROR",
4: "DELETING",
}
var Snapshot_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
"CREATING": 1,
"READY": 2,
"ERROR": 3,
"DELETING": 4,
}
func (x Snapshot_Status) String() string {
return proto.EnumName(Snapshot_Status_name, int32(x))
}
func (Snapshot_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_snapshot_3c7ca140728f66a5, []int{0, 0}
}
// A Snapshot resource. For more information, see [Snapshots](/docs/compute/concepts/snapshot).
type Snapshot struct {
// ID of the snapshot.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the snapshot belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Name of the snapshot. 1-63 characters long.
Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
// Description of the snapshot. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
// Resource labels as `` key:value `` pairs. Maximum of 64 per resource.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Size of the snapshot, specified in bytes.
StorageSize int64 `protobuf:"varint,7,opt,name=storage_size,json=storageSize,proto3" json:"storage_size,omitempty"`
// Size of the disk when the snapshot was created, specified in bytes.
DiskSize int64 `protobuf:"varint,8,opt,name=disk_size,json=diskSize,proto3" json:"disk_size,omitempty"`
// License IDs that indicate which licenses are attached to this resource.
// License IDs are used to calculate additional charges for the use of the virtual machine.
//
// The correct license ID is generated by Yandex.Cloud. IDs are inherited by new resources created from this resource.
//
// If you know the license IDs, specify them when you create the image.
// For example, if you create a disk image using a third-party utility and load it into Yandex Object Storage, the license IDs will be lost.
// You can specify them in the [yandex.cloud.compute.v1.ImageService.Create] request.
ProductIds []string `protobuf:"bytes,9,rep,name=product_ids,json=productIds,proto3" json:"product_ids,omitempty"`
// Current status of the snapshot.
Status Snapshot_Status `protobuf:"varint,10,opt,name=status,proto3,enum=yandex.cloud.compute.v1.Snapshot_Status" json:"status,omitempty"`
// ID of the source disk used to create this snapshot.
SourceDiskId string `protobuf:"bytes,11,opt,name=source_disk_id,json=sourceDiskId,proto3" json:"source_disk_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Snapshot) Reset() { *m = Snapshot{} }
func (m *Snapshot) String() string { return proto.CompactTextString(m) }
func (*Snapshot) ProtoMessage() {}
func (*Snapshot) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_3c7ca140728f66a5, []int{0}
}
func (m *Snapshot) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Snapshot.Unmarshal(m, b)
}
func (m *Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Snapshot.Marshal(b, m, deterministic)
}
func (dst *Snapshot) XXX_Merge(src proto.Message) {
xxx_messageInfo_Snapshot.Merge(dst, src)
}
func (m *Snapshot) XXX_Size() int {
return xxx_messageInfo_Snapshot.Size(m)
}
func (m *Snapshot) XXX_DiscardUnknown() {
xxx_messageInfo_Snapshot.DiscardUnknown(m)
}
var xxx_messageInfo_Snapshot proto.InternalMessageInfo
func (m *Snapshot) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Snapshot) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Snapshot) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Snapshot) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Snapshot) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Snapshot) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *Snapshot) GetStorageSize() int64 {
if m != nil {
return m.StorageSize
}
return 0
}
func (m *Snapshot) GetDiskSize() int64 {
if m != nil {
return m.DiskSize
}
return 0
}
func (m *Snapshot) GetProductIds() []string {
if m != nil {
return m.ProductIds
}
return nil
}
func (m *Snapshot) GetStatus() Snapshot_Status {
if m != nil {
return m.Status
}
return Snapshot_STATUS_UNSPECIFIED
}
func (m *Snapshot) GetSourceDiskId() string {
if m != nil {
return m.SourceDiskId
}
return ""
}
func init() {
proto.RegisterType((*Snapshot)(nil), "yandex.cloud.compute.v1.Snapshot")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.compute.v1.Snapshot.LabelsEntry")
proto.RegisterEnum("yandex.cloud.compute.v1.Snapshot_Status", Snapshot_Status_name, Snapshot_Status_value)
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/snapshot.proto", fileDescriptor_snapshot_3c7ca140728f66a5)
}
var fileDescriptor_snapshot_3c7ca140728f66a5 = []byte{
// 484 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0x41, 0x8f, 0x9b, 0x3e,
0x10, 0xc5, 0xff, 0x84, 0x24, 0xff, 0x30, 0x44, 0x11, 0xb2, 0xaa, 0x16, 0xa5, 0x87, 0xa5, 0xab,
0xaa, 0xe2, 0x12, 0xd0, 0xa6, 0x97, 0x6e, 0x7b, 0x69, 0x9a, 0xd0, 0x0a, 0x69, 0xb5, 0xad, 0x4c,
0xf6, 0xd0, 0x5e, 0x10, 0xc1, 0x5e, 0xd6, 0x0a, 0xc1, 0x08, 0x9b, 0xa8, 0xd9, 0x2f, 0xd8, 0xaf,
0x55, 0x61, 0x1c, 0x69, 0x2f, 0xab, 0xde, 0x86, 0x37, 0xbf, 0xf1, 0xf3, 0xc3, 0x03, 0xef, 0x4e,
0x59, 0x45, 0xe8, 0xef, 0x30, 0x2f, 0x79, 0x4b, 0xc2, 0x9c, 0x1f, 0xea, 0x56, 0xd2, 0xf0, 0x78,
0x15, 0x8a, 0x2a, 0xab, 0xc5, 0x03, 0x97, 0x41, 0xdd, 0x70, 0xc9, 0xd1, 0xab, 0x9e, 0x0b, 0x14,
0x17, 0x68, 0x2e, 0x38, 0x5e, 0xcd, 0x2f, 0x0a, 0xce, 0x8b, 0x92, 0x86, 0x0a, 0xdb, 0xb5, 0xf7,
0xa1, 0x64, 0x07, 0x2a, 0x64, 0x76, 0xa8, 0xfb, 0xc9, 0xcb, 0x3f, 0x43, 0x98, 0x24, 0xfa, 0x30,
0x34, 0x83, 0x01, 0x23, 0xae, 0xe1, 0x19, 0xbe, 0x85, 0x07, 0x8c, 0xa0, 0xd7, 0x60, 0xdd, 0xf3,
0x92, 0xd0, 0x26, 0x65, 0xc4, 0x1d, 0x28, 0x79, 0xd2, 0x0b, 0x31, 0x41, 0xd7, 0x00, 0x79, 0x43,
0x33, 0x49, 0x49, 0x9a, 0x49, 0xd7, 0xf4, 0x0c, 0xdf, 0x5e, 0xce, 0x83, 0xde, 0x2f, 0x38, 0xfb,
0x05, 0xdb, 0xb3, 0x1f, 0xb6, 0x34, 0xbd, 0x92, 0x08, 0xc1, 0xb0, 0xca, 0x0e, 0xd4, 0x1d, 0xaa,
0x23, 0x55, 0x8d, 0x3c, 0xb0, 0x09, 0x15, 0x79, 0xc3, 0x6a, 0xc9, 0x78, 0xe5, 0x8e, 0x54, 0xeb,
0xa9, 0x84, 0x22, 0x18, 0x97, 0xd9, 0x8e, 0x96, 0xc2, 0x1d, 0x7b, 0xa6, 0x6f, 0x2f, 0x17, 0xc1,
0x33, 0xa9, 0x83, 0x73, 0xa0, 0xe0, 0x46, 0xf1, 0x51, 0x25, 0x9b, 0x13, 0xd6, 0xc3, 0xe8, 0x0d,
0x4c, 0x85, 0xe4, 0x4d, 0x56, 0xd0, 0x54, 0xb0, 0x47, 0xea, 0xfe, 0xef, 0x19, 0xbe, 0x89, 0x6d,
0xad, 0x25, 0xec, 0x91, 0x76, 0xb9, 0x09, 0x13, 0xfb, 0xbe, 0x3f, 0x51, 0xfd, 0x49, 0x27, 0xa8,
0xe6, 0x05, 0xd8, 0x75, 0xc3, 0x49, 0x9b, 0xcb, 0x94, 0x11, 0xe1, 0x5a, 0x9e, 0xe9, 0x5b, 0x18,
0xb4, 0x14, 0x13, 0x81, 0x3e, 0xc3, 0x58, 0xc8, 0x4c, 0xb6, 0xc2, 0x05, 0xcf, 0xf0, 0x67, 0x4b,
0xff, 0xdf, 0xf7, 0x4c, 0x14, 0x8f, 0xf5, 0x1c, 0x7a, 0x0b, 0x33, 0xc1, 0xdb, 0x26, 0xa7, 0xa9,
0xba, 0x06, 0x23, 0xae, 0xad, 0x7e, 0xc7, 0xb4, 0x57, 0x37, 0x4c, 0xec, 0x63, 0x32, 0xbf, 0x06,
0xfb, 0x49, 0x3e, 0xe4, 0x80, 0xb9, 0xa7, 0x27, 0xfd, 0x7a, 0x5d, 0x89, 0x5e, 0xc0, 0xe8, 0x98,
0x95, 0x2d, 0xd5, 0x4f, 0xd7, 0x7f, 0x7c, 0x1c, 0x7c, 0x30, 0x2e, 0x31, 0x8c, 0x7b, 0x4b, 0xf4,
0x12, 0x50, 0xb2, 0x5d, 0x6d, 0xef, 0x92, 0xf4, 0xee, 0x36, 0xf9, 0x11, 0xad, 0xe3, 0xaf, 0x71,
0xb4, 0x71, 0xfe, 0x43, 0x53, 0x98, 0xac, 0x71, 0xb4, 0xda, 0xc6, 0xb7, 0xdf, 0x1c, 0x03, 0x59,
0x30, 0xc2, 0xd1, 0x6a, 0xf3, 0xd3, 0x19, 0x74, 0x65, 0x84, 0xf1, 0x77, 0xec, 0x98, 0x1d, 0xb3,
0x89, 0x6e, 0x22, 0xc5, 0x0c, 0xbf, 0x44, 0xbf, 0xd6, 0x05, 0x93, 0x0f, 0xed, 0xae, 0x4b, 0x18,
0xf6, 0x91, 0x17, 0xfd, 0xe2, 0x16, 0x7c, 0x51, 0xd0, 0x4a, 0xed, 0x44, 0xf8, 0xcc, 0x46, 0x7f,
0xd2, 0xe5, 0x6e, 0xac, 0xb0, 0xf7, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xf6, 0xec, 0x41, 0x99,
0xfb, 0x02, 0x00, 0x00,
}

976
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/snapshot_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,976 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/snapshot_service.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/api"
import operation "github.com/yandex-cloud/go-genproto/yandex/cloud/operation"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import field_mask "google.golang.org/genproto/protobuf/field_mask"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetSnapshotRequest struct {
// ID of the Snapshot resource to return.
// To get the snapshot ID, use a [SnapshotService.List] request.
SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetSnapshotRequest) Reset() { *m = GetSnapshotRequest{} }
func (m *GetSnapshotRequest) String() string { return proto.CompactTextString(m) }
func (*GetSnapshotRequest) ProtoMessage() {}
func (*GetSnapshotRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_150bb34e00a40392, []int{0}
}
func (m *GetSnapshotRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetSnapshotRequest.Unmarshal(m, b)
}
func (m *GetSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetSnapshotRequest.Marshal(b, m, deterministic)
}
func (dst *GetSnapshotRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetSnapshotRequest.Merge(dst, src)
}
func (m *GetSnapshotRequest) XXX_Size() int {
return xxx_messageInfo_GetSnapshotRequest.Size(m)
}
func (m *GetSnapshotRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetSnapshotRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetSnapshotRequest proto.InternalMessageInfo
func (m *GetSnapshotRequest) GetSnapshotId() string {
if m != nil {
return m.SnapshotId
}
return ""
}
type ListSnapshotsRequest struct {
// ID of the folder to list snapshots in.
// To get the folder ID, use a [yandex.cloud.resourcemanager.v1.FolderService.List] request.
FolderId string `protobuf:"bytes,1,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListSnapshotsResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListSnapshotsResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
// A filter expression that filters resources listed in the response.
// The expression must specify:
// 1. The field name. Currently you can use filtering only on the [Snapshot.name] field.
// 2. An operator. Can be either `=` or `!=` for single values, `IN` or `NOT IN` for lists of values.
// 3. The value. Мust be 3-63 characters long and match the regular expression `^[a-z]([-a-z0-9]{,61}[a-z0-9])?$`.
Filter string `protobuf:"bytes,4,opt,name=filter,proto3" json:"filter,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListSnapshotsRequest) Reset() { *m = ListSnapshotsRequest{} }
func (m *ListSnapshotsRequest) String() string { return proto.CompactTextString(m) }
func (*ListSnapshotsRequest) ProtoMessage() {}
func (*ListSnapshotsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_150bb34e00a40392, []int{1}
}
func (m *ListSnapshotsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListSnapshotsRequest.Unmarshal(m, b)
}
func (m *ListSnapshotsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListSnapshotsRequest.Marshal(b, m, deterministic)
}
func (dst *ListSnapshotsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListSnapshotsRequest.Merge(dst, src)
}
func (m *ListSnapshotsRequest) XXX_Size() int {
return xxx_messageInfo_ListSnapshotsRequest.Size(m)
}
func (m *ListSnapshotsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListSnapshotsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListSnapshotsRequest proto.InternalMessageInfo
func (m *ListSnapshotsRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *ListSnapshotsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListSnapshotsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
func (m *ListSnapshotsRequest) GetFilter() string {
if m != nil {
return m.Filter
}
return ""
}
type ListSnapshotsResponse struct {
// List of snapshots.
Snapshots []*Snapshot `protobuf:"bytes,1,rep,name=snapshots,proto3" json:"snapshots,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListSnapshotsRequest.page_size], use
// the [next_page_token] as the value
// for the [ListSnapshotsRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListSnapshotsResponse) Reset() { *m = ListSnapshotsResponse{} }
func (m *ListSnapshotsResponse) String() string { return proto.CompactTextString(m) }
func (*ListSnapshotsResponse) ProtoMessage() {}
func (*ListSnapshotsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_150bb34e00a40392, []int{2}
}
func (m *ListSnapshotsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListSnapshotsResponse.Unmarshal(m, b)
}
func (m *ListSnapshotsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListSnapshotsResponse.Marshal(b, m, deterministic)
}
func (dst *ListSnapshotsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListSnapshotsResponse.Merge(dst, src)
}
func (m *ListSnapshotsResponse) XXX_Size() int {
return xxx_messageInfo_ListSnapshotsResponse.Size(m)
}
func (m *ListSnapshotsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListSnapshotsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListSnapshotsResponse proto.InternalMessageInfo
func (m *ListSnapshotsResponse) GetSnapshots() []*Snapshot {
if m != nil {
return m.Snapshots
}
return nil
}
func (m *ListSnapshotsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type CreateSnapshotRequest struct {
// ID of the folder to create a snapshot in.
// To get the folder ID use a [yandex.cloud.resourcemanager.v1.FolderService.List] request.
FolderId string `protobuf:"bytes,1,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// ID of the disk to create the snapshot from.
// To get the disk ID use a [yandex.cloud.compute.v1.DiskService.List] request.
DiskId string `protobuf:"bytes,2,opt,name=disk_id,json=diskId,proto3" json:"disk_id,omitempty"`
// Name of the snapshot.
Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
// Description of the snapshot.
Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
// Resource labels as `` key:value `` pairs.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateSnapshotRequest) Reset() { *m = CreateSnapshotRequest{} }
func (m *CreateSnapshotRequest) String() string { return proto.CompactTextString(m) }
func (*CreateSnapshotRequest) ProtoMessage() {}
func (*CreateSnapshotRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_150bb34e00a40392, []int{3}
}
func (m *CreateSnapshotRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateSnapshotRequest.Unmarshal(m, b)
}
func (m *CreateSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateSnapshotRequest.Marshal(b, m, deterministic)
}
func (dst *CreateSnapshotRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateSnapshotRequest.Merge(dst, src)
}
func (m *CreateSnapshotRequest) XXX_Size() int {
return xxx_messageInfo_CreateSnapshotRequest.Size(m)
}
func (m *CreateSnapshotRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateSnapshotRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateSnapshotRequest proto.InternalMessageInfo
func (m *CreateSnapshotRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *CreateSnapshotRequest) GetDiskId() string {
if m != nil {
return m.DiskId
}
return ""
}
func (m *CreateSnapshotRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *CreateSnapshotRequest) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *CreateSnapshotRequest) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
type CreateSnapshotMetadata struct {
// ID of the snapshot that is being created.
SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
// ID of the source disk used to create this snapshot.
DiskId string `protobuf:"bytes,2,opt,name=disk_id,json=diskId,proto3" json:"disk_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateSnapshotMetadata) Reset() { *m = CreateSnapshotMetadata{} }
func (m *CreateSnapshotMetadata) String() string { return proto.CompactTextString(m) }
func (*CreateSnapshotMetadata) ProtoMessage() {}
func (*CreateSnapshotMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_150bb34e00a40392, []int{4}
}
func (m *CreateSnapshotMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateSnapshotMetadata.Unmarshal(m, b)
}
func (m *CreateSnapshotMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateSnapshotMetadata.Marshal(b, m, deterministic)
}
func (dst *CreateSnapshotMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateSnapshotMetadata.Merge(dst, src)
}
func (m *CreateSnapshotMetadata) XXX_Size() int {
return xxx_messageInfo_CreateSnapshotMetadata.Size(m)
}
func (m *CreateSnapshotMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_CreateSnapshotMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_CreateSnapshotMetadata proto.InternalMessageInfo
func (m *CreateSnapshotMetadata) GetSnapshotId() string {
if m != nil {
return m.SnapshotId
}
return ""
}
func (m *CreateSnapshotMetadata) GetDiskId() string {
if m != nil {
return m.DiskId
}
return ""
}
type UpdateSnapshotRequest struct {
// ID of the Snapshot resource to update.
// To get the snapshot ID use a [SnapshotService.List] request.
SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
// Field mask that specifies which fields of the Snapshot resource are going to be updated.
UpdateMask *field_mask.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
// Name of the snapshot.
Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
// Description of the snapshot.
Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
// Resource labels as `` key:value `` pairs.
//
// Existing set of `` labels `` is completely replaced by the provided set.
Labels map[string]string `protobuf:"bytes,5,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UpdateSnapshotRequest) Reset() { *m = UpdateSnapshotRequest{} }
func (m *UpdateSnapshotRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateSnapshotRequest) ProtoMessage() {}
func (*UpdateSnapshotRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_150bb34e00a40392, []int{5}
}
func (m *UpdateSnapshotRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateSnapshotRequest.Unmarshal(m, b)
}
func (m *UpdateSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UpdateSnapshotRequest.Marshal(b, m, deterministic)
}
func (dst *UpdateSnapshotRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_UpdateSnapshotRequest.Merge(dst, src)
}
func (m *UpdateSnapshotRequest) XXX_Size() int {
return xxx_messageInfo_UpdateSnapshotRequest.Size(m)
}
func (m *UpdateSnapshotRequest) XXX_DiscardUnknown() {
xxx_messageInfo_UpdateSnapshotRequest.DiscardUnknown(m)
}
var xxx_messageInfo_UpdateSnapshotRequest proto.InternalMessageInfo
func (m *UpdateSnapshotRequest) GetSnapshotId() string {
if m != nil {
return m.SnapshotId
}
return ""
}
func (m *UpdateSnapshotRequest) GetUpdateMask() *field_mask.FieldMask {
if m != nil {
return m.UpdateMask
}
return nil
}
func (m *UpdateSnapshotRequest) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *UpdateSnapshotRequest) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *UpdateSnapshotRequest) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
type UpdateSnapshotMetadata struct {
// ID of the Snapshot resource that is being updated.
SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UpdateSnapshotMetadata) Reset() { *m = UpdateSnapshotMetadata{} }
func (m *UpdateSnapshotMetadata) String() string { return proto.CompactTextString(m) }
func (*UpdateSnapshotMetadata) ProtoMessage() {}
func (*UpdateSnapshotMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_150bb34e00a40392, []int{6}
}
func (m *UpdateSnapshotMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateSnapshotMetadata.Unmarshal(m, b)
}
func (m *UpdateSnapshotMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UpdateSnapshotMetadata.Marshal(b, m, deterministic)
}
func (dst *UpdateSnapshotMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_UpdateSnapshotMetadata.Merge(dst, src)
}
func (m *UpdateSnapshotMetadata) XXX_Size() int {
return xxx_messageInfo_UpdateSnapshotMetadata.Size(m)
}
func (m *UpdateSnapshotMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_UpdateSnapshotMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_UpdateSnapshotMetadata proto.InternalMessageInfo
func (m *UpdateSnapshotMetadata) GetSnapshotId() string {
if m != nil {
return m.SnapshotId
}
return ""
}
type DeleteSnapshotRequest struct {
// ID of the snapshot to delete.
// To get the snapshot ID, use a [SnapshotService.List] request.
SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteSnapshotRequest) Reset() { *m = DeleteSnapshotRequest{} }
func (m *DeleteSnapshotRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteSnapshotRequest) ProtoMessage() {}
func (*DeleteSnapshotRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_150bb34e00a40392, []int{7}
}
func (m *DeleteSnapshotRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteSnapshotRequest.Unmarshal(m, b)
}
func (m *DeleteSnapshotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteSnapshotRequest.Marshal(b, m, deterministic)
}
func (dst *DeleteSnapshotRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteSnapshotRequest.Merge(dst, src)
}
func (m *DeleteSnapshotRequest) XXX_Size() int {
return xxx_messageInfo_DeleteSnapshotRequest.Size(m)
}
func (m *DeleteSnapshotRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteSnapshotRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteSnapshotRequest proto.InternalMessageInfo
func (m *DeleteSnapshotRequest) GetSnapshotId() string {
if m != nil {
return m.SnapshotId
}
return ""
}
type DeleteSnapshotMetadata struct {
// ID of the snapshot that is being deleted.
SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteSnapshotMetadata) Reset() { *m = DeleteSnapshotMetadata{} }
func (m *DeleteSnapshotMetadata) String() string { return proto.CompactTextString(m) }
func (*DeleteSnapshotMetadata) ProtoMessage() {}
func (*DeleteSnapshotMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_150bb34e00a40392, []int{8}
}
func (m *DeleteSnapshotMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteSnapshotMetadata.Unmarshal(m, b)
}
func (m *DeleteSnapshotMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteSnapshotMetadata.Marshal(b, m, deterministic)
}
func (dst *DeleteSnapshotMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteSnapshotMetadata.Merge(dst, src)
}
func (m *DeleteSnapshotMetadata) XXX_Size() int {
return xxx_messageInfo_DeleteSnapshotMetadata.Size(m)
}
func (m *DeleteSnapshotMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteSnapshotMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteSnapshotMetadata proto.InternalMessageInfo
func (m *DeleteSnapshotMetadata) GetSnapshotId() string {
if m != nil {
return m.SnapshotId
}
return ""
}
type ListSnapshotOperationsRequest struct {
// ID of the Snapshot resource to list operations for.
SnapshotId string `protobuf:"bytes,1,opt,name=snapshot_id,json=snapshotId,proto3" json:"snapshot_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size], the service returns a [ListSnapshotOperationsResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListSnapshotOperationsResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListSnapshotOperationsRequest) Reset() { *m = ListSnapshotOperationsRequest{} }
func (m *ListSnapshotOperationsRequest) String() string { return proto.CompactTextString(m) }
func (*ListSnapshotOperationsRequest) ProtoMessage() {}
func (*ListSnapshotOperationsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_150bb34e00a40392, []int{9}
}
func (m *ListSnapshotOperationsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListSnapshotOperationsRequest.Unmarshal(m, b)
}
func (m *ListSnapshotOperationsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListSnapshotOperationsRequest.Marshal(b, m, deterministic)
}
func (dst *ListSnapshotOperationsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListSnapshotOperationsRequest.Merge(dst, src)
}
func (m *ListSnapshotOperationsRequest) XXX_Size() int {
return xxx_messageInfo_ListSnapshotOperationsRequest.Size(m)
}
func (m *ListSnapshotOperationsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListSnapshotOperationsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListSnapshotOperationsRequest proto.InternalMessageInfo
func (m *ListSnapshotOperationsRequest) GetSnapshotId() string {
if m != nil {
return m.SnapshotId
}
return ""
}
func (m *ListSnapshotOperationsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListSnapshotOperationsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListSnapshotOperationsResponse struct {
// List of operations for the specified snapshot.
Operations []*operation.Operation `protobuf:"bytes,1,rep,name=operations,proto3" json:"operations,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListSnapshotOperationsRequest.page_size], use the [next_page_token] as the value
// for the [ListSnapshotOperationsRequest.page_token] query parameter in the next list request.
// Each subsequent list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListSnapshotOperationsResponse) Reset() { *m = ListSnapshotOperationsResponse{} }
func (m *ListSnapshotOperationsResponse) String() string { return proto.CompactTextString(m) }
func (*ListSnapshotOperationsResponse) ProtoMessage() {}
func (*ListSnapshotOperationsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_snapshot_service_150bb34e00a40392, []int{10}
}
func (m *ListSnapshotOperationsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListSnapshotOperationsResponse.Unmarshal(m, b)
}
func (m *ListSnapshotOperationsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListSnapshotOperationsResponse.Marshal(b, m, deterministic)
}
func (dst *ListSnapshotOperationsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListSnapshotOperationsResponse.Merge(dst, src)
}
func (m *ListSnapshotOperationsResponse) XXX_Size() int {
return xxx_messageInfo_ListSnapshotOperationsResponse.Size(m)
}
func (m *ListSnapshotOperationsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListSnapshotOperationsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListSnapshotOperationsResponse proto.InternalMessageInfo
func (m *ListSnapshotOperationsResponse) GetOperations() []*operation.Operation {
if m != nil {
return m.Operations
}
return nil
}
func (m *ListSnapshotOperationsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetSnapshotRequest)(nil), "yandex.cloud.compute.v1.GetSnapshotRequest")
proto.RegisterType((*ListSnapshotsRequest)(nil), "yandex.cloud.compute.v1.ListSnapshotsRequest")
proto.RegisterType((*ListSnapshotsResponse)(nil), "yandex.cloud.compute.v1.ListSnapshotsResponse")
proto.RegisterType((*CreateSnapshotRequest)(nil), "yandex.cloud.compute.v1.CreateSnapshotRequest")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.compute.v1.CreateSnapshotRequest.LabelsEntry")
proto.RegisterType((*CreateSnapshotMetadata)(nil), "yandex.cloud.compute.v1.CreateSnapshotMetadata")
proto.RegisterType((*UpdateSnapshotRequest)(nil), "yandex.cloud.compute.v1.UpdateSnapshotRequest")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.compute.v1.UpdateSnapshotRequest.LabelsEntry")
proto.RegisterType((*UpdateSnapshotMetadata)(nil), "yandex.cloud.compute.v1.UpdateSnapshotMetadata")
proto.RegisterType((*DeleteSnapshotRequest)(nil), "yandex.cloud.compute.v1.DeleteSnapshotRequest")
proto.RegisterType((*DeleteSnapshotMetadata)(nil), "yandex.cloud.compute.v1.DeleteSnapshotMetadata")
proto.RegisterType((*ListSnapshotOperationsRequest)(nil), "yandex.cloud.compute.v1.ListSnapshotOperationsRequest")
proto.RegisterType((*ListSnapshotOperationsResponse)(nil), "yandex.cloud.compute.v1.ListSnapshotOperationsResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// SnapshotServiceClient is the client API for SnapshotService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SnapshotServiceClient interface {
// Returns the specified Snapshot resource.
//
// To get the list of available Snapshot resources, make a [List] request.
Get(ctx context.Context, in *GetSnapshotRequest, opts ...grpc.CallOption) (*Snapshot, error)
// Retrieves the list of Snapshot resources in the specified folder.
List(ctx context.Context, in *ListSnapshotsRequest, opts ...grpc.CallOption) (*ListSnapshotsResponse, error)
// Creates a snapshot of the specified disk.
Create(ctx context.Context, in *CreateSnapshotRequest, opts ...grpc.CallOption) (*operation.Operation, error)
// Updates the specified snapshot.
//
// Values of omitted parameters are not changed.
Update(ctx context.Context, in *UpdateSnapshotRequest, opts ...grpc.CallOption) (*operation.Operation, error)
// Deletes the specified snapshot.
//
// Deleting a snapshot removes its data permanently and is irreversible.
Delete(ctx context.Context, in *DeleteSnapshotRequest, opts ...grpc.CallOption) (*operation.Operation, error)
// Lists operations for the specified snapshot.
ListOperations(ctx context.Context, in *ListSnapshotOperationsRequest, opts ...grpc.CallOption) (*ListSnapshotOperationsResponse, error)
}
type snapshotServiceClient struct {
cc *grpc.ClientConn
}
func NewSnapshotServiceClient(cc *grpc.ClientConn) SnapshotServiceClient {
return &snapshotServiceClient{cc}
}
func (c *snapshotServiceClient) Get(ctx context.Context, in *GetSnapshotRequest, opts ...grpc.CallOption) (*Snapshot, error) {
out := new(Snapshot)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.SnapshotService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *snapshotServiceClient) List(ctx context.Context, in *ListSnapshotsRequest, opts ...grpc.CallOption) (*ListSnapshotsResponse, error) {
out := new(ListSnapshotsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.SnapshotService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *snapshotServiceClient) Create(ctx context.Context, in *CreateSnapshotRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.SnapshotService/Create", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *snapshotServiceClient) Update(ctx context.Context, in *UpdateSnapshotRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.SnapshotService/Update", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *snapshotServiceClient) Delete(ctx context.Context, in *DeleteSnapshotRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.SnapshotService/Delete", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *snapshotServiceClient) ListOperations(ctx context.Context, in *ListSnapshotOperationsRequest, opts ...grpc.CallOption) (*ListSnapshotOperationsResponse, error) {
out := new(ListSnapshotOperationsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.SnapshotService/ListOperations", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// SnapshotServiceServer is the server API for SnapshotService service.
type SnapshotServiceServer interface {
// Returns the specified Snapshot resource.
//
// To get the list of available Snapshot resources, make a [List] request.
Get(context.Context, *GetSnapshotRequest) (*Snapshot, error)
// Retrieves the list of Snapshot resources in the specified folder.
List(context.Context, *ListSnapshotsRequest) (*ListSnapshotsResponse, error)
// Creates a snapshot of the specified disk.
Create(context.Context, *CreateSnapshotRequest) (*operation.Operation, error)
// Updates the specified snapshot.
//
// Values of omitted parameters are not changed.
Update(context.Context, *UpdateSnapshotRequest) (*operation.Operation, error)
// Deletes the specified snapshot.
//
// Deleting a snapshot removes its data permanently and is irreversible.
Delete(context.Context, *DeleteSnapshotRequest) (*operation.Operation, error)
// Lists operations for the specified snapshot.
ListOperations(context.Context, *ListSnapshotOperationsRequest) (*ListSnapshotOperationsResponse, error)
}
func RegisterSnapshotServiceServer(s *grpc.Server, srv SnapshotServiceServer) {
s.RegisterService(&_SnapshotService_serviceDesc, srv)
}
func _SnapshotService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetSnapshotRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SnapshotServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.SnapshotService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SnapshotServiceServer).Get(ctx, req.(*GetSnapshotRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SnapshotService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListSnapshotsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SnapshotServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.SnapshotService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SnapshotServiceServer).List(ctx, req.(*ListSnapshotsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SnapshotService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateSnapshotRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SnapshotServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.SnapshotService/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SnapshotServiceServer).Create(ctx, req.(*CreateSnapshotRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SnapshotService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UpdateSnapshotRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SnapshotServiceServer).Update(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.SnapshotService/Update",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SnapshotServiceServer).Update(ctx, req.(*UpdateSnapshotRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SnapshotService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteSnapshotRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SnapshotServiceServer).Delete(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.SnapshotService/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SnapshotServiceServer).Delete(ctx, req.(*DeleteSnapshotRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SnapshotService_ListOperations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListSnapshotOperationsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SnapshotServiceServer).ListOperations(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.SnapshotService/ListOperations",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SnapshotServiceServer).ListOperations(ctx, req.(*ListSnapshotOperationsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _SnapshotService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.compute.v1.SnapshotService",
HandlerType: (*SnapshotServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _SnapshotService_Get_Handler,
},
{
MethodName: "List",
Handler: _SnapshotService_List_Handler,
},
{
MethodName: "Create",
Handler: _SnapshotService_Create_Handler,
},
{
MethodName: "Update",
Handler: _SnapshotService_Update_Handler,
},
{
MethodName: "Delete",
Handler: _SnapshotService_Delete_Handler,
},
{
MethodName: "ListOperations",
Handler: _SnapshotService_ListOperations_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/compute/v1/snapshot_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/snapshot_service.proto", fileDescriptor_snapshot_service_150bb34e00a40392)
}
var fileDescriptor_snapshot_service_150bb34e00a40392 = []byte{
// 984 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0x41, 0x6f, 0xdc, 0x44,
0x14, 0xd6, 0x64, 0x13, 0x37, 0xfb, 0x16, 0x68, 0x35, 0xea, 0x36, 0x2b, 0x8b, 0x40, 0x6a, 0xd4,
0xb2, 0x6c, 0xb0, 0xbd, 0xde, 0x92, 0x85, 0xa4, 0xad, 0x2a, 0x12, 0x92, 0x2a, 0x52, 0x2b, 0x90,
0x53, 0x2e, 0x44, 0x65, 0x35, 0x89, 0x27, 0x5b, 0x6b, 0x1d, 0xdb, 0xec, 0x78, 0x57, 0x4d, 0x4a,
0x25, 0x14, 0x71, 0x0a, 0xc7, 0xde, 0x91, 0x10, 0xbf, 0x80, 0x9c, 0x8a, 0xf8, 0x01, 0xc9, 0xb9,
0xfc, 0x05, 0x0e, 0x5c, 0xe9, 0x91, 0x13, 0xf2, 0xcc, 0x78, 0xb3, 0x9b, 0xd8, 0x8d, 0x03, 0x08,
0x71, 0x1b, 0xfb, 0x7d, 0xef, 0xcd, 0x37, 0xef, 0xbd, 0xf9, 0xde, 0x80, 0xb1, 0x43, 0x7c, 0x87,
0x3e, 0x36, 0x37, 0xbd, 0xa0, 0xe7, 0x98, 0x9b, 0xc1, 0x76, 0xd8, 0x8b, 0xa8, 0xd9, 0xb7, 0x4c,
0xe6, 0x93, 0x90, 0x3d, 0x0a, 0xa2, 0x16, 0xa3, 0xdd, 0xbe, 0xbb, 0x49, 0x8d, 0xb0, 0x1b, 0x44,
0x01, 0x9e, 0x12, 0x78, 0x83, 0xe3, 0x0d, 0x89, 0x37, 0xfa, 0x96, 0xfa, 0x66, 0x3b, 0x08, 0xda,
0x1e, 0x35, 0x49, 0xe8, 0x9a, 0xc4, 0xf7, 0x83, 0x88, 0x44, 0x6e, 0xe0, 0x33, 0xe1, 0xa6, 0xce,
0x48, 0x2b, 0xff, 0xda, 0xe8, 0x6d, 0x99, 0x5b, 0x2e, 0xf5, 0x9c, 0xd6, 0x36, 0x61, 0x1d, 0x89,
0x50, 0x25, 0x91, 0xd8, 0x3f, 0x08, 0x69, 0x97, 0xbb, 0x4b, 0xdb, 0xf5, 0xb3, 0x48, 0xa6, 0xe2,
0x06, 0x51, 0x4e, 0xc5, 0x9b, 0x1e, 0xc1, 0xf5, 0x89, 0xe7, 0x3a, 0x43, 0x66, 0x6d, 0x09, 0xf0,
0x5d, 0x1a, 0xad, 0xc9, 0xd8, 0x36, 0xfd, 0xaa, 0x47, 0x59, 0x84, 0x75, 0x28, 0x0d, 0x72, 0xe2,
0x3a, 0x15, 0x34, 0x83, 0xaa, 0xc5, 0xc5, 0xd7, 0x7e, 0x3f, 0xb4, 0xd0, 0xfe, 0x91, 0x35, 0x7e,
0xeb, 0xf6, 0x5c, 0xdd, 0x86, 0x04, 0xb0, 0xea, 0x68, 0xcf, 0x11, 0x5c, 0xbe, 0xe7, 0xb2, 0x41,
0x18, 0x96, 0xc4, 0x79, 0x0f, 0x8a, 0x5b, 0x81, 0xe7, 0xd0, 0x6e, 0x56, 0x94, 0x49, 0x61, 0x5e,
0x75, 0xf0, 0xbb, 0x50, 0x0c, 0x49, 0x9b, 0xb6, 0x98, 0xbb, 0x4b, 0x2b, 0x63, 0x33, 0xa8, 0x5a,
0x58, 0x84, 0x3f, 0x0f, 0x2d, 0xe5, 0xd6, 0x6d, 0xab, 0x5e, 0xaf, 0xdb, 0x93, 0xb1, 0x71, 0xcd,
0xdd, 0xa5, 0xb8, 0x0a, 0xc0, 0x81, 0x51, 0xd0, 0xa1, 0x7e, 0xa5, 0xc0, 0x83, 0x16, 0xf7, 0x8f,
0xac, 0x09, 0x8e, 0xb4, 0x79, 0x94, 0x07, 0xb1, 0x0d, 0x6b, 0xa0, 0x6c, 0xb9, 0x5e, 0x44, 0xbb,
0x95, 0x71, 0x8e, 0x82, 0xfd, 0xa3, 0x41, 0x3c, 0x69, 0xd1, 0xbe, 0x41, 0x50, 0x3e, 0x41, 0x9d,
0x85, 0x81, 0xcf, 0x28, 0xbe, 0x03, 0xc5, 0xe4, 0x88, 0xac, 0x82, 0x66, 0x0a, 0xd5, 0x52, 0xe3,
0xaa, 0x91, 0xd1, 0x11, 0xc6, 0x20, 0x81, 0xc7, 0x3e, 0xf8, 0x3a, 0x5c, 0xf4, 0xe9, 0xe3, 0xa8,
0x35, 0xc4, 0x36, 0x3e, 0x57, 0xd1, 0x7e, 0x3d, 0xfe, 0xfd, 0x59, 0x42, 0x53, 0xfb, 0xbe, 0x00,
0xe5, 0xa5, 0x2e, 0x25, 0x11, 0x3d, 0x59, 0x86, 0x73, 0xa4, 0xef, 0x1a, 0x5c, 0x70, 0x5c, 0xd6,
0x89, 0x81, 0x63, 0x29, 0x40, 0x25, 0x36, 0xae, 0x3a, 0x78, 0x0e, 0xc6, 0x7d, 0xb2, 0x4d, 0x65,
0xda, 0xae, 0xbe, 0x3c, 0xb4, 0xa6, 0xbf, 0x5e, 0x27, 0xfa, 0xee, 0xc3, 0x75, 0x9d, 0xe8, 0xbb,
0x75, 0x7d, 0xfe, 0xe1, 0x13, 0xeb, 0xfd, 0xa6, 0xf5, 0x74, 0x5d, 0x7e, 0xd9, 0x1c, 0x8e, 0x67,
0xa1, 0xe4, 0x50, 0xb6, 0xd9, 0x75, 0xc3, 0xb8, 0x75, 0x64, 0x3a, 0x65, 0xd2, 0x1b, 0x73, 0x4d,
0x7b, 0xd8, 0x8a, 0x9f, 0x21, 0x50, 0x3c, 0xb2, 0x41, 0x3d, 0x56, 0x51, 0x78, 0xda, 0x16, 0x32,
0xd3, 0x96, 0x7a, 0x6c, 0xe3, 0x1e, 0x77, 0x5e, 0xf6, 0xa3, 0xee, 0xce, 0xe2, 0x9d, 0x97, 0x87,
0x56, 0x69, 0x5d, 0x6f, 0xd5, 0xf5, 0xf9, 0x98, 0x66, 0x6d, 0x8f, 0x9f, 0xa8, 0xf9, 0x81, 0x38,
0x59, 0xf3, 0xc6, 0xc1, 0x91, 0xa5, 0xa8, 0xe3, 0x96, 0xce, 0x57, 0x18, 0x5f, 0x92, 0x87, 0x19,
0xe0, 0x6d, 0x49, 0x45, 0x9d, 0x87, 0xd2, 0x50, 0x5c, 0x7c, 0x09, 0x0a, 0x1d, 0xba, 0x23, 0x92,
0x6a, 0xc7, 0x4b, 0x7c, 0x19, 0x26, 0xfa, 0xc4, 0xeb, 0x51, 0x59, 0x24, 0xf1, 0xb1, 0x30, 0xf6,
0x11, 0xd2, 0x6c, 0xb8, 0x32, 0x4a, 0xf4, 0x3e, 0x8d, 0x88, 0x43, 0x22, 0x82, 0xdf, 0x4e, 0xb9,
0x27, 0xc3, 0x37, 0x03, 0x4f, 0x9d, 0x28, 0x4b, 0x52, 0x08, 0xed, 0x79, 0x01, 0xca, 0x9f, 0x87,
0x4e, 0x4a, 0xd1, 0xcf, 0x77, 0xf7, 0xf0, 0x4d, 0x28, 0xf5, 0x78, 0x1c, 0x2e, 0x30, 0x7c, 0x97,
0x52, 0x43, 0x35, 0x84, 0x06, 0x19, 0x89, 0x06, 0x19, 0x2b, 0xb1, 0x06, 0xdd, 0x27, 0xac, 0x63,
0x83, 0x80, 0xc7, 0xeb, 0xff, 0xba, 0x1d, 0x26, 0xce, 0x68, 0x87, 0xd4, 0x84, 0xfc, 0xef, 0xda,
0x61, 0x1e, 0xae, 0x8c, 0x12, 0xcd, 0xdd, 0x0e, 0xda, 0x0a, 0x94, 0x3f, 0xa1, 0x1e, 0xfd, 0xa7,
0x45, 0x8f, 0x29, 0x8c, 0xc6, 0xc9, 0x4f, 0xe1, 0x07, 0x04, 0xd3, 0xc3, 0x82, 0xf7, 0x69, 0x32,
0x2f, 0xd8, 0xdf, 0x6c, 0xc0, 0x7f, 0x5f, 0xb8, 0xb5, 0xef, 0x10, 0xbc, 0x95, 0xc5, 0x51, 0xaa,
0xf3, 0xc7, 0x00, 0x83, 0x49, 0x97, 0x21, 0xcf, 0xc7, 0x93, 0x70, 0xe0, 0x6f, 0x0f, 0x39, 0xe5,
0xd5, 0xe7, 0xc6, 0x1f, 0x17, 0xe0, 0x62, 0xc2, 0x64, 0x4d, 0x3c, 0x10, 0xf0, 0x1e, 0x82, 0xc2,
0x5d, 0x1a, 0xe1, 0xd9, 0xcc, 0x5e, 0x3e, 0x3d, 0x55, 0xd5, 0xb3, 0xc7, 0x87, 0x36, 0xbb, 0xf7,
0xeb, 0x6f, 0xcf, 0xc6, 0xae, 0xe1, 0x77, 0xd2, 0x26, 0x3f, 0x33, 0x9f, 0x0c, 0x15, 0xe6, 0x29,
0xfe, 0x16, 0xc1, 0x78, 0x9c, 0x26, 0xac, 0x67, 0x06, 0x4e, 0x9b, 0xca, 0xaa, 0x91, 0x17, 0x2e,
0x72, 0xad, 0x4d, 0x73, 0x52, 0x53, 0xb8, 0x9c, 0x4a, 0x0a, 0xff, 0x88, 0x40, 0x11, 0xfa, 0x88,
0x8d, 0xf3, 0x29, 0xbd, 0x7a, 0x76, 0xc5, 0xb4, 0x95, 0x83, 0x17, 0x35, 0x2d, 0x53, 0x80, 0x27,
0x93, 0x3f, 0x9c, 0xa2, 0xaa, 0xa5, 0x53, 0x5c, 0x40, 0x35, 0xfc, 0x13, 0x02, 0x45, 0x5c, 0xdb,
0x57, 0xb0, 0x4c, 0x15, 0xa0, 0x3c, 0x2c, 0x1f, 0x08, 0x96, 0x19, 0xba, 0x30, 0xca, 0xb2, 0xda,
0xc8, 0x53, 0xdd, 0x98, 0xf3, 0x2f, 0x08, 0x14, 0x71, 0xcf, 0x5f, 0xc1, 0x39, 0x55, 0x50, 0xf2,
0x70, 0xfe, 0xf2, 0xe0, 0x45, 0xcd, 0xcc, 0x14, 0x92, 0xf2, 0xc9, 0x09, 0xb2, 0xbc, 0x1d, 0x46,
0x3b, 0xa2, 0x3d, 0x6b, 0xb9, 0xda, 0xf3, 0x67, 0x04, 0x6f, 0xc4, 0x0d, 0x75, 0x7c, 0x7b, 0x71,
0x33, 0x57, 0xe7, 0x9d, 0x92, 0x24, 0xf5, 0xc3, 0x73, 0xfb, 0xc9, 0xd6, 0x6d, 0x72, 0xc2, 0x75,
0x6c, 0xe4, 0x20, 0x7c, 0xfc, 0x74, 0x66, 0x8b, 0xcb, 0x5f, 0x2c, 0xb5, 0xdd, 0xe8, 0x51, 0x6f,
0x23, 0xde, 0xcb, 0x14, 0x9b, 0xeb, 0xe2, 0x09, 0xdd, 0x0e, 0xf4, 0x36, 0xf5, 0x79, 0x5a, 0xcc,
0x8c, 0xb7, 0xfa, 0x4d, 0xb9, 0xdc, 0x50, 0x38, 0xec, 0xc6, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff,
0xfd, 0xcf, 0xec, 0x9e, 0x7a, 0x0c, 0x00, 0x00,
}

133
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/zone.pb.go generated vendored Normal file
View File

@ -0,0 +1,133 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/zone.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type Zone_Status int32
const (
Zone_STATUS_UNSPECIFIED Zone_Status = 0
// Zone is available. You can access the resources allocated in this zone.
Zone_UP Zone_Status = 1
// Zone is not available.
Zone_DOWN Zone_Status = 2
)
var Zone_Status_name = map[int32]string{
0: "STATUS_UNSPECIFIED",
1: "UP",
2: "DOWN",
}
var Zone_Status_value = map[string]int32{
"STATUS_UNSPECIFIED": 0,
"UP": 1,
"DOWN": 2,
}
func (x Zone_Status) String() string {
return proto.EnumName(Zone_Status_name, int32(x))
}
func (Zone_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_zone_f47efd8ae474576f, []int{0, 0}
}
// Availability zone. For more information, see [Availability zones](/docs/overview/concepts/geo-scope).
type Zone struct {
// ID of the zone.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the region.
RegionId string `protobuf:"bytes,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
// Status of the zone.
Status Zone_Status `protobuf:"varint,3,opt,name=status,proto3,enum=yandex.cloud.compute.v1.Zone_Status" json:"status,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Zone) Reset() { *m = Zone{} }
func (m *Zone) String() string { return proto.CompactTextString(m) }
func (*Zone) ProtoMessage() {}
func (*Zone) Descriptor() ([]byte, []int) {
return fileDescriptor_zone_f47efd8ae474576f, []int{0}
}
func (m *Zone) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Zone.Unmarshal(m, b)
}
func (m *Zone) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Zone.Marshal(b, m, deterministic)
}
func (dst *Zone) XXX_Merge(src proto.Message) {
xxx_messageInfo_Zone.Merge(dst, src)
}
func (m *Zone) XXX_Size() int {
return xxx_messageInfo_Zone.Size(m)
}
func (m *Zone) XXX_DiscardUnknown() {
xxx_messageInfo_Zone.DiscardUnknown(m)
}
var xxx_messageInfo_Zone proto.InternalMessageInfo
func (m *Zone) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Zone) GetRegionId() string {
if m != nil {
return m.RegionId
}
return ""
}
func (m *Zone) GetStatus() Zone_Status {
if m != nil {
return m.Status
}
return Zone_STATUS_UNSPECIFIED
}
func init() {
proto.RegisterType((*Zone)(nil), "yandex.cloud.compute.v1.Zone")
proto.RegisterEnum("yandex.cloud.compute.v1.Zone_Status", Zone_Status_name, Zone_Status_value)
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/zone.proto", fileDescriptor_zone_f47efd8ae474576f)
}
var fileDescriptor_zone_f47efd8ae474576f = []byte{
// 237 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xaa, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0x4f, 0xce, 0xcf, 0x2d, 0x28, 0x2d, 0x49,
0xd5, 0x2f, 0x33, 0xd4, 0xaf, 0xca, 0xcf, 0x4b, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12,
0x87, 0xa8, 0xd1, 0x03, 0xab, 0xd1, 0x83, 0xaa, 0xd1, 0x2b, 0x33, 0x54, 0x5a, 0xca, 0xc8, 0xc5,
0x12, 0x95, 0x9f, 0x97, 0x2a, 0xc4, 0xc7, 0xc5, 0x94, 0x99, 0x22, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1,
0x19, 0xc4, 0x94, 0x99, 0x22, 0x24, 0xcd, 0xc5, 0x59, 0x94, 0x9a, 0x9e, 0x99, 0x9f, 0x17, 0x9f,
0x99, 0x22, 0xc1, 0x04, 0x16, 0xe6, 0x80, 0x08, 0x78, 0xa6, 0x08, 0xd9, 0x70, 0xb1, 0x15, 0x97,
0x24, 0x96, 0x94, 0x16, 0x4b, 0x30, 0x2b, 0x30, 0x6a, 0xf0, 0x19, 0xa9, 0xe8, 0xe1, 0x30, 0x5f,
0x0f, 0x64, 0xb6, 0x5e, 0x30, 0x58, 0x6d, 0x10, 0x54, 0x8f, 0x92, 0x11, 0x17, 0x1b, 0x44, 0x44,
0x48, 0x8c, 0x4b, 0x28, 0x38, 0xc4, 0x31, 0x24, 0x34, 0x38, 0x3e, 0xd4, 0x2f, 0x38, 0xc0, 0xd5,
0xd9, 0xd3, 0xcd, 0xd3, 0xd5, 0x45, 0x80, 0x41, 0x88, 0x8d, 0x8b, 0x29, 0x34, 0x40, 0x80, 0x51,
0x88, 0x83, 0x8b, 0xc5, 0xc5, 0x3f, 0xdc, 0x4f, 0x80, 0xc9, 0xc9, 0x35, 0xca, 0x39, 0x3d, 0xb3,
0x24, 0xa3, 0x34, 0x09, 0x64, 0xb8, 0x3e, 0xc4, 0x36, 0x5d, 0x88, 0x8f, 0xd3, 0xf3, 0x75, 0xd3,
0x53, 0xf3, 0xc0, 0xfe, 0xd4, 0xc7, 0x11, 0x14, 0xd6, 0x50, 0x66, 0x12, 0x1b, 0x58, 0x99, 0x31,
0x20, 0x00, 0x00, 0xff, 0xff, 0xa6, 0xd7, 0x67, 0x16, 0x34, 0x01, 0x00, 0x00,
}

324
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1/zone_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,324 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/compute/v1/zone_service.proto
package compute // import "github.com/yandex-cloud/go-genproto/yandex/cloud/compute/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type ListZonesRequest struct {
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListZonesResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListZonesResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListZonesRequest) Reset() { *m = ListZonesRequest{} }
func (m *ListZonesRequest) String() string { return proto.CompactTextString(m) }
func (*ListZonesRequest) ProtoMessage() {}
func (*ListZonesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_zone_service_e9c86d533e92d608, []int{0}
}
func (m *ListZonesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListZonesRequest.Unmarshal(m, b)
}
func (m *ListZonesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListZonesRequest.Marshal(b, m, deterministic)
}
func (dst *ListZonesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListZonesRequest.Merge(dst, src)
}
func (m *ListZonesRequest) XXX_Size() int {
return xxx_messageInfo_ListZonesRequest.Size(m)
}
func (m *ListZonesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListZonesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListZonesRequest proto.InternalMessageInfo
func (m *ListZonesRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListZonesRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListZonesResponse struct {
// List of availability zones.
Zones []*Zone `protobuf:"bytes,1,rep,name=zones,proto3" json:"zones,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListZonesRequest.page_size], use
// the [ListZonesRequest.page_token] as the value
// for the [ListZonesRequest.page_token] query parameter
// in the next list request. Subsequent list requests will have their own
// [ListZonesRequest.page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListZonesResponse) Reset() { *m = ListZonesResponse{} }
func (m *ListZonesResponse) String() string { return proto.CompactTextString(m) }
func (*ListZonesResponse) ProtoMessage() {}
func (*ListZonesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_zone_service_e9c86d533e92d608, []int{1}
}
func (m *ListZonesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListZonesResponse.Unmarshal(m, b)
}
func (m *ListZonesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListZonesResponse.Marshal(b, m, deterministic)
}
func (dst *ListZonesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListZonesResponse.Merge(dst, src)
}
func (m *ListZonesResponse) XXX_Size() int {
return xxx_messageInfo_ListZonesResponse.Size(m)
}
func (m *ListZonesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListZonesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListZonesResponse proto.InternalMessageInfo
func (m *ListZonesResponse) GetZones() []*Zone {
if m != nil {
return m.Zones
}
return nil
}
func (m *ListZonesResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type GetZoneRequest struct {
// ID of the availability zone to return information about.
ZoneId string `protobuf:"bytes,1,opt,name=zone_id,json=zoneId,proto3" json:"zone_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetZoneRequest) Reset() { *m = GetZoneRequest{} }
func (m *GetZoneRequest) String() string { return proto.CompactTextString(m) }
func (*GetZoneRequest) ProtoMessage() {}
func (*GetZoneRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_zone_service_e9c86d533e92d608, []int{2}
}
func (m *GetZoneRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetZoneRequest.Unmarshal(m, b)
}
func (m *GetZoneRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetZoneRequest.Marshal(b, m, deterministic)
}
func (dst *GetZoneRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetZoneRequest.Merge(dst, src)
}
func (m *GetZoneRequest) XXX_Size() int {
return xxx_messageInfo_GetZoneRequest.Size(m)
}
func (m *GetZoneRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetZoneRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetZoneRequest proto.InternalMessageInfo
func (m *GetZoneRequest) GetZoneId() string {
if m != nil {
return m.ZoneId
}
return ""
}
func init() {
proto.RegisterType((*ListZonesRequest)(nil), "yandex.cloud.compute.v1.ListZonesRequest")
proto.RegisterType((*ListZonesResponse)(nil), "yandex.cloud.compute.v1.ListZonesResponse")
proto.RegisterType((*GetZoneRequest)(nil), "yandex.cloud.compute.v1.GetZoneRequest")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// ZoneServiceClient is the client API for ZoneService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ZoneServiceClient interface {
// Returns the information about the specified availability zone.
//
// To get the list of availability zones, make a [List] request.
Get(ctx context.Context, in *GetZoneRequest, opts ...grpc.CallOption) (*Zone, error)
// Retrieves the list of availability zones.
List(ctx context.Context, in *ListZonesRequest, opts ...grpc.CallOption) (*ListZonesResponse, error)
}
type zoneServiceClient struct {
cc *grpc.ClientConn
}
func NewZoneServiceClient(cc *grpc.ClientConn) ZoneServiceClient {
return &zoneServiceClient{cc}
}
func (c *zoneServiceClient) Get(ctx context.Context, in *GetZoneRequest, opts ...grpc.CallOption) (*Zone, error) {
out := new(Zone)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.ZoneService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *zoneServiceClient) List(ctx context.Context, in *ListZonesRequest, opts ...grpc.CallOption) (*ListZonesResponse, error) {
out := new(ListZonesResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.compute.v1.ZoneService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// ZoneServiceServer is the server API for ZoneService service.
type ZoneServiceServer interface {
// Returns the information about the specified availability zone.
//
// To get the list of availability zones, make a [List] request.
Get(context.Context, *GetZoneRequest) (*Zone, error)
// Retrieves the list of availability zones.
List(context.Context, *ListZonesRequest) (*ListZonesResponse, error)
}
func RegisterZoneServiceServer(s *grpc.Server, srv ZoneServiceServer) {
s.RegisterService(&_ZoneService_serviceDesc, srv)
}
func _ZoneService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetZoneRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ZoneServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.ZoneService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ZoneServiceServer).Get(ctx, req.(*GetZoneRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ZoneService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListZonesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ZoneServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.compute.v1.ZoneService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ZoneServiceServer).List(ctx, req.(*ListZonesRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ZoneService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.compute.v1.ZoneService",
HandlerType: (*ZoneServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _ZoneService_Get_Handler,
},
{
MethodName: "List",
Handler: _ZoneService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/compute/v1/zone_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/compute/v1/zone_service.proto", fileDescriptor_zone_service_e9c86d533e92d608)
}
var fileDescriptor_zone_service_e9c86d533e92d608 = []byte{
// 421 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x4f, 0x8b, 0xd3, 0x40,
0x18, 0xc6, 0xc9, 0x76, 0xb7, 0x9a, 0x59, 0xff, 0xed, 0x78, 0xb0, 0x46, 0x0b, 0x25, 0xa2, 0x1b,
0x17, 0x36, 0x93, 0x6c, 0x11, 0x0f, 0xb6, 0x97, 0x88, 0x14, 0xc1, 0x83, 0xa4, 0x9e, 0x7a, 0x29,
0x69, 0xf3, 0x12, 0x07, 0xeb, 0x4c, 0xec, 0x4c, 0x42, 0xad, 0x78, 0xf1, 0xd8, 0xab, 0x1f, 0xaa,
0xbd, 0xfb, 0x15, 0x3c, 0xf8, 0x19, 0xf4, 0x22, 0x33, 0x13, 0xc5, 0x56, 0x52, 0xf6, 0x16, 0xf2,
0xfe, 0xe6, 0x79, 0x9e, 0xf7, 0x0f, 0x3a, 0xfb, 0x98, 0xb0, 0x14, 0x16, 0x64, 0x3a, 0xe3, 0x45,
0x4a, 0xa6, 0xfc, 0x7d, 0x5e, 0x48, 0x20, 0x65, 0x48, 0x96, 0x9c, 0xc1, 0x58, 0xc0, 0xbc, 0xa4,
0x53, 0xf0, 0xf3, 0x39, 0x97, 0x1c, 0xdf, 0x31, 0xac, 0xaf, 0x59, 0xbf, 0x62, 0xfd, 0x32, 0x74,
0xee, 0x67, 0x9c, 0x67, 0x33, 0x20, 0x49, 0x4e, 0x49, 0xc2, 0x18, 0x97, 0x89, 0xa4, 0x9c, 0x09,
0xf3, 0xcc, 0x71, 0xf7, 0x59, 0x54, 0x4c, 0x7b, 0x8b, 0x29, 0x93, 0x19, 0x4d, 0xb5, 0x86, 0x29,
0xbb, 0x80, 0x6e, 0xbd, 0xa2, 0x42, 0x8e, 0x38, 0x03, 0x11, 0xc3, 0x87, 0x02, 0x84, 0xc4, 0xa7,
0xc8, 0xce, 0x93, 0x0c, 0xc6, 0x82, 0x2e, 0xa1, 0x65, 0x75, 0x2c, 0xaf, 0x11, 0xa1, 0x9f, 0xeb,
0xb0, 0xd9, 0xeb, 0x87, 0x41, 0x10, 0xc4, 0x57, 0x55, 0x71, 0x48, 0x97, 0x80, 0x3d, 0x84, 0x34,
0x28, 0xf9, 0x3b, 0x60, 0xad, 0x83, 0x8e, 0xe5, 0xd9, 0x91, 0xbd, 0xda, 0x84, 0x47, 0x9a, 0x8c,
0xb5, 0xca, 0x1b, 0x55, 0x73, 0x73, 0x74, 0xf2, 0x8f, 0x8d, 0xc8, 0x39, 0x13, 0x80, 0xbb, 0xe8,
0x48, 0x05, 0x15, 0x2d, 0xab, 0xd3, 0xf0, 0x8e, 0x2f, 0xda, 0x7e, 0xcd, 0x14, 0x7c, 0xf5, 0x2c,
0x36, 0x2c, 0x7e, 0x84, 0x6e, 0x32, 0x58, 0xc8, 0xf1, 0xae, 0x71, 0x7c, 0x5d, 0xfd, 0x7e, 0xfd,
0xd7, 0xf1, 0x29, 0xba, 0x31, 0x00, 0x6d, 0xf8, 0xa7, 0xad, 0x87, 0xe8, 0x8a, 0x1e, 0x3d, 0x4d,
0x75, 0x53, 0x76, 0x74, 0xed, 0xc7, 0x3a, 0xb4, 0x56, 0x9b, 0xf0, 0xb0, 0xd7, 0x7f, 0x12, 0xc4,
0x4d, 0x55, 0x7c, 0x99, 0x5e, 0xfc, 0xb2, 0xd0, 0xb1, 0x7a, 0x36, 0x34, 0x1b, 0xc2, 0x73, 0xd4,
0x18, 0x80, 0xc4, 0xa7, 0xb5, 0xe9, 0xb6, 0x6d, 0x9c, 0xfd, 0x6d, 0xb8, 0x0f, 0xbe, 0x7c, 0xfb,
0xfe, 0xf5, 0xa0, 0x8d, 0xef, 0xed, 0xee, 0x4b, 0x90, 0x4f, 0x55, 0xbc, 0xcf, 0x78, 0x81, 0x0e,
0xd5, 0xb8, 0xf0, 0xe3, 0x5a, 0xad, 0xdd, 0xa5, 0x39, 0x67, 0x97, 0x41, 0xcd, 0xe0, 0xdd, 0xbb,
0x3a, 0xc3, 0x6d, 0x7c, 0xf2, 0x5f, 0x86, 0xe8, 0xc5, 0xe8, 0x79, 0x46, 0xe5, 0xdb, 0x62, 0xa2,
0x14, 0x88, 0x91, 0x3c, 0x37, 0xb7, 0x93, 0xf1, 0xf3, 0x0c, 0x98, 0x3e, 0x1b, 0x52, 0x73, 0x78,
0xcf, 0xaa, 0xcf, 0x49, 0x53, 0x63, 0xdd, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x18, 0x19, 0x69,
0xb4, 0x05, 0x03, 0x00, 0x00,
}

87
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/endpoint/api_endpoint.pb.go generated vendored Normal file
View File

@ -0,0 +1,87 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/endpoint/api_endpoint.proto
package endpoint // import "github.com/yandex-cloud/go-genproto/yandex/cloud/endpoint"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type ApiEndpoint struct {
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ApiEndpoint) Reset() { *m = ApiEndpoint{} }
func (m *ApiEndpoint) String() string { return proto.CompactTextString(m) }
func (*ApiEndpoint) ProtoMessage() {}
func (*ApiEndpoint) Descriptor() ([]byte, []int) {
return fileDescriptor_api_endpoint_f9ce6e4a311495de, []int{0}
}
func (m *ApiEndpoint) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ApiEndpoint.Unmarshal(m, b)
}
func (m *ApiEndpoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ApiEndpoint.Marshal(b, m, deterministic)
}
func (dst *ApiEndpoint) XXX_Merge(src proto.Message) {
xxx_messageInfo_ApiEndpoint.Merge(dst, src)
}
func (m *ApiEndpoint) XXX_Size() int {
return xxx_messageInfo_ApiEndpoint.Size(m)
}
func (m *ApiEndpoint) XXX_DiscardUnknown() {
xxx_messageInfo_ApiEndpoint.DiscardUnknown(m)
}
var xxx_messageInfo_ApiEndpoint proto.InternalMessageInfo
func (m *ApiEndpoint) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *ApiEndpoint) GetAddress() string {
if m != nil {
return m.Address
}
return ""
}
func init() {
proto.RegisterType((*ApiEndpoint)(nil), "yandex.cloud.endpoint.ApiEndpoint")
}
func init() {
proto.RegisterFile("yandex/cloud/endpoint/api_endpoint.proto", fileDescriptor_api_endpoint_f9ce6e4a311495de)
}
var fileDescriptor_api_endpoint_f9ce6e4a311495de = []byte{
// 152 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xa8, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0x4f, 0xcd, 0x4b, 0x29, 0xc8, 0xcf, 0xcc,
0x2b, 0xd1, 0x4f, 0x2c, 0xc8, 0x8c, 0x87, 0x71, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0x44,
0x21, 0x2a, 0xf5, 0xc0, 0x2a, 0xf5, 0x60, 0x92, 0x4a, 0xe6, 0x5c, 0xdc, 0x8e, 0x05, 0x99, 0xae,
0x50, 0xae, 0x10, 0x1f, 0x17, 0x53, 0x66, 0x8a, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x67, 0x10, 0x53,
0x66, 0x8a, 0x90, 0x04, 0x17, 0x7b, 0x62, 0x4a, 0x4a, 0x51, 0x6a, 0x71, 0xb1, 0x04, 0x13, 0x58,
0x10, 0xc6, 0x75, 0x72, 0x89, 0x72, 0x4a, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf,
0xd5, 0x87, 0x18, 0xae, 0x0b, 0x71, 0x46, 0x7a, 0xbe, 0x6e, 0x7a, 0x6a, 0x1e, 0xd8, 0x5a, 0x7d,
0xac, 0xee, 0xb3, 0x86, 0x31, 0x92, 0xd8, 0xc0, 0xaa, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff,
0x42, 0x6c, 0x3b, 0xb8, 0xc8, 0x00, 0x00, 0x00,
}

298
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/endpoint/api_endpoint_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,298 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/endpoint/api_endpoint_service.proto
package endpoint // import "github.com/yandex-cloud/go-genproto/yandex/cloud/endpoint"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetApiEndpointRequest struct {
ApiEndpointId string `protobuf:"bytes,1,opt,name=api_endpoint_id,json=apiEndpointId,proto3" json:"api_endpoint_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetApiEndpointRequest) Reset() { *m = GetApiEndpointRequest{} }
func (m *GetApiEndpointRequest) String() string { return proto.CompactTextString(m) }
func (*GetApiEndpointRequest) ProtoMessage() {}
func (*GetApiEndpointRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_api_endpoint_service_3b852f01606ed782, []int{0}
}
func (m *GetApiEndpointRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetApiEndpointRequest.Unmarshal(m, b)
}
func (m *GetApiEndpointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetApiEndpointRequest.Marshal(b, m, deterministic)
}
func (dst *GetApiEndpointRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetApiEndpointRequest.Merge(dst, src)
}
func (m *GetApiEndpointRequest) XXX_Size() int {
return xxx_messageInfo_GetApiEndpointRequest.Size(m)
}
func (m *GetApiEndpointRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetApiEndpointRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetApiEndpointRequest proto.InternalMessageInfo
func (m *GetApiEndpointRequest) GetApiEndpointId() string {
if m != nil {
return m.ApiEndpointId
}
return ""
}
type ListApiEndpointsRequest struct {
PageSize int64 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListApiEndpointsRequest) Reset() { *m = ListApiEndpointsRequest{} }
func (m *ListApiEndpointsRequest) String() string { return proto.CompactTextString(m) }
func (*ListApiEndpointsRequest) ProtoMessage() {}
func (*ListApiEndpointsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_api_endpoint_service_3b852f01606ed782, []int{1}
}
func (m *ListApiEndpointsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListApiEndpointsRequest.Unmarshal(m, b)
}
func (m *ListApiEndpointsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListApiEndpointsRequest.Marshal(b, m, deterministic)
}
func (dst *ListApiEndpointsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListApiEndpointsRequest.Merge(dst, src)
}
func (m *ListApiEndpointsRequest) XXX_Size() int {
return xxx_messageInfo_ListApiEndpointsRequest.Size(m)
}
func (m *ListApiEndpointsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListApiEndpointsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListApiEndpointsRequest proto.InternalMessageInfo
func (m *ListApiEndpointsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListApiEndpointsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListApiEndpointsResponse struct {
Endpoints []*ApiEndpoint `protobuf:"bytes,1,rep,name=endpoints,proto3" json:"endpoints,omitempty"`
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListApiEndpointsResponse) Reset() { *m = ListApiEndpointsResponse{} }
func (m *ListApiEndpointsResponse) String() string { return proto.CompactTextString(m) }
func (*ListApiEndpointsResponse) ProtoMessage() {}
func (*ListApiEndpointsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_api_endpoint_service_3b852f01606ed782, []int{2}
}
func (m *ListApiEndpointsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListApiEndpointsResponse.Unmarshal(m, b)
}
func (m *ListApiEndpointsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListApiEndpointsResponse.Marshal(b, m, deterministic)
}
func (dst *ListApiEndpointsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListApiEndpointsResponse.Merge(dst, src)
}
func (m *ListApiEndpointsResponse) XXX_Size() int {
return xxx_messageInfo_ListApiEndpointsResponse.Size(m)
}
func (m *ListApiEndpointsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListApiEndpointsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListApiEndpointsResponse proto.InternalMessageInfo
func (m *ListApiEndpointsResponse) GetEndpoints() []*ApiEndpoint {
if m != nil {
return m.Endpoints
}
return nil
}
func (m *ListApiEndpointsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetApiEndpointRequest)(nil), "yandex.cloud.endpoint.GetApiEndpointRequest")
proto.RegisterType((*ListApiEndpointsRequest)(nil), "yandex.cloud.endpoint.ListApiEndpointsRequest")
proto.RegisterType((*ListApiEndpointsResponse)(nil), "yandex.cloud.endpoint.ListApiEndpointsResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// ApiEndpointServiceClient is the client API for ApiEndpointService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ApiEndpointServiceClient interface {
Get(ctx context.Context, in *GetApiEndpointRequest, opts ...grpc.CallOption) (*ApiEndpoint, error)
List(ctx context.Context, in *ListApiEndpointsRequest, opts ...grpc.CallOption) (*ListApiEndpointsResponse, error)
}
type apiEndpointServiceClient struct {
cc *grpc.ClientConn
}
func NewApiEndpointServiceClient(cc *grpc.ClientConn) ApiEndpointServiceClient {
return &apiEndpointServiceClient{cc}
}
func (c *apiEndpointServiceClient) Get(ctx context.Context, in *GetApiEndpointRequest, opts ...grpc.CallOption) (*ApiEndpoint, error) {
out := new(ApiEndpoint)
err := c.cc.Invoke(ctx, "/yandex.cloud.endpoint.ApiEndpointService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *apiEndpointServiceClient) List(ctx context.Context, in *ListApiEndpointsRequest, opts ...grpc.CallOption) (*ListApiEndpointsResponse, error) {
out := new(ListApiEndpointsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.endpoint.ApiEndpointService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// ApiEndpointServiceServer is the server API for ApiEndpointService service.
type ApiEndpointServiceServer interface {
Get(context.Context, *GetApiEndpointRequest) (*ApiEndpoint, error)
List(context.Context, *ListApiEndpointsRequest) (*ListApiEndpointsResponse, error)
}
func RegisterApiEndpointServiceServer(s *grpc.Server, srv ApiEndpointServiceServer) {
s.RegisterService(&_ApiEndpointService_serviceDesc, srv)
}
func _ApiEndpointService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetApiEndpointRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ApiEndpointServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.endpoint.ApiEndpointService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ApiEndpointServiceServer).Get(ctx, req.(*GetApiEndpointRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ApiEndpointService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListApiEndpointsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ApiEndpointServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.endpoint.ApiEndpointService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ApiEndpointServiceServer).List(ctx, req.(*ListApiEndpointsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ApiEndpointService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.endpoint.ApiEndpointService",
HandlerType: (*ApiEndpointServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _ApiEndpointService_Get_Handler,
},
{
MethodName: "List",
Handler: _ApiEndpointService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/endpoint/api_endpoint_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/endpoint/api_endpoint_service.proto", fileDescriptor_api_endpoint_service_3b852f01606ed782)
}
var fileDescriptor_api_endpoint_service_3b852f01606ed782 = []byte{
// 370 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x52, 0x51, 0x4b, 0x2a, 0x41,
0x18, 0x65, 0xf5, 0x72, 0xb9, 0x7e, 0xf7, 0xca, 0x85, 0x01, 0x69, 0xd9, 0x2c, 0x64, 0x89, 0xf0,
0x21, 0x67, 0xc2, 0x1e, 0x7b, 0xa8, 0xa4, 0x90, 0xa0, 0x87, 0xd0, 0x7a, 0xe9, 0x65, 0x59, 0xdd,
0x8f, 0x6d, 0xc8, 0x66, 0x36, 0x67, 0x0c, 0x53, 0x7c, 0x89, 0x7e, 0x40, 0xd0, 0x4f, 0xeb, 0x2f,
0xf4, 0x43, 0x62, 0x67, 0xda, 0xb4, 0x54, 0xf2, 0x6d, 0xf7, 0x9b, 0x73, 0xce, 0x9c, 0x39, 0xe7,
0x83, 0xdd, 0x87, 0x50, 0x44, 0x38, 0x64, 0xdd, 0x9e, 0x1c, 0x44, 0x0c, 0x45, 0x94, 0x48, 0x2e,
0x34, 0x0b, 0x13, 0x1e, 0x64, 0x3f, 0x81, 0xc2, 0xfe, 0x3d, 0xef, 0x22, 0x4d, 0xfa, 0x52, 0x4b,
0x52, 0xb2, 0x0c, 0x6a, 0x18, 0x34, 0x03, 0x79, 0xe5, 0x58, 0xca, 0xb8, 0x87, 0x29, 0x93, 0x85,
0x42, 0x48, 0x1d, 0x6a, 0x2e, 0x85, 0xb2, 0x24, 0xaf, 0xfa, 0xf3, 0x35, 0x16, 0xe9, 0x1f, 0x40,
0xa9, 0x89, 0xfa, 0x28, 0xe1, 0x27, 0x1f, 0xf3, 0x16, 0xde, 0x0d, 0x50, 0x69, 0xb2, 0x0d, 0xff,
0xbf, 0xb8, 0xe2, 0x91, 0xeb, 0x54, 0x9c, 0x6a, 0xa1, 0x55, 0x0c, 0xa7, 0xe0, 0xd3, 0xc8, 0xbf,
0x84, 0xb5, 0x33, 0xae, 0x66, 0x15, 0x54, 0x26, 0xb1, 0x0e, 0x85, 0x24, 0x8c, 0x31, 0x50, 0x7c,
0x84, 0x86, 0x9c, 0x6f, 0xfd, 0x49, 0x07, 0x6d, 0x3e, 0x42, 0xb2, 0x01, 0x60, 0x0e, 0xb5, 0xbc,
0x41, 0xe1, 0xe6, 0x8c, 0xb4, 0x81, 0x5f, 0xa4, 0x03, 0xff, 0xc9, 0x01, 0x77, 0x5e, 0x57, 0x25,
0x52, 0x28, 0x24, 0x87, 0x50, 0xc8, 0x7c, 0x29, 0xd7, 0xa9, 0xe4, 0xab, 0x7f, 0xeb, 0x3e, 0x5d,
0x98, 0x13, 0x9d, 0x7d, 0xd9, 0x94, 0x94, 0xbe, 0x4e, 0xe0, 0x50, 0x07, 0x73, 0x16, 0x8a, 0xe9,
0xf8, 0x3c, 0xb3, 0x51, 0x7f, 0xce, 0x01, 0x99, 0x91, 0x68, 0xdb, 0x6a, 0xc8, 0x04, 0xf2, 0x4d,
0xd4, 0x64, 0x67, 0xc9, 0xa5, 0x0b, 0x13, 0xf5, 0x56, 0xb0, 0xe8, 0x6f, 0x3d, 0xbe, 0xbe, 0xbd,
0xe4, 0x36, 0x49, 0xf9, 0xb3, 0x34, 0xc5, 0xc6, 0xdf, 0x7a, 0x98, 0x90, 0x31, 0xfc, 0x4a, 0xb3,
0x21, 0x74, 0x89, 0xe2, 0x92, 0x42, 0x3c, 0xb6, 0x32, 0xde, 0x06, 0xed, 0x13, 0x63, 0xe7, 0x1f,
0x81, 0xa9, 0x9d, 0xc6, 0xf1, 0x55, 0x23, 0xe6, 0xfa, 0x7a, 0xd0, 0xa1, 0x5d, 0x79, 0xcb, 0xac,
0x60, 0xcd, 0x2e, 0x5a, 0x2c, 0x6b, 0x31, 0x0a, 0xb3, 0x58, 0x6c, 0xe1, 0x06, 0xee, 0x67, 0x1f,
0x9d, 0xdf, 0x06, 0xb5, 0xf7, 0x1e, 0x00, 0x00, 0xff, 0xff, 0x83, 0x68, 0x07, 0x93, 0x11, 0x03,
0x00, 0x00,
}

129
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/awscompatibility/access_key.pb.go generated vendored Normal file
View File

@ -0,0 +1,129 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/awscompatibility/access_key.proto
package awscompatibility // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/awscompatibility"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// An AccessKey resource.
// For more information, see [AWS-compatible access keys](/docs/iam/concepts/authorization/access-key).
type AccessKey struct {
// ID of the AccessKey resource.
// It is used to manage secret credentials: an access key ID and a secret access key.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the service account that the access key belongs to.
ServiceAccountId string `protobuf:"bytes,2,opt,name=service_account_id,json=serviceAccountId,proto3" json:"service_account_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Description of the access key. 0-256 characters long.
Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
// ID of the access key.
// The key is AWS compatible.
KeyId string `protobuf:"bytes,5,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AccessKey) Reset() { *m = AccessKey{} }
func (m *AccessKey) String() string { return proto.CompactTextString(m) }
func (*AccessKey) ProtoMessage() {}
func (*AccessKey) Descriptor() ([]byte, []int) {
return fileDescriptor_access_key_dd425dc954899590, []int{0}
}
func (m *AccessKey) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AccessKey.Unmarshal(m, b)
}
func (m *AccessKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AccessKey.Marshal(b, m, deterministic)
}
func (dst *AccessKey) XXX_Merge(src proto.Message) {
xxx_messageInfo_AccessKey.Merge(dst, src)
}
func (m *AccessKey) XXX_Size() int {
return xxx_messageInfo_AccessKey.Size(m)
}
func (m *AccessKey) XXX_DiscardUnknown() {
xxx_messageInfo_AccessKey.DiscardUnknown(m)
}
var xxx_messageInfo_AccessKey proto.InternalMessageInfo
func (m *AccessKey) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *AccessKey) GetServiceAccountId() string {
if m != nil {
return m.ServiceAccountId
}
return ""
}
func (m *AccessKey) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *AccessKey) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *AccessKey) GetKeyId() string {
if m != nil {
return m.KeyId
}
return ""
}
func init() {
proto.RegisterType((*AccessKey)(nil), "yandex.cloud.iam.v1.awscompatibility.AccessKey")
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/awscompatibility/access_key.proto", fileDescriptor_access_key_dd425dc954899590)
}
var fileDescriptor_access_key_dd425dc954899590 = []byte{
// 285 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x90, 0x41, 0x4b, 0xfb, 0x30,
0x18, 0xc6, 0xe9, 0xfe, 0xff, 0x0d, 0x96, 0x81, 0x48, 0x40, 0x28, 0xbb, 0x58, 0xc4, 0xc3, 0x0e,
0x2e, 0x61, 0x8a, 0x07, 0xf1, 0x54, 0x6f, 0xc3, 0xdb, 0xf0, 0xa2, 0x1e, 0x4a, 0x9a, 0xbc, 0xd6,
0x97, 0x36, 0x4d, 0x69, 0xd2, 0x6a, 0x3e, 0x9c, 0xdf, 0x4d, 0x4c, 0x36, 0x90, 0x9d, 0xbc, 0xbe,
0xcf, 0xfb, 0x7b, 0x9e, 0x87, 0x87, 0xdc, 0x7a, 0xd1, 0x2a, 0xf8, 0xe4, 0xb2, 0x31, 0x83, 0xe2,
0x28, 0x34, 0x1f, 0x37, 0x5c, 0x7c, 0x58, 0x69, 0x74, 0x27, 0x1c, 0x96, 0xd8, 0xa0, 0xf3, 0x5c,
0x48, 0x09, 0xd6, 0x16, 0x35, 0x78, 0xd6, 0xf5, 0xc6, 0x19, 0x7a, 0x19, 0x31, 0x16, 0x30, 0x86,
0x42, 0xb3, 0x71, 0xc3, 0x8e, 0xb1, 0xe5, 0x79, 0x65, 0x4c, 0xd5, 0x00, 0x0f, 0x4c, 0x39, 0xbc,
0x71, 0x87, 0x1a, 0xac, 0x13, 0xba, 0x8b, 0x36, 0x17, 0x5f, 0x09, 0x99, 0xe7, 0xc1, 0xfb, 0x11,
0x3c, 0x3d, 0x21, 0x13, 0x54, 0x69, 0x92, 0x25, 0xab, 0xf9, 0x6e, 0x82, 0x8a, 0x5e, 0x11, 0x6a,
0xa1, 0x1f, 0x51, 0x42, 0x21, 0xa4, 0x34, 0x43, 0xeb, 0x0a, 0x54, 0xe9, 0x24, 0xe8, 0xa7, 0x7b,
0x25, 0x8f, 0xc2, 0x56, 0xd1, 0x3b, 0x42, 0x64, 0x0f, 0xc2, 0x81, 0x2a, 0x84, 0x4b, 0xff, 0x65,
0xc9, 0x6a, 0x71, 0xbd, 0x64, 0xb1, 0x01, 0x3b, 0x34, 0x60, 0x4f, 0x87, 0x06, 0xbb, 0xf9, 0xfe,
0x3b, 0x77, 0x34, 0x23, 0x0b, 0x05, 0x56, 0xf6, 0xd8, 0x39, 0x34, 0x6d, 0xfa, 0x3f, 0x24, 0xfc,
0x3e, 0xd1, 0x33, 0x32, 0xab, 0xc1, 0xff, 0xc4, 0x4f, 0x83, 0x38, 0xad, 0xc1, 0x6f, 0xd5, 0xc3,
0xeb, 0xcb, 0x73, 0x85, 0xee, 0x7d, 0x28, 0x99, 0x34, 0x9a, 0xc7, 0x4d, 0xd6, 0x71, 0xca, 0xca,
0xac, 0x2b, 0x68, 0x43, 0x2e, 0xff, 0xcb, 0xc6, 0xf7, 0xc7, 0x87, 0x72, 0x16, 0xe0, 0x9b, 0xef,
0x00, 0x00, 0x00, 0xff, 0xff, 0x6e, 0x37, 0x35, 0xf6, 0xa3, 0x01, 0x00, 0x00,
}

565
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/awscompatibility/access_key_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,565 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/awscompatibility/access_key_service.proto
package awscompatibility // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/awscompatibility"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import empty "github.com/golang/protobuf/ptypes/empty"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetAccessKeyRequest struct {
// ID of the AccessKey resource to return.
// To get the access key ID, use a [AccessKeyService.List] request.
AccessKeyId string `protobuf:"bytes,1,opt,name=access_key_id,json=accessKeyId,proto3" json:"access_key_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetAccessKeyRequest) Reset() { *m = GetAccessKeyRequest{} }
func (m *GetAccessKeyRequest) String() string { return proto.CompactTextString(m) }
func (*GetAccessKeyRequest) ProtoMessage() {}
func (*GetAccessKeyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_access_key_service_efeaa691b26615d7, []int{0}
}
func (m *GetAccessKeyRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetAccessKeyRequest.Unmarshal(m, b)
}
func (m *GetAccessKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetAccessKeyRequest.Marshal(b, m, deterministic)
}
func (dst *GetAccessKeyRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetAccessKeyRequest.Merge(dst, src)
}
func (m *GetAccessKeyRequest) XXX_Size() int {
return xxx_messageInfo_GetAccessKeyRequest.Size(m)
}
func (m *GetAccessKeyRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetAccessKeyRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetAccessKeyRequest proto.InternalMessageInfo
func (m *GetAccessKeyRequest) GetAccessKeyId() string {
if m != nil {
return m.AccessKeyId
}
return ""
}
type ListAccessKeysRequest struct {
// ID of the service account to list access keys for.
// To get the service account ID, use a [yandex.cloud.iam.v1.ServiceAccountService.List] request.
// If not specified, it defaults to the subject that made the request.
ServiceAccountId string `protobuf:"bytes,1,opt,name=service_account_id,json=serviceAccountId,proto3" json:"service_account_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListAccessKeysResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
// Default value: 100.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token]
// to the [ListAccessKeysResponse.next_page_token]
// returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListAccessKeysRequest) Reset() { *m = ListAccessKeysRequest{} }
func (m *ListAccessKeysRequest) String() string { return proto.CompactTextString(m) }
func (*ListAccessKeysRequest) ProtoMessage() {}
func (*ListAccessKeysRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_access_key_service_efeaa691b26615d7, []int{1}
}
func (m *ListAccessKeysRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListAccessKeysRequest.Unmarshal(m, b)
}
func (m *ListAccessKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListAccessKeysRequest.Marshal(b, m, deterministic)
}
func (dst *ListAccessKeysRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListAccessKeysRequest.Merge(dst, src)
}
func (m *ListAccessKeysRequest) XXX_Size() int {
return xxx_messageInfo_ListAccessKeysRequest.Size(m)
}
func (m *ListAccessKeysRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListAccessKeysRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListAccessKeysRequest proto.InternalMessageInfo
func (m *ListAccessKeysRequest) GetServiceAccountId() string {
if m != nil {
return m.ServiceAccountId
}
return ""
}
func (m *ListAccessKeysRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListAccessKeysRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListAccessKeysResponse struct {
// List of AccessKey resources.
AccessKeys []*AccessKey `protobuf:"bytes,1,rep,name=access_keys,json=accessKeys,proto3" json:"access_keys,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListAccessKeysRequest.page_size], use
// the [next_page_token] as the value
// for the [ListAccessKeysRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListAccessKeysResponse) Reset() { *m = ListAccessKeysResponse{} }
func (m *ListAccessKeysResponse) String() string { return proto.CompactTextString(m) }
func (*ListAccessKeysResponse) ProtoMessage() {}
func (*ListAccessKeysResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_access_key_service_efeaa691b26615d7, []int{2}
}
func (m *ListAccessKeysResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListAccessKeysResponse.Unmarshal(m, b)
}
func (m *ListAccessKeysResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListAccessKeysResponse.Marshal(b, m, deterministic)
}
func (dst *ListAccessKeysResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListAccessKeysResponse.Merge(dst, src)
}
func (m *ListAccessKeysResponse) XXX_Size() int {
return xxx_messageInfo_ListAccessKeysResponse.Size(m)
}
func (m *ListAccessKeysResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListAccessKeysResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListAccessKeysResponse proto.InternalMessageInfo
func (m *ListAccessKeysResponse) GetAccessKeys() []*AccessKey {
if m != nil {
return m.AccessKeys
}
return nil
}
func (m *ListAccessKeysResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type CreateAccessKeyRequest struct {
// ID of the service account to create an access key for.
// To get the service account ID, use a [yandex.cloud.iam.v1.ServiceAccountService.List] request.
// If not specified, it defaults to the subject that made the request.
ServiceAccountId string `protobuf:"bytes,1,opt,name=service_account_id,json=serviceAccountId,proto3" json:"service_account_id,omitempty"`
// Description of the access key.
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateAccessKeyRequest) Reset() { *m = CreateAccessKeyRequest{} }
func (m *CreateAccessKeyRequest) String() string { return proto.CompactTextString(m) }
func (*CreateAccessKeyRequest) ProtoMessage() {}
func (*CreateAccessKeyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_access_key_service_efeaa691b26615d7, []int{3}
}
func (m *CreateAccessKeyRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateAccessKeyRequest.Unmarshal(m, b)
}
func (m *CreateAccessKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateAccessKeyRequest.Marshal(b, m, deterministic)
}
func (dst *CreateAccessKeyRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateAccessKeyRequest.Merge(dst, src)
}
func (m *CreateAccessKeyRequest) XXX_Size() int {
return xxx_messageInfo_CreateAccessKeyRequest.Size(m)
}
func (m *CreateAccessKeyRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateAccessKeyRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateAccessKeyRequest proto.InternalMessageInfo
func (m *CreateAccessKeyRequest) GetServiceAccountId() string {
if m != nil {
return m.ServiceAccountId
}
return ""
}
func (m *CreateAccessKeyRequest) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
type CreateAccessKeyResponse struct {
// AccessKey resource.
AccessKey *AccessKey `protobuf:"bytes,1,opt,name=access_key,json=accessKey,proto3" json:"access_key,omitempty"`
// Secret access key.
// The key is AWS compatible.
Secret string `protobuf:"bytes,2,opt,name=secret,proto3" json:"secret,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateAccessKeyResponse) Reset() { *m = CreateAccessKeyResponse{} }
func (m *CreateAccessKeyResponse) String() string { return proto.CompactTextString(m) }
func (*CreateAccessKeyResponse) ProtoMessage() {}
func (*CreateAccessKeyResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_access_key_service_efeaa691b26615d7, []int{4}
}
func (m *CreateAccessKeyResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateAccessKeyResponse.Unmarshal(m, b)
}
func (m *CreateAccessKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateAccessKeyResponse.Marshal(b, m, deterministic)
}
func (dst *CreateAccessKeyResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateAccessKeyResponse.Merge(dst, src)
}
func (m *CreateAccessKeyResponse) XXX_Size() int {
return xxx_messageInfo_CreateAccessKeyResponse.Size(m)
}
func (m *CreateAccessKeyResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CreateAccessKeyResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CreateAccessKeyResponse proto.InternalMessageInfo
func (m *CreateAccessKeyResponse) GetAccessKey() *AccessKey {
if m != nil {
return m.AccessKey
}
return nil
}
func (m *CreateAccessKeyResponse) GetSecret() string {
if m != nil {
return m.Secret
}
return ""
}
type DeleteAccessKeyRequest struct {
// ID of the access key to delete.
// To get the access key ID, use a [AccessKeyService.List] request.
AccessKeyId string `protobuf:"bytes,1,opt,name=access_key_id,json=accessKeyId,proto3" json:"access_key_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteAccessKeyRequest) Reset() { *m = DeleteAccessKeyRequest{} }
func (m *DeleteAccessKeyRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteAccessKeyRequest) ProtoMessage() {}
func (*DeleteAccessKeyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_access_key_service_efeaa691b26615d7, []int{5}
}
func (m *DeleteAccessKeyRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteAccessKeyRequest.Unmarshal(m, b)
}
func (m *DeleteAccessKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteAccessKeyRequest.Marshal(b, m, deterministic)
}
func (dst *DeleteAccessKeyRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteAccessKeyRequest.Merge(dst, src)
}
func (m *DeleteAccessKeyRequest) XXX_Size() int {
return xxx_messageInfo_DeleteAccessKeyRequest.Size(m)
}
func (m *DeleteAccessKeyRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteAccessKeyRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteAccessKeyRequest proto.InternalMessageInfo
func (m *DeleteAccessKeyRequest) GetAccessKeyId() string {
if m != nil {
return m.AccessKeyId
}
return ""
}
func init() {
proto.RegisterType((*GetAccessKeyRequest)(nil), "yandex.cloud.iam.v1.awscompatibility.GetAccessKeyRequest")
proto.RegisterType((*ListAccessKeysRequest)(nil), "yandex.cloud.iam.v1.awscompatibility.ListAccessKeysRequest")
proto.RegisterType((*ListAccessKeysResponse)(nil), "yandex.cloud.iam.v1.awscompatibility.ListAccessKeysResponse")
proto.RegisterType((*CreateAccessKeyRequest)(nil), "yandex.cloud.iam.v1.awscompatibility.CreateAccessKeyRequest")
proto.RegisterType((*CreateAccessKeyResponse)(nil), "yandex.cloud.iam.v1.awscompatibility.CreateAccessKeyResponse")
proto.RegisterType((*DeleteAccessKeyRequest)(nil), "yandex.cloud.iam.v1.awscompatibility.DeleteAccessKeyRequest")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// AccessKeyServiceClient is the client API for AccessKeyService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AccessKeyServiceClient interface {
// Retrieves the list of AccessKey resources for the specified service account.
List(ctx context.Context, in *ListAccessKeysRequest, opts ...grpc.CallOption) (*ListAccessKeysResponse, error)
// Returns the specified AccessKey resource.
//
// To get the list of available AccessKey resources, make a [List] request.
Get(ctx context.Context, in *GetAccessKeyRequest, opts ...grpc.CallOption) (*AccessKey, error)
// Creates an access key for the specified service account.
Create(ctx context.Context, in *CreateAccessKeyRequest, opts ...grpc.CallOption) (*CreateAccessKeyResponse, error)
// Deletes the specified access key.
Delete(ctx context.Context, in *DeleteAccessKeyRequest, opts ...grpc.CallOption) (*empty.Empty, error)
}
type accessKeyServiceClient struct {
cc *grpc.ClientConn
}
func NewAccessKeyServiceClient(cc *grpc.ClientConn) AccessKeyServiceClient {
return &accessKeyServiceClient{cc}
}
func (c *accessKeyServiceClient) List(ctx context.Context, in *ListAccessKeysRequest, opts ...grpc.CallOption) (*ListAccessKeysResponse, error) {
out := new(ListAccessKeysResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *accessKeyServiceClient) Get(ctx context.Context, in *GetAccessKeyRequest, opts ...grpc.CallOption) (*AccessKey, error) {
out := new(AccessKey)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *accessKeyServiceClient) Create(ctx context.Context, in *CreateAccessKeyRequest, opts ...grpc.CallOption) (*CreateAccessKeyResponse, error) {
out := new(CreateAccessKeyResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/Create", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *accessKeyServiceClient) Delete(ctx context.Context, in *DeleteAccessKeyRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
out := new(empty.Empty)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/Delete", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// AccessKeyServiceServer is the server API for AccessKeyService service.
type AccessKeyServiceServer interface {
// Retrieves the list of AccessKey resources for the specified service account.
List(context.Context, *ListAccessKeysRequest) (*ListAccessKeysResponse, error)
// Returns the specified AccessKey resource.
//
// To get the list of available AccessKey resources, make a [List] request.
Get(context.Context, *GetAccessKeyRequest) (*AccessKey, error)
// Creates an access key for the specified service account.
Create(context.Context, *CreateAccessKeyRequest) (*CreateAccessKeyResponse, error)
// Deletes the specified access key.
Delete(context.Context, *DeleteAccessKeyRequest) (*empty.Empty, error)
}
func RegisterAccessKeyServiceServer(s *grpc.Server, srv AccessKeyServiceServer) {
s.RegisterService(&_AccessKeyService_serviceDesc, srv)
}
func _AccessKeyService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListAccessKeysRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AccessKeyServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AccessKeyServiceServer).List(ctx, req.(*ListAccessKeysRequest))
}
return interceptor(ctx, in, info, handler)
}
func _AccessKeyService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetAccessKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AccessKeyServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AccessKeyServiceServer).Get(ctx, req.(*GetAccessKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _AccessKeyService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateAccessKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AccessKeyServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AccessKeyServiceServer).Create(ctx, req.(*CreateAccessKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _AccessKeyService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteAccessKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AccessKeyServiceServer).Delete(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.awscompatibility.AccessKeyService/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AccessKeyServiceServer).Delete(ctx, req.(*DeleteAccessKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
var _AccessKeyService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.iam.v1.awscompatibility.AccessKeyService",
HandlerType: (*AccessKeyServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "List",
Handler: _AccessKeyService_List_Handler,
},
{
MethodName: "Get",
Handler: _AccessKeyService_Get_Handler,
},
{
MethodName: "Create",
Handler: _AccessKeyService_Create_Handler,
},
{
MethodName: "Delete",
Handler: _AccessKeyService_Delete_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/iam/v1/awscompatibility/access_key_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/awscompatibility/access_key_service.proto", fileDescriptor_access_key_service_efeaa691b26615d7)
}
var fileDescriptor_access_key_service_efeaa691b26615d7 = []byte{
// 649 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x95, 0xbf, 0x6e, 0x13, 0x4b,
0x14, 0xc6, 0x35, 0x71, 0x62, 0xc5, 0xc7, 0x37, 0xba, 0xd1, 0x5c, 0x5d, 0x63, 0x19, 0x90, 0xa2,
0x55, 0x14, 0x4c, 0x20, 0x3b, 0xde, 0x40, 0x22, 0x41, 0xec, 0x22, 0x01, 0x14, 0x05, 0x10, 0x8a,
0x1c, 0x1a, 0xa0, 0xb0, 0xc6, 0xbb, 0x07, 0x33, 0x8a, 0xbd, 0xb3, 0x78, 0xc6, 0x4e, 0x1c, 0x94,
0x02, 0xca, 0x94, 0xd0, 0x52, 0xf1, 0x02, 0xe9, 0x78, 0x85, 0xa4, 0xa2, 0xe1, 0x15, 0x28, 0x78,
0x06, 0x2a, 0xb4, 0xb3, 0x6b, 0x3b, 0x7f, 0x5c, 0x6c, 0x5c, 0xee, 0x9c, 0xf9, 0xce, 0xf9, 0xe6,
0x77, 0xce, 0xcc, 0x42, 0xa5, 0xc7, 0x7d, 0x0f, 0xf7, 0x99, 0xdb, 0x94, 0x1d, 0x8f, 0x09, 0xde,
0x62, 0x5d, 0x87, 0xf1, 0x3d, 0xe5, 0xca, 0x56, 0xc0, 0xb5, 0xa8, 0x8b, 0xa6, 0xd0, 0x3d, 0xc6,
0x5d, 0x17, 0x95, 0xaa, 0xed, 0x62, 0xaf, 0xa6, 0xb0, 0xdd, 0x15, 0x2e, 0xda, 0x41, 0x5b, 0x6a,
0x49, 0xe7, 0x23, 0xb9, 0x6d, 0xe4, 0xb6, 0xe0, 0x2d, 0xbb, 0xeb, 0xd8, 0x17, 0xe5, 0x85, 0x1b,
0x0d, 0x29, 0x1b, 0x4d, 0x64, 0x3c, 0x10, 0x8c, 0xfb, 0xbe, 0xd4, 0x5c, 0x0b, 0xe9, 0xab, 0x28,
0x47, 0xe1, 0x7a, 0x1c, 0x35, 0x5f, 0xf5, 0xce, 0x5b, 0x86, 0xad, 0x40, 0xf7, 0xe2, 0xe0, 0xca,
0x15, 0xfd, 0xc5, 0xb2, 0x9b, 0xe7, 0x64, 0x5d, 0xde, 0x14, 0x9e, 0xa9, 0x19, 0x85, 0xad, 0x4d,
0xf8, 0x6f, 0x13, 0xf5, 0xba, 0x51, 0x3d, 0xc3, 0x5e, 0x15, 0xdf, 0x77, 0x50, 0x69, 0x5a, 0x82,
0x99, 0x33, 0x27, 0x15, 0x5e, 0x9e, 0xcc, 0x91, 0x62, 0x66, 0xe3, 0x9f, 0xdf, 0x27, 0x0e, 0x39,
0x3a, 0x75, 0x26, 0xcb, 0x95, 0x95, 0x52, 0x35, 0xcb, 0xfb, 0xb2, 0x2d, 0xcf, 0xfa, 0x46, 0xe0,
0xff, 0xe7, 0x42, 0x0d, 0x53, 0xa9, 0x7e, 0xae, 0x55, 0xa0, 0x31, 0xaa, 0x1a, 0x77, 0x5d, 0xd9,
0xf1, 0xf5, 0x30, 0xe1, 0xf4, 0x20, 0xd9, 0x6c, 0xbc, 0x67, 0x3d, 0xda, 0xb2, 0xe5, 0xd1, 0x5b,
0x90, 0x09, 0x78, 0x03, 0x6b, 0x4a, 0x1c, 0x60, 0x7e, 0x62, 0x8e, 0x14, 0x53, 0x1b, 0xf0, 0xe7,
0xc4, 0x49, 0x97, 0x2b, 0x4e, 0xa9, 0x54, 0xaa, 0x4e, 0x87, 0xc1, 0x1d, 0x71, 0x80, 0xb4, 0x08,
0x60, 0x36, 0x6a, 0xb9, 0x8b, 0x7e, 0x3e, 0x65, 0x12, 0x67, 0x8e, 0x4e, 0x9d, 0x29, 0xb3, 0xb3,
0x6a, 0xb2, 0xbc, 0x0c, 0x63, 0xd6, 0x67, 0x02, 0xb9, 0x8b, 0x26, 0x55, 0x20, 0x7d, 0x85, 0x74,
0x1b, 0xb2, 0xc3, 0x13, 0xab, 0x3c, 0x99, 0x4b, 0x15, 0xb3, 0xcb, 0xcc, 0x4e, 0xd2, 0x55, 0x7b,
0x88, 0x0f, 0x06, 0x48, 0x14, 0x5d, 0x80, 0x7f, 0x7d, 0xdc, 0xd7, 0xb5, 0x33, 0xde, 0xc2, 0x53,
0x64, 0xaa, 0x33, 0xe1, 0xf2, 0xf6, 0xc0, 0xd4, 0x21, 0xe4, 0x1e, 0xb5, 0x91, 0x6b, 0xbc, 0xd4,
0x85, 0x71, 0xc9, 0xdd, 0x81, 0xac, 0x87, 0xca, 0x6d, 0x8b, 0x20, 0xec, 0x74, 0x54, 0xb5, 0x4f,
0x64, 0x79, 0x65, 0xb5, 0x7a, 0x36, 0x6a, 0x7d, 0x24, 0x70, 0xed, 0x52, 0xfd, 0x18, 0xca, 0x0b,
0x80, 0x21, 0x14, 0x53, 0x78, 0x0c, 0x26, 0x99, 0x01, 0x13, 0x9a, 0x83, 0xb4, 0x42, 0xb7, 0x8d,
0x3a, 0x26, 0x11, 0x7f, 0x59, 0x4f, 0x21, 0xf7, 0x18, 0x9b, 0x38, 0x02, 0xc1, 0x95, 0x07, 0x71,
0xf9, 0xc7, 0x14, 0xcc, 0x0e, 0xd2, 0xec, 0x44, 0x68, 0xe8, 0x31, 0x81, 0xc9, 0xb0, 0xf1, 0x74,
0x2d, 0x99, 0xfb, 0x91, 0x93, 0x5c, 0x28, 0x8f, 0x27, 0x8e, 0x60, 0x5a, 0x77, 0x3f, 0xfd, 0xfc,
0xf5, 0x65, 0x62, 0x81, 0xce, 0x9b, 0xcb, 0xcb, 0xf7, 0xd4, 0xd2, 0xf9, 0xab, 0x1b, 0x5e, 0xe7,
0xe1, 0xf4, 0x1c, 0x13, 0x48, 0x6d, 0xa2, 0xa6, 0x0f, 0x92, 0xd5, 0x1c, 0x71, 0x89, 0x0b, 0x57,
0xed, 0x94, 0x55, 0x36, 0x0e, 0x57, 0xe9, 0xfd, 0x24, 0x0e, 0xd9, 0x87, 0x73, 0x8d, 0x39, 0xa4,
0xdf, 0x09, 0xa4, 0xa3, 0x41, 0xa2, 0x09, 0x41, 0x8d, 0x1e, 0xfb, 0x42, 0x65, 0x4c, 0x75, 0xcc,
0x99, 0x99, 0x53, 0xdc, 0xb6, 0x12, 0x71, 0x7e, 0x48, 0x16, 0xe9, 0x57, 0x02, 0xe9, 0x68, 0xfc,
0x92, 0x1a, 0x1f, 0x3d, 0xac, 0x85, 0x9c, 0x1d, 0x3d, 0xe0, 0x76, 0xff, 0x01, 0xb7, 0x9f, 0x84,
0x0f, 0x78, 0x9f, 0xeb, 0xe2, 0x58, 0x5c, 0x37, 0xde, 0xbc, 0x7e, 0xd5, 0x10, 0xfa, 0x5d, 0xa7,
0x6e, 0xbb, 0xb2, 0xc5, 0x22, 0x7f, 0x4b, 0xd1, 0x73, 0xde, 0x90, 0x4b, 0x0d, 0xf4, 0x4d, 0x35,
0x96, 0xe4, 0xf7, 0xb0, 0x76, 0x71, 0xa1, 0x9e, 0x36, 0xe2, 0x7b, 0x7f, 0x03, 0x00, 0x00, 0xff,
0xff, 0xaa, 0xd6, 0x8e, 0x16, 0xfe, 0x06, 0x00, 0x00,
}

326
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/iam_token_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,326 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/iam_token_service.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type CreateIamTokenRequest struct {
// Types that are valid to be assigned to Identity:
// *CreateIamTokenRequest_YandexPassportOauthToken
// *CreateIamTokenRequest_Jwt
Identity isCreateIamTokenRequest_Identity `protobuf_oneof:"identity"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateIamTokenRequest) Reset() { *m = CreateIamTokenRequest{} }
func (m *CreateIamTokenRequest) String() string { return proto.CompactTextString(m) }
func (*CreateIamTokenRequest) ProtoMessage() {}
func (*CreateIamTokenRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_iam_token_service_021a8da7029cec45, []int{0}
}
func (m *CreateIamTokenRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateIamTokenRequest.Unmarshal(m, b)
}
func (m *CreateIamTokenRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateIamTokenRequest.Marshal(b, m, deterministic)
}
func (dst *CreateIamTokenRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateIamTokenRequest.Merge(dst, src)
}
func (m *CreateIamTokenRequest) XXX_Size() int {
return xxx_messageInfo_CreateIamTokenRequest.Size(m)
}
func (m *CreateIamTokenRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateIamTokenRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateIamTokenRequest proto.InternalMessageInfo
type isCreateIamTokenRequest_Identity interface {
isCreateIamTokenRequest_Identity()
}
type CreateIamTokenRequest_YandexPassportOauthToken struct {
YandexPassportOauthToken string `protobuf:"bytes,1,opt,name=yandex_passport_oauth_token,json=yandexPassportOauthToken,proto3,oneof"`
}
type CreateIamTokenRequest_Jwt struct {
Jwt string `protobuf:"bytes,2,opt,name=jwt,proto3,oneof"`
}
func (*CreateIamTokenRequest_YandexPassportOauthToken) isCreateIamTokenRequest_Identity() {}
func (*CreateIamTokenRequest_Jwt) isCreateIamTokenRequest_Identity() {}
func (m *CreateIamTokenRequest) GetIdentity() isCreateIamTokenRequest_Identity {
if m != nil {
return m.Identity
}
return nil
}
func (m *CreateIamTokenRequest) GetYandexPassportOauthToken() string {
if x, ok := m.GetIdentity().(*CreateIamTokenRequest_YandexPassportOauthToken); ok {
return x.YandexPassportOauthToken
}
return ""
}
func (m *CreateIamTokenRequest) GetJwt() string {
if x, ok := m.GetIdentity().(*CreateIamTokenRequest_Jwt); ok {
return x.Jwt
}
return ""
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*CreateIamTokenRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _CreateIamTokenRequest_OneofMarshaler, _CreateIamTokenRequest_OneofUnmarshaler, _CreateIamTokenRequest_OneofSizer, []interface{}{
(*CreateIamTokenRequest_YandexPassportOauthToken)(nil),
(*CreateIamTokenRequest_Jwt)(nil),
}
}
func _CreateIamTokenRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*CreateIamTokenRequest)
// identity
switch x := m.Identity.(type) {
case *CreateIamTokenRequest_YandexPassportOauthToken:
b.EncodeVarint(1<<3 | proto.WireBytes)
b.EncodeStringBytes(x.YandexPassportOauthToken)
case *CreateIamTokenRequest_Jwt:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeStringBytes(x.Jwt)
case nil:
default:
return fmt.Errorf("CreateIamTokenRequest.Identity has unexpected type %T", x)
}
return nil
}
func _CreateIamTokenRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*CreateIamTokenRequest)
switch tag {
case 1: // identity.yandex_passport_oauth_token
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Identity = &CreateIamTokenRequest_YandexPassportOauthToken{x}
return true, err
case 2: // identity.jwt
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Identity = &CreateIamTokenRequest_Jwt{x}
return true, err
default:
return false, nil
}
}
func _CreateIamTokenRequest_OneofSizer(msg proto.Message) (n int) {
m := msg.(*CreateIamTokenRequest)
// identity
switch x := m.Identity.(type) {
case *CreateIamTokenRequest_YandexPassportOauthToken:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.YandexPassportOauthToken)))
n += len(x.YandexPassportOauthToken)
case *CreateIamTokenRequest_Jwt:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.Jwt)))
n += len(x.Jwt)
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
type CreateIamTokenResponse struct {
// IAM token for the specified identity.
//
// You should pass the token in the `Authorization` header for any further API requests.
// For example, `Authorization: Bearer [iam_token]`.
IamToken string `protobuf:"bytes,1,opt,name=iam_token,json=iamToken,proto3" json:"iam_token,omitempty"`
// IAM token expiration time, in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
ExpiresAt *timestamp.Timestamp `protobuf:"bytes,2,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateIamTokenResponse) Reset() { *m = CreateIamTokenResponse{} }
func (m *CreateIamTokenResponse) String() string { return proto.CompactTextString(m) }
func (*CreateIamTokenResponse) ProtoMessage() {}
func (*CreateIamTokenResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_iam_token_service_021a8da7029cec45, []int{1}
}
func (m *CreateIamTokenResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateIamTokenResponse.Unmarshal(m, b)
}
func (m *CreateIamTokenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateIamTokenResponse.Marshal(b, m, deterministic)
}
func (dst *CreateIamTokenResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateIamTokenResponse.Merge(dst, src)
}
func (m *CreateIamTokenResponse) XXX_Size() int {
return xxx_messageInfo_CreateIamTokenResponse.Size(m)
}
func (m *CreateIamTokenResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CreateIamTokenResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CreateIamTokenResponse proto.InternalMessageInfo
func (m *CreateIamTokenResponse) GetIamToken() string {
if m != nil {
return m.IamToken
}
return ""
}
func (m *CreateIamTokenResponse) GetExpiresAt() *timestamp.Timestamp {
if m != nil {
return m.ExpiresAt
}
return nil
}
func init() {
proto.RegisterType((*CreateIamTokenRequest)(nil), "yandex.cloud.iam.v1.CreateIamTokenRequest")
proto.RegisterType((*CreateIamTokenResponse)(nil), "yandex.cloud.iam.v1.CreateIamTokenResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// IamTokenServiceClient is the client API for IamTokenService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type IamTokenServiceClient interface {
// Creates an IAM token for the specified identity.
Create(ctx context.Context, in *CreateIamTokenRequest, opts ...grpc.CallOption) (*CreateIamTokenResponse, error)
}
type iamTokenServiceClient struct {
cc *grpc.ClientConn
}
func NewIamTokenServiceClient(cc *grpc.ClientConn) IamTokenServiceClient {
return &iamTokenServiceClient{cc}
}
func (c *iamTokenServiceClient) Create(ctx context.Context, in *CreateIamTokenRequest, opts ...grpc.CallOption) (*CreateIamTokenResponse, error) {
out := new(CreateIamTokenResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.IamTokenService/Create", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// IamTokenServiceServer is the server API for IamTokenService service.
type IamTokenServiceServer interface {
// Creates an IAM token for the specified identity.
Create(context.Context, *CreateIamTokenRequest) (*CreateIamTokenResponse, error)
}
func RegisterIamTokenServiceServer(s *grpc.Server, srv IamTokenServiceServer) {
s.RegisterService(&_IamTokenService_serviceDesc, srv)
}
func _IamTokenService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateIamTokenRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IamTokenServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.IamTokenService/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IamTokenServiceServer).Create(ctx, req.(*CreateIamTokenRequest))
}
return interceptor(ctx, in, info, handler)
}
var _IamTokenService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.iam.v1.IamTokenService",
HandlerType: (*IamTokenServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Create",
Handler: _IamTokenService_Create_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/iam/v1/iam_token_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/iam_token_service.proto", fileDescriptor_iam_token_service_021a8da7029cec45)
}
var fileDescriptor_iam_token_service_021a8da7029cec45 = []byte{
// 382 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xc1, 0x4e, 0xdb, 0x30,
0x18, 0xc7, 0x97, 0x6e, 0xaa, 0x5a, 0x4f, 0xda, 0x26, 0x57, 0x9b, 0xba, 0x74, 0xd3, 0xa6, 0x9c,
0x50, 0xab, 0xda, 0x6a, 0x39, 0x41, 0x85, 0x10, 0xe5, 0x02, 0x27, 0x50, 0xe8, 0x89, 0x4b, 0xe4,
0x36, 0x26, 0x35, 0x34, 0xb6, 0x89, 0xbf, 0x84, 0x56, 0x42, 0x1c, 0x78, 0x01, 0x0e, 0xbc, 0x10,
0x3c, 0x03, 0xaf, 0xc0, 0x83, 0xa0, 0xc4, 0x09, 0x12, 0xa8, 0x07, 0x4e, 0x96, 0xf5, 0xfd, 0xfc,
0xfd, 0xff, 0xdf, 0xdf, 0x1f, 0xea, 0xad, 0x98, 0x0c, 0xf9, 0x92, 0xce, 0x16, 0x2a, 0x0d, 0xa9,
0x60, 0x31, 0xcd, 0x06, 0xf9, 0x11, 0x80, 0xba, 0xe0, 0x32, 0x30, 0x3c, 0xc9, 0xc4, 0x8c, 0x13,
0x9d, 0x28, 0x50, 0xb8, 0x65, 0x61, 0x52, 0xc0, 0x44, 0xb0, 0x98, 0x64, 0x03, 0xf7, 0x4f, 0xa4,
0x54, 0xb4, 0xe0, 0x94, 0x69, 0x41, 0x99, 0x94, 0x0a, 0x18, 0x08, 0x25, 0x8d, 0x7d, 0xe2, 0xfe,
0x2b, 0xab, 0xc5, 0x6d, 0x9a, 0x9e, 0x51, 0x10, 0x31, 0x37, 0xc0, 0x62, 0x5d, 0x02, 0x7f, 0xdf,
0x18, 0xc8, 0xd8, 0x42, 0x84, 0x45, 0x03, 0x5b, 0xf6, 0x6e, 0xd0, 0xcf, 0xfd, 0x84, 0x33, 0xe0,
0x87, 0x2c, 0x9e, 0xe4, 0x96, 0x7c, 0x7e, 0x99, 0x72, 0x03, 0x78, 0x17, 0x75, 0xec, 0xcb, 0x40,
0x33, 0x63, 0xb4, 0x4a, 0x20, 0x50, 0x2c, 0x85, 0xb9, 0x35, 0xde, 0x76, 0xfe, 0x3b, 0x1b, 0xcd,
0x83, 0x4f, 0x7e, 0xdb, 0x42, 0xc7, 0x25, 0x73, 0x94, 0x23, 0x45, 0x1f, 0x8c, 0xd1, 0xe7, 0xf3,
0x2b, 0x68, 0xd7, 0x4a, 0x30, 0xbf, 0x8c, 0x7f, 0xa0, 0x86, 0x08, 0xb9, 0x04, 0x01, 0x2b, 0xfc,
0xe5, 0xe1, 0x71, 0xe0, 0x78, 0x1a, 0xfd, 0x7a, 0xaf, 0x6f, 0xb4, 0x92, 0x86, 0xe3, 0x0e, 0x6a,
0xbe, 0xe6, 0x64, 0xe5, 0xfc, 0x86, 0x28, 0x21, 0xbc, 0x85, 0x10, 0x5f, 0x6a, 0x91, 0x70, 0x13,
0x30, 0xab, 0xf1, 0x75, 0xe8, 0x12, 0x9b, 0x05, 0xa9, 0xb2, 0x20, 0x93, 0x2a, 0x0b, 0xbf, 0x59,
0xd2, 0x7b, 0x30, 0xbc, 0x73, 0xd0, 0xf7, 0x4a, 0xec, 0xc4, 0xc6, 0x8f, 0xaf, 0x51, 0xdd, 0xba,
0xc0, 0x5d, 0xb2, 0xe6, 0x0f, 0xc8, 0xda, 0x88, 0xdc, 0xde, 0x87, 0x58, 0x3b, 0x8e, 0xf7, 0xfb,
0xf6, 0xe9, 0xf9, 0xbe, 0xd6, 0xf2, 0xbe, 0x55, 0x4b, 0x50, 0x0c, 0x66, 0xb6, 0x9d, 0xee, 0x78,
0xe7, 0x74, 0x14, 0x09, 0x98, 0xa7, 0x53, 0x32, 0x53, 0x31, 0xb5, 0x3d, 0xfb, 0xf6, 0xbf, 0x22,
0xd5, 0x8f, 0xb8, 0x2c, 0x06, 0xa2, 0x6b, 0x36, 0x69, 0x24, 0x58, 0x3c, 0xad, 0x17, 0xe5, 0xcd,
0x97, 0x00, 0x00, 0x00, 0xff, 0xff, 0xda, 0xac, 0x14, 0x7c, 0x6b, 0x02, 0x00, 0x00,
}

266
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/key.pb.go generated vendored Normal file
View File

@ -0,0 +1,266 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/key.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type Key_Algorithm int32
const (
Key_ALGORITHM_UNSPECIFIED Key_Algorithm = 0
// RSA with a 2048-bit key size. Default value.
Key_RSA_2048 Key_Algorithm = 1
// RSA with a 4096-bit key size.
Key_RSA_4096 Key_Algorithm = 2
)
var Key_Algorithm_name = map[int32]string{
0: "ALGORITHM_UNSPECIFIED",
1: "RSA_2048",
2: "RSA_4096",
}
var Key_Algorithm_value = map[string]int32{
"ALGORITHM_UNSPECIFIED": 0,
"RSA_2048": 1,
"RSA_4096": 2,
}
func (x Key_Algorithm) String() string {
return proto.EnumName(Key_Algorithm_name, int32(x))
}
func (Key_Algorithm) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_key_8778cd8d03fc7198, []int{0, 0}
}
// A Key resource. For more information, see [Authorized keys](/docs/iam/concepts/authorization/key).
type Key struct {
// ID of the Key resource.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// Types that are valid to be assigned to Subject:
// *Key_UserAccountId
// *Key_ServiceAccountId
Subject isKey_Subject `protobuf_oneof:"subject"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Description of the Key resource. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
// An algorithm used to generate a key pair of the Key resource.
KeyAlgorithm Key_Algorithm `protobuf:"varint,6,opt,name=key_algorithm,json=keyAlgorithm,proto3,enum=yandex.cloud.iam.v1.Key_Algorithm" json:"key_algorithm,omitempty"`
// A public key of the Key resource.
PublicKey string `protobuf:"bytes,7,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Key) Reset() { *m = Key{} }
func (m *Key) String() string { return proto.CompactTextString(m) }
func (*Key) ProtoMessage() {}
func (*Key) Descriptor() ([]byte, []int) {
return fileDescriptor_key_8778cd8d03fc7198, []int{0}
}
func (m *Key) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Key.Unmarshal(m, b)
}
func (m *Key) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Key.Marshal(b, m, deterministic)
}
func (dst *Key) XXX_Merge(src proto.Message) {
xxx_messageInfo_Key.Merge(dst, src)
}
func (m *Key) XXX_Size() int {
return xxx_messageInfo_Key.Size(m)
}
func (m *Key) XXX_DiscardUnknown() {
xxx_messageInfo_Key.DiscardUnknown(m)
}
var xxx_messageInfo_Key proto.InternalMessageInfo
func (m *Key) GetId() string {
if m != nil {
return m.Id
}
return ""
}
type isKey_Subject interface {
isKey_Subject()
}
type Key_UserAccountId struct {
UserAccountId string `protobuf:"bytes,2,opt,name=user_account_id,json=userAccountId,proto3,oneof"`
}
type Key_ServiceAccountId struct {
ServiceAccountId string `protobuf:"bytes,3,opt,name=service_account_id,json=serviceAccountId,proto3,oneof"`
}
func (*Key_UserAccountId) isKey_Subject() {}
func (*Key_ServiceAccountId) isKey_Subject() {}
func (m *Key) GetSubject() isKey_Subject {
if m != nil {
return m.Subject
}
return nil
}
func (m *Key) GetUserAccountId() string {
if x, ok := m.GetSubject().(*Key_UserAccountId); ok {
return x.UserAccountId
}
return ""
}
func (m *Key) GetServiceAccountId() string {
if x, ok := m.GetSubject().(*Key_ServiceAccountId); ok {
return x.ServiceAccountId
}
return ""
}
func (m *Key) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Key) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Key) GetKeyAlgorithm() Key_Algorithm {
if m != nil {
return m.KeyAlgorithm
}
return Key_ALGORITHM_UNSPECIFIED
}
func (m *Key) GetPublicKey() string {
if m != nil {
return m.PublicKey
}
return ""
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*Key) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _Key_OneofMarshaler, _Key_OneofUnmarshaler, _Key_OneofSizer, []interface{}{
(*Key_UserAccountId)(nil),
(*Key_ServiceAccountId)(nil),
}
}
func _Key_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*Key)
// subject
switch x := m.Subject.(type) {
case *Key_UserAccountId:
b.EncodeVarint(2<<3 | proto.WireBytes)
b.EncodeStringBytes(x.UserAccountId)
case *Key_ServiceAccountId:
b.EncodeVarint(3<<3 | proto.WireBytes)
b.EncodeStringBytes(x.ServiceAccountId)
case nil:
default:
return fmt.Errorf("Key.Subject has unexpected type %T", x)
}
return nil
}
func _Key_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*Key)
switch tag {
case 2: // subject.user_account_id
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Subject = &Key_UserAccountId{x}
return true, err
case 3: // subject.service_account_id
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeStringBytes()
m.Subject = &Key_ServiceAccountId{x}
return true, err
default:
return false, nil
}
}
func _Key_OneofSizer(msg proto.Message) (n int) {
m := msg.(*Key)
// subject
switch x := m.Subject.(type) {
case *Key_UserAccountId:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.UserAccountId)))
n += len(x.UserAccountId)
case *Key_ServiceAccountId:
n += 1 // tag and wire
n += proto.SizeVarint(uint64(len(x.ServiceAccountId)))
n += len(x.ServiceAccountId)
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
func init() {
proto.RegisterType((*Key)(nil), "yandex.cloud.iam.v1.Key")
proto.RegisterEnum("yandex.cloud.iam.v1.Key_Algorithm", Key_Algorithm_name, Key_Algorithm_value)
}
func init() { proto.RegisterFile("yandex/cloud/iam/v1/key.proto", fileDescriptor_key_8778cd8d03fc7198) }
var fileDescriptor_key_8778cd8d03fc7198 = []byte{
// 384 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x92, 0x4b, 0x6f, 0xd4, 0x30,
0x14, 0x85, 0x9b, 0x0c, 0xb4, 0xc4, 0x7d, 0x10, 0x19, 0x21, 0x85, 0x4a, 0x15, 0xd1, 0xac, 0xb2,
0xa9, 0xdd, 0x0e, 0x15, 0xa2, 0xaa, 0x58, 0x64, 0xa0, 0xb4, 0xd1, 0xf0, 0x52, 0x5a, 0x36, 0x6c,
0x22, 0xc7, 0xbe, 0xa4, 0x26, 0x0f, 0x47, 0x89, 0x33, 0xc2, 0x6b, 0xfe, 0x38, 0x6a, 0x32, 0x61,
0x66, 0x31, 0xcb, 0x7b, 0xbe, 0xcf, 0xf2, 0xd1, 0xb5, 0xd1, 0x89, 0x61, 0x95, 0x80, 0x3f, 0x94,
0x17, 0xaa, 0x13, 0x54, 0xb2, 0x92, 0x2e, 0xcf, 0x69, 0x0e, 0x86, 0xd4, 0x8d, 0xd2, 0x0a, 0xbf,
0x18, 0x30, 0xe9, 0x31, 0x91, 0xac, 0x24, 0xcb, 0xf3, 0xe3, 0xd7, 0x99, 0x52, 0x59, 0x01, 0xb4,
0x57, 0xd2, 0xee, 0x17, 0xd5, 0xb2, 0x84, 0x56, 0xb3, 0xb2, 0x1e, 0x4e, 0x4d, 0xff, 0x4e, 0xd0,
0x64, 0x01, 0x06, 0x1f, 0x21, 0x5b, 0x0a, 0xcf, 0xf2, 0xad, 0xc0, 0x89, 0x6d, 0x29, 0x70, 0x80,
0x9e, 0x77, 0x2d, 0x34, 0x09, 0xe3, 0x5c, 0x75, 0x95, 0x4e, 0xa4, 0xf0, 0xec, 0x47, 0x78, 0xbb,
0x13, 0x1f, 0x3e, 0x82, 0x70, 0xc8, 0x23, 0x81, 0x09, 0xc2, 0x2d, 0x34, 0x4b, 0xc9, 0x61, 0x53,
0x9e, 0xac, 0x64, 0x77, 0xc5, 0xd6, 0xfe, 0x25, 0x42, 0xbc, 0x01, 0xa6, 0x41, 0x24, 0x4c, 0x7b,
0x4f, 0x7c, 0x2b, 0xd8, 0x9f, 0x1d, 0x93, 0xa1, 0x27, 0x19, 0x7b, 0x92, 0xfb, 0xb1, 0x67, 0xec,
0xac, 0xec, 0x50, 0x63, 0x1f, 0xed, 0x0b, 0x68, 0x79, 0x23, 0x6b, 0x2d, 0x55, 0xe5, 0x3d, 0xed,
0xdb, 0x6e, 0x46, 0xf8, 0x06, 0x1d, 0xe6, 0x60, 0x12, 0x56, 0x64, 0xaa, 0x91, 0xfa, 0xa1, 0xf4,
0x76, 0x7d, 0x2b, 0x38, 0x9a, 0x4d, 0xc9, 0x96, 0xe5, 0x90, 0x05, 0x18, 0x12, 0x8e, 0x66, 0x7c,
0x90, 0x83, 0xf9, 0x3f, 0xe1, 0x13, 0x84, 0xea, 0x2e, 0x2d, 0x24, 0x4f, 0x72, 0x30, 0xde, 0x5e,
0x7f, 0x93, 0x33, 0x24, 0x0b, 0x30, 0xd3, 0x39, 0x72, 0xd6, 0xee, 0x2b, 0xf4, 0x32, 0xfc, 0x7c,
0xf3, 0x2d, 0x8e, 0xee, 0x6f, 0xbf, 0x24, 0x3f, 0xbe, 0xde, 0x7d, 0xbf, 0xfe, 0x10, 0x7d, 0x8a,
0xae, 0x3f, 0xba, 0x3b, 0xf8, 0x00, 0x3d, 0x8b, 0xef, 0xc2, 0x64, 0x76, 0x76, 0xf1, 0xce, 0xb5,
0xc6, 0xe9, 0xe2, 0xec, 0xf2, 0xad, 0x6b, 0xcf, 0x1d, 0xb4, 0xd7, 0x76, 0xe9, 0x6f, 0xe0, 0x7a,
0xfe, 0xfe, 0xe7, 0x55, 0x26, 0xf5, 0x43, 0x97, 0x12, 0xae, 0x4a, 0x3a, 0x74, 0x3d, 0x1d, 0xde,
0x39, 0x53, 0xa7, 0x19, 0x54, 0xfd, 0x5e, 0xe8, 0x96, 0x0f, 0x70, 0x25, 0x59, 0x99, 0xee, 0xf6,
0xf8, 0xcd, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x41, 0xba, 0x65, 0x21, 0x22, 0x02, 0x00, 0x00,
}

624
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/key_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,624 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/key_service.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import empty "github.com/golang/protobuf/ptypes/empty"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type KeyFormat int32
const (
// Privacy-Enhanced Mail (PEM) format. Default value.
KeyFormat_PEM_FILE KeyFormat = 0
)
var KeyFormat_name = map[int32]string{
0: "PEM_FILE",
}
var KeyFormat_value = map[string]int32{
"PEM_FILE": 0,
}
func (x KeyFormat) String() string {
return proto.EnumName(KeyFormat_name, int32(x))
}
func (KeyFormat) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_key_service_16d84045cfb780d5, []int{0}
}
type GetKeyRequest struct {
// ID of the Key resource to return.
// To get the ID use a [KeyService.List] request.
KeyId string `protobuf:"bytes,1,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"`
// Output format of the key.
Format KeyFormat `protobuf:"varint,2,opt,name=format,proto3,enum=yandex.cloud.iam.v1.KeyFormat" json:"format,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetKeyRequest) Reset() { *m = GetKeyRequest{} }
func (m *GetKeyRequest) String() string { return proto.CompactTextString(m) }
func (*GetKeyRequest) ProtoMessage() {}
func (*GetKeyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_key_service_16d84045cfb780d5, []int{0}
}
func (m *GetKeyRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetKeyRequest.Unmarshal(m, b)
}
func (m *GetKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetKeyRequest.Marshal(b, m, deterministic)
}
func (dst *GetKeyRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetKeyRequest.Merge(dst, src)
}
func (m *GetKeyRequest) XXX_Size() int {
return xxx_messageInfo_GetKeyRequest.Size(m)
}
func (m *GetKeyRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetKeyRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetKeyRequest proto.InternalMessageInfo
func (m *GetKeyRequest) GetKeyId() string {
if m != nil {
return m.KeyId
}
return ""
}
func (m *GetKeyRequest) GetFormat() KeyFormat {
if m != nil {
return m.Format
}
return KeyFormat_PEM_FILE
}
type ListKeysRequest struct {
// Output format of the key.
Format KeyFormat `protobuf:"varint,1,opt,name=format,proto3,enum=yandex.cloud.iam.v1.KeyFormat" json:"format,omitempty"`
// ID of the service account to list key pairs for.
// To get the service account ID, use a [yandex.cloud.iam.v1.ServiceAccountService.List] request.
// If not specified, it defaults to the subject that made the request.
ServiceAccountId string `protobuf:"bytes,2,opt,name=service_account_id,json=serviceAccountId,proto3" json:"service_account_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListKeysResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
// Default value: 100.
PageSize int64 `protobuf:"varint,3,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListKeysResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,4,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListKeysRequest) Reset() { *m = ListKeysRequest{} }
func (m *ListKeysRequest) String() string { return proto.CompactTextString(m) }
func (*ListKeysRequest) ProtoMessage() {}
func (*ListKeysRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_key_service_16d84045cfb780d5, []int{1}
}
func (m *ListKeysRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListKeysRequest.Unmarshal(m, b)
}
func (m *ListKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListKeysRequest.Marshal(b, m, deterministic)
}
func (dst *ListKeysRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListKeysRequest.Merge(dst, src)
}
func (m *ListKeysRequest) XXX_Size() int {
return xxx_messageInfo_ListKeysRequest.Size(m)
}
func (m *ListKeysRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListKeysRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListKeysRequest proto.InternalMessageInfo
func (m *ListKeysRequest) GetFormat() KeyFormat {
if m != nil {
return m.Format
}
return KeyFormat_PEM_FILE
}
func (m *ListKeysRequest) GetServiceAccountId() string {
if m != nil {
return m.ServiceAccountId
}
return ""
}
func (m *ListKeysRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListKeysRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListKeysResponse struct {
// List of Key resources.
Keys []*Key `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListKeysRequest.page_size], use
// the [next_page_token] as the value
// for the [ListKeysRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListKeysResponse) Reset() { *m = ListKeysResponse{} }
func (m *ListKeysResponse) String() string { return proto.CompactTextString(m) }
func (*ListKeysResponse) ProtoMessage() {}
func (*ListKeysResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_key_service_16d84045cfb780d5, []int{2}
}
func (m *ListKeysResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListKeysResponse.Unmarshal(m, b)
}
func (m *ListKeysResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListKeysResponse.Marshal(b, m, deterministic)
}
func (dst *ListKeysResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListKeysResponse.Merge(dst, src)
}
func (m *ListKeysResponse) XXX_Size() int {
return xxx_messageInfo_ListKeysResponse.Size(m)
}
func (m *ListKeysResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListKeysResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListKeysResponse proto.InternalMessageInfo
func (m *ListKeysResponse) GetKeys() []*Key {
if m != nil {
return m.Keys
}
return nil
}
func (m *ListKeysResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type CreateKeyRequest struct {
// ID of the service account to create a key pair for.
// To get the service account ID, use a [yandex.cloud.iam.v1.ServiceAccountService.List] request.
// If not specified, it defaults to the subject that made the request.
ServiceAccountId string `protobuf:"bytes,1,opt,name=service_account_id,json=serviceAccountId,proto3" json:"service_account_id,omitempty"`
// Description of the key pair.
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
// Output format of the key.
Format KeyFormat `protobuf:"varint,3,opt,name=format,proto3,enum=yandex.cloud.iam.v1.KeyFormat" json:"format,omitempty"`
// An algorithm used to generate a key pair of the Key resource.
KeyAlgorithm Key_Algorithm `protobuf:"varint,4,opt,name=key_algorithm,json=keyAlgorithm,proto3,enum=yandex.cloud.iam.v1.Key_Algorithm" json:"key_algorithm,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateKeyRequest) Reset() { *m = CreateKeyRequest{} }
func (m *CreateKeyRequest) String() string { return proto.CompactTextString(m) }
func (*CreateKeyRequest) ProtoMessage() {}
func (*CreateKeyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_key_service_16d84045cfb780d5, []int{3}
}
func (m *CreateKeyRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateKeyRequest.Unmarshal(m, b)
}
func (m *CreateKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateKeyRequest.Marshal(b, m, deterministic)
}
func (dst *CreateKeyRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateKeyRequest.Merge(dst, src)
}
func (m *CreateKeyRequest) XXX_Size() int {
return xxx_messageInfo_CreateKeyRequest.Size(m)
}
func (m *CreateKeyRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateKeyRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateKeyRequest proto.InternalMessageInfo
func (m *CreateKeyRequest) GetServiceAccountId() string {
if m != nil {
return m.ServiceAccountId
}
return ""
}
func (m *CreateKeyRequest) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *CreateKeyRequest) GetFormat() KeyFormat {
if m != nil {
return m.Format
}
return KeyFormat_PEM_FILE
}
func (m *CreateKeyRequest) GetKeyAlgorithm() Key_Algorithm {
if m != nil {
return m.KeyAlgorithm
}
return Key_ALGORITHM_UNSPECIFIED
}
type CreateKeyResponse struct {
// Key resource.
Key *Key `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
// A private key of the Key resource.
// This key must be stored securely.
PrivateKey string `protobuf:"bytes,2,opt,name=private_key,json=privateKey,proto3" json:"private_key,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateKeyResponse) Reset() { *m = CreateKeyResponse{} }
func (m *CreateKeyResponse) String() string { return proto.CompactTextString(m) }
func (*CreateKeyResponse) ProtoMessage() {}
func (*CreateKeyResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_key_service_16d84045cfb780d5, []int{4}
}
func (m *CreateKeyResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateKeyResponse.Unmarshal(m, b)
}
func (m *CreateKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateKeyResponse.Marshal(b, m, deterministic)
}
func (dst *CreateKeyResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateKeyResponse.Merge(dst, src)
}
func (m *CreateKeyResponse) XXX_Size() int {
return xxx_messageInfo_CreateKeyResponse.Size(m)
}
func (m *CreateKeyResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CreateKeyResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CreateKeyResponse proto.InternalMessageInfo
func (m *CreateKeyResponse) GetKey() *Key {
if m != nil {
return m.Key
}
return nil
}
func (m *CreateKeyResponse) GetPrivateKey() string {
if m != nil {
return m.PrivateKey
}
return ""
}
type DeleteKeyRequest struct {
// ID of the key to delete.
// To get key ID use a [KeyService.List] request.
KeyId string `protobuf:"bytes,1,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteKeyRequest) Reset() { *m = DeleteKeyRequest{} }
func (m *DeleteKeyRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteKeyRequest) ProtoMessage() {}
func (*DeleteKeyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_key_service_16d84045cfb780d5, []int{5}
}
func (m *DeleteKeyRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteKeyRequest.Unmarshal(m, b)
}
func (m *DeleteKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteKeyRequest.Marshal(b, m, deterministic)
}
func (dst *DeleteKeyRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteKeyRequest.Merge(dst, src)
}
func (m *DeleteKeyRequest) XXX_Size() int {
return xxx_messageInfo_DeleteKeyRequest.Size(m)
}
func (m *DeleteKeyRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteKeyRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteKeyRequest proto.InternalMessageInfo
func (m *DeleteKeyRequest) GetKeyId() string {
if m != nil {
return m.KeyId
}
return ""
}
func init() {
proto.RegisterType((*GetKeyRequest)(nil), "yandex.cloud.iam.v1.GetKeyRequest")
proto.RegisterType((*ListKeysRequest)(nil), "yandex.cloud.iam.v1.ListKeysRequest")
proto.RegisterType((*ListKeysResponse)(nil), "yandex.cloud.iam.v1.ListKeysResponse")
proto.RegisterType((*CreateKeyRequest)(nil), "yandex.cloud.iam.v1.CreateKeyRequest")
proto.RegisterType((*CreateKeyResponse)(nil), "yandex.cloud.iam.v1.CreateKeyResponse")
proto.RegisterType((*DeleteKeyRequest)(nil), "yandex.cloud.iam.v1.DeleteKeyRequest")
proto.RegisterEnum("yandex.cloud.iam.v1.KeyFormat", KeyFormat_name, KeyFormat_value)
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// KeyServiceClient is the client API for KeyService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type KeyServiceClient interface {
// Returns the specified Key resource.
//
// To get the list of available Key resources, make a [List] request.
Get(ctx context.Context, in *GetKeyRequest, opts ...grpc.CallOption) (*Key, error)
// Retrieves the list of Key resources for the specified service account.
List(ctx context.Context, in *ListKeysRequest, opts ...grpc.CallOption) (*ListKeysResponse, error)
// Creates a key pair for the specified service account.
Create(ctx context.Context, in *CreateKeyRequest, opts ...grpc.CallOption) (*CreateKeyResponse, error)
// Deletes the specified key pair.
Delete(ctx context.Context, in *DeleteKeyRequest, opts ...grpc.CallOption) (*empty.Empty, error)
}
type keyServiceClient struct {
cc *grpc.ClientConn
}
func NewKeyServiceClient(cc *grpc.ClientConn) KeyServiceClient {
return &keyServiceClient{cc}
}
func (c *keyServiceClient) Get(ctx context.Context, in *GetKeyRequest, opts ...grpc.CallOption) (*Key, error) {
out := new(Key)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.KeyService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *keyServiceClient) List(ctx context.Context, in *ListKeysRequest, opts ...grpc.CallOption) (*ListKeysResponse, error) {
out := new(ListKeysResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.KeyService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *keyServiceClient) Create(ctx context.Context, in *CreateKeyRequest, opts ...grpc.CallOption) (*CreateKeyResponse, error) {
out := new(CreateKeyResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.KeyService/Create", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *keyServiceClient) Delete(ctx context.Context, in *DeleteKeyRequest, opts ...grpc.CallOption) (*empty.Empty, error) {
out := new(empty.Empty)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.KeyService/Delete", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// KeyServiceServer is the server API for KeyService service.
type KeyServiceServer interface {
// Returns the specified Key resource.
//
// To get the list of available Key resources, make a [List] request.
Get(context.Context, *GetKeyRequest) (*Key, error)
// Retrieves the list of Key resources for the specified service account.
List(context.Context, *ListKeysRequest) (*ListKeysResponse, error)
// Creates a key pair for the specified service account.
Create(context.Context, *CreateKeyRequest) (*CreateKeyResponse, error)
// Deletes the specified key pair.
Delete(context.Context, *DeleteKeyRequest) (*empty.Empty, error)
}
func RegisterKeyServiceServer(s *grpc.Server, srv KeyServiceServer) {
s.RegisterService(&_KeyService_serviceDesc, srv)
}
func _KeyService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(KeyServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.KeyService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(KeyServiceServer).Get(ctx, req.(*GetKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _KeyService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListKeysRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(KeyServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.KeyService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(KeyServiceServer).List(ctx, req.(*ListKeysRequest))
}
return interceptor(ctx, in, info, handler)
}
func _KeyService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(KeyServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.KeyService/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(KeyServiceServer).Create(ctx, req.(*CreateKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _KeyService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(KeyServiceServer).Delete(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.KeyService/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(KeyServiceServer).Delete(ctx, req.(*DeleteKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
var _KeyService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.iam.v1.KeyService",
HandlerType: (*KeyServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _KeyService_Get_Handler,
},
{
MethodName: "List",
Handler: _KeyService_List_Handler,
},
{
MethodName: "Create",
Handler: _KeyService_Create_Handler,
},
{
MethodName: "Delete",
Handler: _KeyService_Delete_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/iam/v1/key_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/key_service.proto", fileDescriptor_key_service_16d84045cfb780d5)
}
var fileDescriptor_key_service_16d84045cfb780d5 = []byte{
// 685 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x41, 0x53, 0xd3, 0x5c,
0x14, 0xfd, 0x42, 0x4b, 0x87, 0x5e, 0x0a, 0x94, 0xf7, 0xa9, 0xd4, 0x2a, 0xda, 0x89, 0x82, 0x9d,
0x2a, 0x49, 0x5b, 0x07, 0x9c, 0x11, 0x58, 0x80, 0x02, 0xc3, 0x14, 0x67, 0x98, 0xe0, 0xca, 0x4d,
0x7d, 0x6d, 0x2f, 0xe5, 0x4d, 0x9b, 0xbc, 0x98, 0xbc, 0x76, 0x08, 0x8e, 0x1b, 0x97, 0x6c, 0xfd,
0x2d, 0xfe, 0x06, 0xd8, 0xeb, 0x4f, 0x70, 0xe1, 0x4f, 0x70, 0x5c, 0x39, 0x79, 0x49, 0x4b, 0x60,
0x52, 0x91, 0x65, 0x72, 0xcf, 0x3b, 0xe7, 0x9e, 0x73, 0xdf, 0xbb, 0xb0, 0xe0, 0x51, 0xab, 0x85,
0xc7, 0x7a, 0xb3, 0xcb, 0x7b, 0x2d, 0x9d, 0x51, 0x53, 0xef, 0x57, 0xf4, 0x0e, 0x7a, 0x75, 0x17,
0x9d, 0x3e, 0x6b, 0xa2, 0x66, 0x3b, 0x5c, 0x70, 0xf2, 0x7f, 0x00, 0xd3, 0x24, 0x4c, 0x63, 0xd4,
0xd4, 0xfa, 0x95, 0xfc, 0xfd, 0x36, 0xe7, 0xed, 0x2e, 0xea, 0xd4, 0x66, 0x3a, 0xb5, 0x2c, 0x2e,
0xa8, 0x60, 0xdc, 0x72, 0x83, 0x23, 0xf9, 0x7b, 0x61, 0x55, 0x7e, 0x35, 0x7a, 0x87, 0x3a, 0x9a,
0xb6, 0xf0, 0xc2, 0xe2, 0xfc, 0x08, 0xd9, 0xd8, 0x72, 0x9f, 0x76, 0x59, 0x4b, 0x72, 0x07, 0x65,
0xb5, 0x0b, 0x53, 0x3b, 0x28, 0x6a, 0xe8, 0x19, 0xf8, 0xa1, 0x87, 0xae, 0x20, 0x8f, 0x20, 0xe5,
0xf7, 0xcc, 0x5a, 0x39, 0xa5, 0xa0, 0x14, 0xd3, 0x9b, 0x99, 0x9f, 0x67, 0x15, 0xe5, 0xf4, 0xbc,
0x92, 0x5c, 0x5b, 0x5f, 0x2e, 0x1b, 0xe3, 0x1d, 0xf4, 0x76, 0x5b, 0x64, 0x05, 0x52, 0x87, 0xdc,
0x31, 0xa9, 0xc8, 0x8d, 0x15, 0x94, 0xe2, 0x74, 0xf5, 0x81, 0x16, 0x63, 0x4a, 0xab, 0xa1, 0xb7,
0x2d, 0x51, 0x46, 0x88, 0x56, 0xbf, 0x2b, 0x30, 0xb3, 0xc7, 0x5c, 0x5f, 0xcf, 0x1d, 0x08, 0x5e,
0x70, 0x29, 0x37, 0xe1, 0x22, 0x2b, 0x40, 0xc2, 0x60, 0xeb, 0xb4, 0xd9, 0xe4, 0x3d, 0x4b, 0xf8,
0x4d, 0x8f, 0xc9, 0xa6, 0x27, 0x86, 0x0d, 0x67, 0x43, 0xcc, 0x46, 0x00, 0xd9, 0x6d, 0x91, 0x27,
0x90, 0xb6, 0x69, 0x1b, 0xeb, 0x2e, 0x3b, 0xc1, 0x5c, 0xa2, 0xa0, 0x14, 0x13, 0x9b, 0xf0, 0xfb,
0xac, 0x92, 0x5a, 0x5b, 0xaf, 0x94, 0xcb, 0x65, 0x63, 0xc2, 0x2f, 0x1e, 0xb0, 0x13, 0x24, 0x45,
0x00, 0x09, 0x14, 0xbc, 0x83, 0x56, 0x2e, 0x29, 0x89, 0xd3, 0xa7, 0xe7, 0x95, 0x71, 0x89, 0x34,
0x24, 0xcb, 0x5b, 0xbf, 0xa6, 0x1e, 0x41, 0xf6, 0xc2, 0x95, 0x6b, 0x73, 0xcb, 0x45, 0xf2, 0x0c,
0x92, 0x1d, 0xf4, 0xdc, 0x9c, 0x52, 0x48, 0x14, 0x27, 0xab, 0xb9, 0x51, 0xa6, 0x0c, 0x89, 0x22,
0x8b, 0x30, 0x63, 0xe1, 0xb1, 0xa8, 0x47, 0x04, 0xa5, 0x13, 0x63, 0xca, 0xff, 0xbd, 0x3f, 0x54,
0xfa, 0xa5, 0x40, 0xf6, 0x95, 0x83, 0x54, 0x60, 0x64, 0x64, 0xf1, 0x49, 0x28, 0xd7, 0x26, 0xf1,
0x14, 0x26, 0x5b, 0xe8, 0x36, 0x1d, 0x66, 0xfb, 0x17, 0x22, 0x8c, 0x2e, 0x74, 0x58, 0x5d, 0x5e,
0x31, 0xa2, 0xd5, 0xc8, 0x98, 0x12, 0x37, 0x1a, 0xd3, 0x0e, 0x4c, 0xf9, 0xf7, 0x89, 0x76, 0xdb,
0xdc, 0x61, 0xe2, 0xc8, 0x94, 0x41, 0x4e, 0x57, 0xd5, 0x51, 0xc7, 0xb5, 0x8d, 0x01, 0xd2, 0xc8,
0x74, 0xd0, 0x1b, 0x7e, 0xa9, 0xef, 0x61, 0x36, 0xe2, 0x3c, 0x4c, 0xb9, 0x04, 0x89, 0x0e, 0x7a,
0xd2, 0xeb, 0xdf, 0x42, 0xf6, 0x41, 0xe4, 0x21, 0x4c, 0xda, 0x0e, 0xeb, 0x53, 0x81, 0x75, 0xff,
0x4c, 0x90, 0x2f, 0x84, 0xbf, 0x6a, 0xe8, 0xa9, 0x2f, 0x20, 0xfb, 0x1a, 0xbb, 0x78, 0x29, 0xdb,
0x7f, 0x79, 0x0e, 0xa5, 0xbb, 0x90, 0x1e, 0x1a, 0x27, 0x19, 0x98, 0xd8, 0xdf, 0x7a, 0x53, 0xdf,
0xde, 0xdd, 0xdb, 0xca, 0xfe, 0x57, 0xfd, 0x9a, 0x00, 0xa8, 0xa1, 0x77, 0x10, 0x64, 0x4f, 0x1a,
0x90, 0xd8, 0x41, 0x41, 0xe2, 0xdd, 0x5f, 0x7a, 0x88, 0xf9, 0x91, 0x6e, 0xd4, 0xf9, 0xcf, 0xdf,
0x7e, 0x7c, 0x19, 0x9b, 0x23, 0xb7, 0x23, 0xaf, 0xdd, 0xd5, 0x3f, 0x06, 0x7d, 0x7e, 0x22, 0x0c,
0x92, 0xfe, 0x6d, 0x24, 0x8f, 0x63, 0x09, 0xae, 0x3c, 0xbf, 0xfc, 0xc2, 0x35, 0xa8, 0x20, 0x68,
0xf5, 0x96, 0xd4, 0x9c, 0x26, 0x99, 0xa8, 0x26, 0xb1, 0x21, 0x15, 0xcc, 0x84, 0xc4, 0xd3, 0x5c,
0xbd, 0xaa, 0xf9, 0xc5, 0xeb, 0x60, 0xa1, 0xdc, 0x9c, 0x94, 0x9b, 0x55, 0x2f, 0xc9, 0xbd, 0x54,
0x4a, 0xe4, 0x10, 0x52, 0xc1, 0x8c, 0x46, 0x28, 0x5e, 0x1d, 0x60, 0xfe, 0x8e, 0x16, 0x2c, 0x4f,
0x6d, 0xb0, 0x3c, 0xb5, 0x2d, 0x7f, 0x79, 0x0e, 0x42, 0x2c, 0xc5, 0x87, 0xb8, 0xb9, 0xfe, 0x6e,
0xb5, 0xcd, 0xc4, 0x51, 0xaf, 0xa1, 0x35, 0xb9, 0xa9, 0x07, 0x4a, 0x4b, 0xc1, 0x0e, 0x6d, 0xf3,
0xa5, 0x36, 0x5a, 0x92, 0x4e, 0x8f, 0xd9, 0xbd, 0xab, 0x8c, 0x9a, 0x8d, 0x94, 0x2c, 0x3f, 0xff,
0x13, 0x00, 0x00, 0xff, 0xff, 0xca, 0x77, 0xed, 0xa5, 0x14, 0x06, 0x00, 0x00,
}

90
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/role.pb.go generated vendored Normal file
View File

@ -0,0 +1,90 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/role.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// A Role resource. For more information, see [Roles](/docs/iam/concepts/access-control/roles).
type Role struct {
// ID of the role.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// Description of the role. 0-256 characters long.
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Role) Reset() { *m = Role{} }
func (m *Role) String() string { return proto.CompactTextString(m) }
func (*Role) ProtoMessage() {}
func (*Role) Descriptor() ([]byte, []int) {
return fileDescriptor_role_656bcd2fea39e7f2, []int{0}
}
func (m *Role) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Role.Unmarshal(m, b)
}
func (m *Role) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Role.Marshal(b, m, deterministic)
}
func (dst *Role) XXX_Merge(src proto.Message) {
xxx_messageInfo_Role.Merge(dst, src)
}
func (m *Role) XXX_Size() int {
return xxx_messageInfo_Role.Size(m)
}
func (m *Role) XXX_DiscardUnknown() {
xxx_messageInfo_Role.DiscardUnknown(m)
}
var xxx_messageInfo_Role proto.InternalMessageInfo
func (m *Role) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Role) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func init() {
proto.RegisterType((*Role)(nil), "yandex.cloud.iam.v1.Role")
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/role.proto", fileDescriptor_role_656bcd2fea39e7f2)
}
var fileDescriptor_role_656bcd2fea39e7f2 = []byte{
// 155 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xab, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0xcf, 0x4c, 0xcc, 0xd5, 0x2f, 0x33, 0xd4,
0x2f, 0xca, 0xcf, 0x49, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x86, 0xc8, 0xeb, 0x81,
0xe5, 0xf5, 0x32, 0x13, 0x73, 0xf5, 0xca, 0x0c, 0x95, 0x2c, 0xb8, 0x58, 0x82, 0xf2, 0x73, 0x52,
0x85, 0xf8, 0xb8, 0x98, 0x32, 0x53, 0x24, 0x18, 0x15, 0x18, 0x35, 0x38, 0x83, 0x98, 0x32, 0x53,
0x84, 0x14, 0xb8, 0xb8, 0x53, 0x52, 0x8b, 0x93, 0x8b, 0x32, 0x0b, 0x4a, 0x32, 0xf3, 0xf3, 0x24,
0x98, 0xc0, 0x12, 0xc8, 0x42, 0x4e, 0xb6, 0x51, 0xd6, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a,
0xc9, 0xf9, 0xb9, 0xfa, 0x10, 0xb3, 0x75, 0x21, 0x76, 0xa7, 0xe7, 0xeb, 0xa6, 0xa7, 0xe6, 0x81,
0x6d, 0xd5, 0xc7, 0xe2, 0x28, 0xeb, 0xcc, 0xc4, 0xdc, 0x24, 0x36, 0xb0, 0xb4, 0x31, 0x20, 0x00,
0x00, 0xff, 0xff, 0x48, 0x72, 0x28, 0xb9, 0xb6, 0x00, 0x00, 0x00,
}

336
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/role_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,336 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/role_service.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetRoleRequest struct {
// ID of the Role resource to return.
// To get the role ID, use a [RoleService.List] request.
RoleId string `protobuf:"bytes,1,opt,name=role_id,json=roleId,proto3" json:"role_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetRoleRequest) Reset() { *m = GetRoleRequest{} }
func (m *GetRoleRequest) String() string { return proto.CompactTextString(m) }
func (*GetRoleRequest) ProtoMessage() {}
func (*GetRoleRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_role_service_e49934510c2989c5, []int{0}
}
func (m *GetRoleRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetRoleRequest.Unmarshal(m, b)
}
func (m *GetRoleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetRoleRequest.Marshal(b, m, deterministic)
}
func (dst *GetRoleRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetRoleRequest.Merge(dst, src)
}
func (m *GetRoleRequest) XXX_Size() int {
return xxx_messageInfo_GetRoleRequest.Size(m)
}
func (m *GetRoleRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetRoleRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetRoleRequest proto.InternalMessageInfo
func (m *GetRoleRequest) GetRoleId() string {
if m != nil {
return m.RoleId
}
return ""
}
type ListRolesRequest struct {
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size],
// the service returns a [ListRolesResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
// Default value: 100.
PageSize int64 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token]
// to the [ListRolesResponse.next_page_token]
// returned by a previous list request.
PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
// A filter expression that filters resources listed in the response.
Filter string `protobuf:"bytes,3,opt,name=filter,proto3" json:"filter,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListRolesRequest) Reset() { *m = ListRolesRequest{} }
func (m *ListRolesRequest) String() string { return proto.CompactTextString(m) }
func (*ListRolesRequest) ProtoMessage() {}
func (*ListRolesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_role_service_e49934510c2989c5, []int{1}
}
func (m *ListRolesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListRolesRequest.Unmarshal(m, b)
}
func (m *ListRolesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListRolesRequest.Marshal(b, m, deterministic)
}
func (dst *ListRolesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListRolesRequest.Merge(dst, src)
}
func (m *ListRolesRequest) XXX_Size() int {
return xxx_messageInfo_ListRolesRequest.Size(m)
}
func (m *ListRolesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListRolesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListRolesRequest proto.InternalMessageInfo
func (m *ListRolesRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListRolesRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
func (m *ListRolesRequest) GetFilter() string {
if m != nil {
return m.Filter
}
return ""
}
type ListRolesResponse struct {
// List of Role resources.
Roles []*Role `protobuf:"bytes,1,rep,name=roles,proto3" json:"roles,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListRolesRequest.page_size], use
// the [next_page_token] as the value
// for the [ListRolesRequest.page_token] query parameter
// in the next list request. Each subsequent list request will have its own
// [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListRolesResponse) Reset() { *m = ListRolesResponse{} }
func (m *ListRolesResponse) String() string { return proto.CompactTextString(m) }
func (*ListRolesResponse) ProtoMessage() {}
func (*ListRolesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_role_service_e49934510c2989c5, []int{2}
}
func (m *ListRolesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListRolesResponse.Unmarshal(m, b)
}
func (m *ListRolesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListRolesResponse.Marshal(b, m, deterministic)
}
func (dst *ListRolesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListRolesResponse.Merge(dst, src)
}
func (m *ListRolesResponse) XXX_Size() int {
return xxx_messageInfo_ListRolesResponse.Size(m)
}
func (m *ListRolesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListRolesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListRolesResponse proto.InternalMessageInfo
func (m *ListRolesResponse) GetRoles() []*Role {
if m != nil {
return m.Roles
}
return nil
}
func (m *ListRolesResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetRoleRequest)(nil), "yandex.cloud.iam.v1.GetRoleRequest")
proto.RegisterType((*ListRolesRequest)(nil), "yandex.cloud.iam.v1.ListRolesRequest")
proto.RegisterType((*ListRolesResponse)(nil), "yandex.cloud.iam.v1.ListRolesResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// RoleServiceClient is the client API for RoleService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RoleServiceClient interface {
// Returns the specified Role resource.
//
// To get the list of available Role resources, use a [List] request.
Get(ctx context.Context, in *GetRoleRequest, opts ...grpc.CallOption) (*Role, error)
// Retrieves the list of Role resources.
List(ctx context.Context, in *ListRolesRequest, opts ...grpc.CallOption) (*ListRolesResponse, error)
}
type roleServiceClient struct {
cc *grpc.ClientConn
}
func NewRoleServiceClient(cc *grpc.ClientConn) RoleServiceClient {
return &roleServiceClient{cc}
}
func (c *roleServiceClient) Get(ctx context.Context, in *GetRoleRequest, opts ...grpc.CallOption) (*Role, error) {
out := new(Role)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.RoleService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *roleServiceClient) List(ctx context.Context, in *ListRolesRequest, opts ...grpc.CallOption) (*ListRolesResponse, error) {
out := new(ListRolesResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.RoleService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// RoleServiceServer is the server API for RoleService service.
type RoleServiceServer interface {
// Returns the specified Role resource.
//
// To get the list of available Role resources, use a [List] request.
Get(context.Context, *GetRoleRequest) (*Role, error)
// Retrieves the list of Role resources.
List(context.Context, *ListRolesRequest) (*ListRolesResponse, error)
}
func RegisterRoleServiceServer(s *grpc.Server, srv RoleServiceServer) {
s.RegisterService(&_RoleService_serviceDesc, srv)
}
func _RoleService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetRoleRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RoleServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.RoleService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RoleServiceServer).Get(ctx, req.(*GetRoleRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RoleService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListRolesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RoleServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.RoleService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RoleServiceServer).List(ctx, req.(*ListRolesRequest))
}
return interceptor(ctx, in, info, handler)
}
var _RoleService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.iam.v1.RoleService",
HandlerType: (*RoleServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _RoleService_Get_Handler,
},
{
MethodName: "List",
Handler: _RoleService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/iam/v1/role_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/role_service.proto", fileDescriptor_role_service_e49934510c2989c5)
}
var fileDescriptor_role_service_e49934510c2989c5 = []byte{
// 431 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x52, 0x3f, 0x6f, 0xd3, 0x40,
0x14, 0x97, 0x9b, 0x36, 0x90, 0x57, 0x4a, 0xe1, 0x10, 0xc2, 0xb5, 0xf8, 0x53, 0x19, 0x35, 0x64,
0xa9, 0xcf, 0x2e, 0x42, 0x0c, 0x6d, 0x96, 0x2c, 0x15, 0x12, 0x03, 0x72, 0x99, 0x58, 0xa2, 0x6b,
0xfc, 0x6a, 0x4e, 0x9c, 0xef, 0x8c, 0xef, 0x62, 0x95, 0x22, 0x16, 0x36, 0xb2, 0xf2, 0xa1, 0x9a,
0x9d, 0x8f, 0x00, 0x03, 0x9f, 0x81, 0x09, 0xf9, 0x2e, 0x45, 0x4d, 0xe5, 0x8a, 0xf5, 0x7e, 0x7f,
0xef, 0xbd, 0x07, 0xfd, 0x4f, 0x4c, 0x66, 0x78, 0x4a, 0x27, 0x42, 0x4d, 0x33, 0xca, 0x59, 0x41,
0xeb, 0x84, 0x56, 0x4a, 0xe0, 0x58, 0x63, 0x55, 0xf3, 0x09, 0x46, 0x65, 0xa5, 0x8c, 0x22, 0xf7,
0x1c, 0x2f, 0xb2, 0xbc, 0x88, 0xb3, 0x22, 0xaa, 0x93, 0xe0, 0x61, 0xae, 0x54, 0x2e, 0x90, 0xb2,
0x92, 0x53, 0x26, 0xa5, 0x32, 0xcc, 0x70, 0x25, 0xb5, 0x93, 0x04, 0x8f, 0x96, 0xac, 0x6b, 0x26,
0x78, 0x66, 0xf1, 0x05, 0xfc, 0xf8, 0xba, 0x64, 0x87, 0x87, 0x2f, 0xe1, 0xf6, 0x21, 0x9a, 0x54,
0x09, 0x4c, 0xf1, 0xe3, 0x14, 0xb5, 0x21, 0x3b, 0x70, 0xc3, 0x36, 0xe3, 0x99, 0xef, 0x6d, 0x7b,
0x83, 0xde, 0xe8, 0xd6, 0xef, 0xf3, 0xc4, 0x9b, 0xcd, 0x93, 0xd5, 0x83, 0xe1, 0x8b, 0x38, 0xed,
0x36, 0xe0, 0xab, 0x2c, 0xfc, 0xe6, 0xc1, 0x9d, 0xd7, 0x5c, 0x5b, 0xa9, 0xbe, 0xd0, 0x3e, 0x83,
0x5e, 0xc9, 0x72, 0x1c, 0x6b, 0x7e, 0x86, 0x56, 0xdd, 0x19, 0xc1, 0x9f, 0xf3, 0xa4, 0x7b, 0x30,
0x4c, 0xe2, 0x38, 0x4e, 0x6f, 0x36, 0xe0, 0x11, 0x3f, 0x43, 0x32, 0x00, 0xb0, 0x44, 0xa3, 0x3e,
0xa0, 0xf4, 0x57, 0x6c, 0x4e, 0x6f, 0x36, 0x4f, 0xd6, 0x2c, 0x33, 0xb5, 0x2e, 0x6f, 0x1b, 0x8c,
0x84, 0xd0, 0x3d, 0xe1, 0xc2, 0x60, 0xe5, 0x77, 0x2c, 0x0b, 0x66, 0xf3, 0x7f, 0x7e, 0x0b, 0x24,
0x14, 0x70, 0xf7, 0x52, 0x15, 0x5d, 0x2a, 0xa9, 0x91, 0x50, 0x58, 0x6b, 0xaa, 0x6a, 0xdf, 0xdb,
0xee, 0x0c, 0xd6, 0xf7, 0xb6, 0xa2, 0x96, 0xd9, 0x46, 0xf6, 0xe3, 0x8e, 0x47, 0xfa, 0xb0, 0x29,
0xf1, 0xd4, 0x8c, 0xaf, 0x16, 0x4b, 0x37, 0x9a, 0xe7, 0x37, 0x17, 0x8d, 0xf6, 0x7e, 0x7a, 0xb0,
0xde, 0xe8, 0x8e, 0xdc, 0xea, 0xc8, 0x09, 0x74, 0x0e, 0xd1, 0x90, 0xa7, 0xad, 0x01, 0xcb, 0xc3,
0x0d, 0xae, 0x6f, 0x11, 0x3e, 0xf9, 0xfa, 0xe3, 0xd7, 0xf7, 0x95, 0x2d, 0xf2, 0xe0, 0xf2, 0x96,
0x34, 0xfd, 0xbc, 0x58, 0xc6, 0x17, 0x22, 0x60, 0xb5, 0xf9, 0x25, 0xd9, 0x69, 0xf5, 0xb8, 0xba,
0x8b, 0xa0, 0xff, 0x3f, 0x9a, 0x9b, 0x53, 0x78, 0xdf, 0xe6, 0x6e, 0x92, 0x8d, 0xa5, 0xdc, 0xd1,
0xf0, 0xdd, 0x7e, 0xce, 0xcd, 0xfb, 0xe9, 0x71, 0x34, 0x51, 0x05, 0x75, 0x56, 0xbb, 0xee, 0x8a,
0x72, 0xb5, 0x9b, 0xa3, 0xb4, 0xf7, 0x43, 0x5b, 0xce, 0x6b, 0x9f, 0xb3, 0xe2, 0xb8, 0x6b, 0xe1,
0xe7, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x85, 0xbc, 0xc9, 0x90, 0xfa, 0x02, 0x00, 0x00,
}

127
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/service_account.pb.go generated vendored Normal file
View File

@ -0,0 +1,127 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/service_account.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// A ServiceAccount resource. For more information, see [Service accounts](/docs/iam/concepts/users/service-accounts).
type ServiceAccount struct {
// ID of the service account.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the service account belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Name of the service account.
// The name is unique within the cloud. 3-63 characters long.
Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
// Description of the service account. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ServiceAccount) Reset() { *m = ServiceAccount{} }
func (m *ServiceAccount) String() string { return proto.CompactTextString(m) }
func (*ServiceAccount) ProtoMessage() {}
func (*ServiceAccount) Descriptor() ([]byte, []int) {
return fileDescriptor_service_account_ff4a14d624b4e70e, []int{0}
}
func (m *ServiceAccount) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ServiceAccount.Unmarshal(m, b)
}
func (m *ServiceAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ServiceAccount.Marshal(b, m, deterministic)
}
func (dst *ServiceAccount) XXX_Merge(src proto.Message) {
xxx_messageInfo_ServiceAccount.Merge(dst, src)
}
func (m *ServiceAccount) XXX_Size() int {
return xxx_messageInfo_ServiceAccount.Size(m)
}
func (m *ServiceAccount) XXX_DiscardUnknown() {
xxx_messageInfo_ServiceAccount.DiscardUnknown(m)
}
var xxx_messageInfo_ServiceAccount proto.InternalMessageInfo
func (m *ServiceAccount) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *ServiceAccount) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *ServiceAccount) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *ServiceAccount) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *ServiceAccount) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func init() {
proto.RegisterType((*ServiceAccount)(nil), "yandex.cloud.iam.v1.ServiceAccount")
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/service_account.proto", fileDescriptor_service_account_ff4a14d624b4e70e)
}
var fileDescriptor_service_account_ff4a14d624b4e70e = []byte{
// 269 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xc1, 0x4b, 0xc3, 0x30,
0x18, 0xc5, 0x69, 0x9d, 0x62, 0x33, 0xd8, 0x21, 0x5e, 0x4a, 0x45, 0x2c, 0x9e, 0xe6, 0x61, 0x09,
0xd3, 0x93, 0x0c, 0x0f, 0xf3, 0xe6, 0x75, 0x7a, 0xf2, 0x52, 0xbe, 0x26, 0xdf, 0xea, 0x07, 0x4d,
0x53, 0xd2, 0xb4, 0xe8, 0x3f, 0xe5, 0xdf, 0x28, 0x26, 0x0e, 0x14, 0x76, 0x0b, 0xef, 0xbd, 0xe4,
0xfd, 0x5e, 0xd8, 0xed, 0x27, 0x74, 0x1a, 0x3f, 0xa4, 0x6a, 0xed, 0xa8, 0x25, 0x81, 0x91, 0xd3,
0x5a, 0x0e, 0xe8, 0x26, 0x52, 0x58, 0x81, 0x52, 0x76, 0xec, 0xbc, 0xe8, 0x9d, 0xf5, 0x96, 0x5f,
0xc4, 0xa8, 0x08, 0x51, 0x41, 0x60, 0xc4, 0xb4, 0x2e, 0xae, 0x1b, 0x6b, 0x9b, 0x16, 0x65, 0x88,
0xd4, 0xe3, 0x5e, 0x7a, 0x32, 0x38, 0x78, 0x30, 0x7d, 0xbc, 0x55, 0x5c, 0xfd, 0x2b, 0x98, 0xa0,
0x25, 0x0d, 0x9e, 0x6c, 0x17, 0xed, 0x9b, 0xaf, 0x84, 0x2d, 0x5e, 0x62, 0xdd, 0x36, 0xb6, 0xf1,
0x05, 0x4b, 0x49, 0xe7, 0x49, 0x99, 0x2c, 0xb3, 0x5d, 0x4a, 0x9a, 0x5f, 0xb2, 0x6c, 0x6f, 0x5b,
0x8d, 0xae, 0x22, 0x9d, 0xa7, 0x41, 0x3e, 0x8f, 0xc2, 0xb3, 0xe6, 0x0f, 0x8c, 0x29, 0x87, 0xe0,
0x51, 0x57, 0xe0, 0xf3, 0x93, 0x32, 0x59, 0xce, 0xef, 0x0a, 0x11, 0xa1, 0xc4, 0x01, 0x4a, 0xbc,
0x1e, 0xa0, 0x76, 0xd9, 0x6f, 0x7a, 0xeb, 0x39, 0x67, 0xb3, 0x0e, 0x0c, 0xe6, 0xb3, 0xf0, 0x64,
0x38, 0xf3, 0x92, 0xcd, 0x35, 0x0e, 0xca, 0x51, 0xff, 0xc3, 0x98, 0x9f, 0x06, 0xeb, 0xaf, 0xf4,
0xf4, 0xf8, 0xb6, 0x69, 0xc8, 0xbf, 0x8f, 0xb5, 0x50, 0xd6, 0xc8, 0x38, 0x6e, 0x15, 0xc7, 0x35,
0x76, 0xd5, 0x60, 0x17, 0x4a, 0xe5, 0x91, 0x6f, 0xdd, 0x10, 0x98, 0xfa, 0x2c, 0xd8, 0xf7, 0xdf,
0x01, 0x00, 0x00, 0xff, 0xff, 0x65, 0x42, 0x1f, 0xbf, 0x78, 0x01, 0x00, 0x00,
}

1041
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/service_account_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

221
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/user_account.pb.go generated vendored Normal file
View File

@ -0,0 +1,221 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/user_account.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Currently represents only [Yandex.Passport account](/docs/iam/concepts/#passport).
type UserAccount struct {
// ID of the user account.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// Types that are valid to be assigned to UserAccount:
// *UserAccount_YandexPassportUserAccount
UserAccount isUserAccount_UserAccount `protobuf_oneof:"user_account"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UserAccount) Reset() { *m = UserAccount{} }
func (m *UserAccount) String() string { return proto.CompactTextString(m) }
func (*UserAccount) ProtoMessage() {}
func (*UserAccount) Descriptor() ([]byte, []int) {
return fileDescriptor_user_account_ced378befb1b3d2f, []int{0}
}
func (m *UserAccount) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UserAccount.Unmarshal(m, b)
}
func (m *UserAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UserAccount.Marshal(b, m, deterministic)
}
func (dst *UserAccount) XXX_Merge(src proto.Message) {
xxx_messageInfo_UserAccount.Merge(dst, src)
}
func (m *UserAccount) XXX_Size() int {
return xxx_messageInfo_UserAccount.Size(m)
}
func (m *UserAccount) XXX_DiscardUnknown() {
xxx_messageInfo_UserAccount.DiscardUnknown(m)
}
var xxx_messageInfo_UserAccount proto.InternalMessageInfo
func (m *UserAccount) GetId() string {
if m != nil {
return m.Id
}
return ""
}
type isUserAccount_UserAccount interface {
isUserAccount_UserAccount()
}
type UserAccount_YandexPassportUserAccount struct {
YandexPassportUserAccount *YandexPassportUserAccount `protobuf:"bytes,2,opt,name=yandex_passport_user_account,json=yandexPassportUserAccount,proto3,oneof"`
}
func (*UserAccount_YandexPassportUserAccount) isUserAccount_UserAccount() {}
func (m *UserAccount) GetUserAccount() isUserAccount_UserAccount {
if m != nil {
return m.UserAccount
}
return nil
}
func (m *UserAccount) GetYandexPassportUserAccount() *YandexPassportUserAccount {
if x, ok := m.GetUserAccount().(*UserAccount_YandexPassportUserAccount); ok {
return x.YandexPassportUserAccount
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*UserAccount) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _UserAccount_OneofMarshaler, _UserAccount_OneofUnmarshaler, _UserAccount_OneofSizer, []interface{}{
(*UserAccount_YandexPassportUserAccount)(nil),
}
}
func _UserAccount_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*UserAccount)
// user_account
switch x := m.UserAccount.(type) {
case *UserAccount_YandexPassportUserAccount:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.YandexPassportUserAccount); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("UserAccount.UserAccount has unexpected type %T", x)
}
return nil
}
func _UserAccount_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*UserAccount)
switch tag {
case 2: // user_account.yandex_passport_user_account
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(YandexPassportUserAccount)
err := b.DecodeMessage(msg)
m.UserAccount = &UserAccount_YandexPassportUserAccount{msg}
return true, err
default:
return false, nil
}
}
func _UserAccount_OneofSizer(msg proto.Message) (n int) {
m := msg.(*UserAccount)
// user_account
switch x := m.UserAccount.(type) {
case *UserAccount_YandexPassportUserAccount:
s := proto.Size(x.YandexPassportUserAccount)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// A YandexPassportUserAccount resource. For more information, see [Yandex.Passport account](/docs/iam/concepts/#passport).
type YandexPassportUserAccount struct {
// Login of the Yandex.Passport user account.
Login string `protobuf:"bytes,1,opt,name=login,proto3" json:"login,omitempty"`
// Default email of the Yandex.Passport user account.
DefaultEmail string `protobuf:"bytes,2,opt,name=default_email,json=defaultEmail,proto3" json:"default_email,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *YandexPassportUserAccount) Reset() { *m = YandexPassportUserAccount{} }
func (m *YandexPassportUserAccount) String() string { return proto.CompactTextString(m) }
func (*YandexPassportUserAccount) ProtoMessage() {}
func (*YandexPassportUserAccount) Descriptor() ([]byte, []int) {
return fileDescriptor_user_account_ced378befb1b3d2f, []int{1}
}
func (m *YandexPassportUserAccount) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_YandexPassportUserAccount.Unmarshal(m, b)
}
func (m *YandexPassportUserAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_YandexPassportUserAccount.Marshal(b, m, deterministic)
}
func (dst *YandexPassportUserAccount) XXX_Merge(src proto.Message) {
xxx_messageInfo_YandexPassportUserAccount.Merge(dst, src)
}
func (m *YandexPassportUserAccount) XXX_Size() int {
return xxx_messageInfo_YandexPassportUserAccount.Size(m)
}
func (m *YandexPassportUserAccount) XXX_DiscardUnknown() {
xxx_messageInfo_YandexPassportUserAccount.DiscardUnknown(m)
}
var xxx_messageInfo_YandexPassportUserAccount proto.InternalMessageInfo
func (m *YandexPassportUserAccount) GetLogin() string {
if m != nil {
return m.Login
}
return ""
}
func (m *YandexPassportUserAccount) GetDefaultEmail() string {
if m != nil {
return m.DefaultEmail
}
return ""
}
func init() {
proto.RegisterType((*UserAccount)(nil), "yandex.cloud.iam.v1.UserAccount")
proto.RegisterType((*YandexPassportUserAccount)(nil), "yandex.cloud.iam.v1.YandexPassportUserAccount")
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/user_account.proto", fileDescriptor_user_account_ced378befb1b3d2f)
}
var fileDescriptor_user_account_ced378befb1b3d2f = []byte{
// 258 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x50, 0xcf, 0x4b, 0xc3, 0x30,
0x14, 0xb6, 0x05, 0x85, 0x65, 0x73, 0x87, 0xe8, 0x61, 0x13, 0x85, 0x31, 0x41, 0x76, 0x59, 0xc2,
0xf4, 0x38, 0x3c, 0x38, 0x10, 0x3c, 0x4a, 0x41, 0x41, 0x2f, 0xe5, 0xad, 0x89, 0xf5, 0x41, 0x7e,
0xd4, 0x36, 0x29, 0xee, 0xbf, 0xf1, 0x4f, 0x15, 0x93, 0x1e, 0x2a, 0x6c, 0xc7, 0xf7, 0xbd, 0xef,
0x17, 0x1f, 0xb9, 0xd9, 0x81, 0x11, 0xf2, 0x9b, 0x17, 0xca, 0x7a, 0xc1, 0x11, 0x34, 0x6f, 0x57,
0xdc, 0x37, 0xb2, 0xce, 0xa1, 0x28, 0xac, 0x37, 0x8e, 0x55, 0xb5, 0x75, 0x96, 0x9e, 0x45, 0x1e,
0x0b, 0x3c, 0x86, 0xa0, 0x59, 0xbb, 0xba, 0xb8, 0xfa, 0x27, 0x6e, 0x41, 0xa1, 0x00, 0x87, 0xd6,
0x44, 0xcd, 0xfc, 0x27, 0x21, 0xc3, 0x97, 0x46, 0xd6, 0x0f, 0xd1, 0x89, 0x8e, 0x49, 0x8a, 0x62,
0x92, 0xcc, 0x92, 0xc5, 0x20, 0x4b, 0x51, 0xd0, 0x2f, 0x72, 0x19, 0x0d, 0xf2, 0x0a, 0x9a, 0xa6,
0xb2, 0xb5, 0xcb, 0xfb, 0xc9, 0x93, 0x74, 0x96, 0x2c, 0x86, 0xb7, 0x8c, 0xed, 0x89, 0x66, 0x6f,
0x01, 0x7b, 0xee, 0x74, 0xbd, 0x94, 0xa7, 0xa3, 0x6c, 0xba, 0x3b, 0xf4, 0xdc, 0x8c, 0xc9, 0xa8,
0x1f, 0x31, 0x7f, 0x25, 0xd3, 0x83, 0x4e, 0xf4, 0x9c, 0x1c, 0x2b, 0x5b, 0xa2, 0xe9, 0x2a, 0xc7,
0x83, 0x5e, 0x93, 0x53, 0x21, 0x3f, 0xc0, 0x2b, 0x97, 0x4b, 0x0d, 0xa8, 0x42, 0xcd, 0x41, 0x36,
0xea, 0xc0, 0xc7, 0x3f, 0x6c, 0x73, 0xff, 0xbe, 0x2e, 0xd1, 0x7d, 0xfa, 0x2d, 0x2b, 0xac, 0xe6,
0xb1, 0xcf, 0x32, 0xce, 0x54, 0xda, 0x65, 0x29, 0x4d, 0x58, 0x88, 0xef, 0x19, 0x7f, 0x8d, 0xa0,
0xb7, 0x27, 0xe1, 0x7d, 0xf7, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xf9, 0xdc, 0xc7, 0x2e, 0x9e, 0x01,
0x00, 0x00,
}

169
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/user_account_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,169 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/user_account_service.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetUserAccountRequest struct {
// ID of the UserAccount resource to return.
UserAccountId string `protobuf:"bytes,1,opt,name=user_account_id,json=userAccountId,proto3" json:"user_account_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetUserAccountRequest) Reset() { *m = GetUserAccountRequest{} }
func (m *GetUserAccountRequest) String() string { return proto.CompactTextString(m) }
func (*GetUserAccountRequest) ProtoMessage() {}
func (*GetUserAccountRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_user_account_service_d671b5c11a2773d8, []int{0}
}
func (m *GetUserAccountRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUserAccountRequest.Unmarshal(m, b)
}
func (m *GetUserAccountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetUserAccountRequest.Marshal(b, m, deterministic)
}
func (dst *GetUserAccountRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetUserAccountRequest.Merge(dst, src)
}
func (m *GetUserAccountRequest) XXX_Size() int {
return xxx_messageInfo_GetUserAccountRequest.Size(m)
}
func (m *GetUserAccountRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetUserAccountRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetUserAccountRequest proto.InternalMessageInfo
func (m *GetUserAccountRequest) GetUserAccountId() string {
if m != nil {
return m.UserAccountId
}
return ""
}
func init() {
proto.RegisterType((*GetUserAccountRequest)(nil), "yandex.cloud.iam.v1.GetUserAccountRequest")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// UserAccountServiceClient is the client API for UserAccountService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type UserAccountServiceClient interface {
// Returns the specified UserAccount resource.
Get(ctx context.Context, in *GetUserAccountRequest, opts ...grpc.CallOption) (*UserAccount, error)
}
type userAccountServiceClient struct {
cc *grpc.ClientConn
}
func NewUserAccountServiceClient(cc *grpc.ClientConn) UserAccountServiceClient {
return &userAccountServiceClient{cc}
}
func (c *userAccountServiceClient) Get(ctx context.Context, in *GetUserAccountRequest, opts ...grpc.CallOption) (*UserAccount, error) {
out := new(UserAccount)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.UserAccountService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// UserAccountServiceServer is the server API for UserAccountService service.
type UserAccountServiceServer interface {
// Returns the specified UserAccount resource.
Get(context.Context, *GetUserAccountRequest) (*UserAccount, error)
}
func RegisterUserAccountServiceServer(s *grpc.Server, srv UserAccountServiceServer) {
s.RegisterService(&_UserAccountService_serviceDesc, srv)
}
func _UserAccountService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetUserAccountRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(UserAccountServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.UserAccountService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(UserAccountServiceServer).Get(ctx, req.(*GetUserAccountRequest))
}
return interceptor(ctx, in, info, handler)
}
var _UserAccountService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.iam.v1.UserAccountService",
HandlerType: (*UserAccountServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _UserAccountService_Get_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/iam/v1/user_account_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/user_account_service.proto", fileDescriptor_user_account_service_d671b5c11a2773d8)
}
var fileDescriptor_user_account_service_d671b5c11a2773d8 = []byte{
// 284 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xab, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0xcf, 0x4c, 0xcc, 0xd5, 0x2f, 0x33, 0xd4,
0x2f, 0x2d, 0x4e, 0x2d, 0x8a, 0x4f, 0x4c, 0x4e, 0xce, 0x2f, 0xcd, 0x2b, 0x89, 0x2f, 0x4e, 0x2d,
0x2a, 0xcb, 0x4c, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x86, 0xa8, 0xd7, 0x03,
0xab, 0xd7, 0xcb, 0x4c, 0xcc, 0xd5, 0x2b, 0x33, 0x94, 0x92, 0x49, 0xcf, 0xcf, 0x4f, 0xcf, 0x49,
0xd5, 0x4f, 0x2c, 0xc8, 0xd4, 0x4f, 0xcc, 0xcb, 0xcb, 0x2f, 0x49, 0x2c, 0xc9, 0xcc, 0xcf, 0x2b,
0x86, 0x68, 0x91, 0x52, 0x23, 0x64, 0x05, 0x54, 0x9d, 0x2c, 0x8a, 0xba, 0xb2, 0xc4, 0x9c, 0xcc,
0x14, 0xb0, 0x39, 0x10, 0x69, 0x25, 0x5f, 0x2e, 0x51, 0xf7, 0xd4, 0x92, 0xd0, 0xe2, 0xd4, 0x22,
0x47, 0x88, 0xb6, 0xa0, 0xd4, 0xc2, 0xd2, 0xd4, 0xe2, 0x12, 0x21, 0x13, 0x2e, 0x7e, 0x14, 0x07,
0x67, 0xa6, 0x48, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x3a, 0xf1, 0xbc, 0x38, 0x6e, 0xc8, 0xd8, 0x75,
0xc2, 0x90, 0xc5, 0xc6, 0xd6, 0xd4, 0x20, 0x88, 0xb7, 0x14, 0xa1, 0xd5, 0x33, 0xc5, 0x68, 0x16,
0x23, 0x97, 0x10, 0x92, 0x61, 0xc1, 0x10, 0x5f, 0x0a, 0x35, 0x33, 0x72, 0x31, 0xbb, 0xa7, 0x96,
0x08, 0x69, 0xe9, 0x61, 0xf1, 0xa8, 0x1e, 0x56, 0x07, 0x48, 0x29, 0x60, 0x55, 0x8b, 0xa4, 0x50,
0x49, 0xaf, 0xe9, 0xf2, 0x93, 0xc9, 0x4c, 0x1a, 0x42, 0x6a, 0xc8, 0xde, 0x87, 0x4a, 0x16, 0xeb,
0x57, 0xa3, 0x39, 0xbf, 0xd6, 0xc9, 0x36, 0xca, 0x3a, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f,
0x39, 0x3f, 0x57, 0x1f, 0x62, 0xba, 0x2e, 0x24, 0x5c, 0xd2, 0xf3, 0x75, 0xd3, 0x53, 0xf3, 0xc0,
0x41, 0xa2, 0x8f, 0x25, 0x60, 0xad, 0x33, 0x13, 0x73, 0x93, 0xd8, 0xc0, 0xd2, 0xc6, 0x80, 0x00,
0x00, 0x00, 0xff, 0xff, 0x80, 0x94, 0x59, 0x76, 0xdd, 0x01, 0x00, 0x00,
}

170
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1/yandex_passport_user_account_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,170 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/iam/v1/yandex_passport_user_account_service.proto
package iam // import "github.com/yandex-cloud/go-genproto/yandex/cloud/iam/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetUserAccountByLoginRequest struct {
// Login of the YandexPassportUserAccount resource to return.
Login string `protobuf:"bytes,1,opt,name=login,proto3" json:"login,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetUserAccountByLoginRequest) Reset() { *m = GetUserAccountByLoginRequest{} }
func (m *GetUserAccountByLoginRequest) String() string { return proto.CompactTextString(m) }
func (*GetUserAccountByLoginRequest) ProtoMessage() {}
func (*GetUserAccountByLoginRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_yandex_passport_user_account_service_fed4b1e4abf6d5f3, []int{0}
}
func (m *GetUserAccountByLoginRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUserAccountByLoginRequest.Unmarshal(m, b)
}
func (m *GetUserAccountByLoginRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetUserAccountByLoginRequest.Marshal(b, m, deterministic)
}
func (dst *GetUserAccountByLoginRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetUserAccountByLoginRequest.Merge(dst, src)
}
func (m *GetUserAccountByLoginRequest) XXX_Size() int {
return xxx_messageInfo_GetUserAccountByLoginRequest.Size(m)
}
func (m *GetUserAccountByLoginRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetUserAccountByLoginRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetUserAccountByLoginRequest proto.InternalMessageInfo
func (m *GetUserAccountByLoginRequest) GetLogin() string {
if m != nil {
return m.Login
}
return ""
}
func init() {
proto.RegisterType((*GetUserAccountByLoginRequest)(nil), "yandex.cloud.iam.v1.GetUserAccountByLoginRequest")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// YandexPassportUserAccountServiceClient is the client API for YandexPassportUserAccountService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type YandexPassportUserAccountServiceClient interface {
// Returns the specified YandexPassportUserAccount resource.
GetByLogin(ctx context.Context, in *GetUserAccountByLoginRequest, opts ...grpc.CallOption) (*UserAccount, error)
}
type yandexPassportUserAccountServiceClient struct {
cc *grpc.ClientConn
}
func NewYandexPassportUserAccountServiceClient(cc *grpc.ClientConn) YandexPassportUserAccountServiceClient {
return &yandexPassportUserAccountServiceClient{cc}
}
func (c *yandexPassportUserAccountServiceClient) GetByLogin(ctx context.Context, in *GetUserAccountByLoginRequest, opts ...grpc.CallOption) (*UserAccount, error) {
out := new(UserAccount)
err := c.cc.Invoke(ctx, "/yandex.cloud.iam.v1.YandexPassportUserAccountService/GetByLogin", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// YandexPassportUserAccountServiceServer is the server API for YandexPassportUserAccountService service.
type YandexPassportUserAccountServiceServer interface {
// Returns the specified YandexPassportUserAccount resource.
GetByLogin(context.Context, *GetUserAccountByLoginRequest) (*UserAccount, error)
}
func RegisterYandexPassportUserAccountServiceServer(s *grpc.Server, srv YandexPassportUserAccountServiceServer) {
s.RegisterService(&_YandexPassportUserAccountService_serviceDesc, srv)
}
func _YandexPassportUserAccountService_GetByLogin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetUserAccountByLoginRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(YandexPassportUserAccountServiceServer).GetByLogin(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.iam.v1.YandexPassportUserAccountService/GetByLogin",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(YandexPassportUserAccountServiceServer).GetByLogin(ctx, req.(*GetUserAccountByLoginRequest))
}
return interceptor(ctx, in, info, handler)
}
var _YandexPassportUserAccountService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.iam.v1.YandexPassportUserAccountService",
HandlerType: (*YandexPassportUserAccountServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetByLogin",
Handler: _YandexPassportUserAccountService_GetByLogin_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/iam/v1/yandex_passport_user_account_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/iam/v1/yandex_passport_user_account_service.proto", fileDescriptor_yandex_passport_user_account_service_fed4b1e4abf6d5f3)
}
var fileDescriptor_yandex_passport_user_account_service_fed4b1e4abf6d5f3 = []byte{
// 297 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0xab, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0xcf, 0x4c, 0xcc, 0xd5, 0x2f, 0x33, 0xd4,
0x87, 0x88, 0xc5, 0x17, 0x24, 0x16, 0x17, 0x17, 0xe4, 0x17, 0x95, 0xc4, 0x97, 0x16, 0xa7, 0x16,
0xc5, 0x27, 0x26, 0x27, 0xe7, 0x97, 0xe6, 0x95, 0xc4, 0x17, 0xa7, 0x16, 0x95, 0x65, 0x26, 0xa7,
0xea, 0x15, 0x14, 0xe5, 0x97, 0xe4, 0x0b, 0x09, 0x43, 0xd4, 0xea, 0x81, 0xf5, 0xeb, 0x65, 0x26,
0xe6, 0xea, 0x95, 0x19, 0x4a, 0xc9, 0xa4, 0xe7, 0xe7, 0xa7, 0xe7, 0xa4, 0xea, 0x27, 0x16, 0x64,
0xea, 0x27, 0xe6, 0xe5, 0xe5, 0x97, 0x24, 0x96, 0x64, 0xe6, 0xe7, 0x15, 0x43, 0xb4, 0x48, 0xa9,
0x61, 0xb3, 0x12, 0xd9, 0x0a, 0xa8, 0x3a, 0x59, 0x14, 0x75, 0x65, 0x89, 0x39, 0x99, 0x29, 0x60,
0x73, 0x20, 0xd2, 0x4a, 0x56, 0x5c, 0x32, 0xee, 0xa9, 0x25, 0xa1, 0xc5, 0xa9, 0x45, 0x8e, 0x10,
0x6d, 0x4e, 0x95, 0x3e, 0xf9, 0xe9, 0x99, 0x79, 0x41, 0xa9, 0x85, 0xa5, 0xa9, 0xc5, 0x25, 0x42,
0x52, 0x5c, 0xac, 0x39, 0x20, 0xbe, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0xa7, 0x13, 0xcb, 0x8b, 0xe3,
0x86, 0x8c, 0x41, 0x10, 0x21, 0xa3, 0x5d, 0x8c, 0x5c, 0x0a, 0x91, 0x60, 0xd3, 0x03, 0xa0, 0x7e,
0x44, 0x32, 0x27, 0x18, 0xe2, 0x41, 0xa1, 0xa9, 0x8c, 0x5c, 0x5c, 0xee, 0xa9, 0x30, 0x63, 0x85,
0x0c, 0xf5, 0xb0, 0x78, 0x55, 0x0f, 0x9f, 0x13, 0xa4, 0x14, 0xb0, 0x6a, 0x41, 0x52, 0xaf, 0x64,
0xd4, 0x74, 0xf9, 0xc9, 0x64, 0x26, 0x1d, 0x21, 0x2d, 0xd4, 0xa0, 0xc7, 0xe2, 0xaa, 0x62, 0xab,
0x24, 0x88, 0xe1, 0x4e, 0xb6, 0x51, 0xd6, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9,
0xb9, 0x50, 0x0d, 0xba, 0x90, 0x40, 0x4a, 0xcf, 0xd7, 0x4d, 0x4f, 0xcd, 0x03, 0x87, 0x8f, 0x3e,
0x96, 0x50, 0xb6, 0xce, 0x4c, 0xcc, 0x4d, 0x62, 0x03, 0x4b, 0x1b, 0x03, 0x02, 0x00, 0x00, 0xff,
0xff, 0xd5, 0x6e, 0x8b, 0x84, 0xfa, 0x01, 0x00, 0x00,
}

137
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/backup.pb.go generated vendored Normal file
View File

@ -0,0 +1,137 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/clickhouse/v1/backup.proto
package clickhouse // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// A ClickHouse Backup resource. See the [Developer's Guide](/docs/managed-clickhouse/concepts)
// for more information.
type Backup struct {
// ID of the backup.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the backup belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format
// (i.e. when the backup operation was completed).
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// ID of the ClickHouse cluster that the backup was created for.
SourceClusterId string `protobuf:"bytes,4,opt,name=source_cluster_id,json=sourceClusterId,proto3" json:"source_cluster_id,omitempty"`
SourceShardNames []string `protobuf:"bytes,6,rep,name=source_shard_names,json=sourceShardNames,proto3" json:"source_shard_names,omitempty"`
// Time when the backup operation was started.
StartedAt *timestamp.Timestamp `protobuf:"bytes,5,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Backup) Reset() { *m = Backup{} }
func (m *Backup) String() string { return proto.CompactTextString(m) }
func (*Backup) ProtoMessage() {}
func (*Backup) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_63c80d0c65f0a55c, []int{0}
}
func (m *Backup) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Backup.Unmarshal(m, b)
}
func (m *Backup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Backup.Marshal(b, m, deterministic)
}
func (dst *Backup) XXX_Merge(src proto.Message) {
xxx_messageInfo_Backup.Merge(dst, src)
}
func (m *Backup) XXX_Size() int {
return xxx_messageInfo_Backup.Size(m)
}
func (m *Backup) XXX_DiscardUnknown() {
xxx_messageInfo_Backup.DiscardUnknown(m)
}
var xxx_messageInfo_Backup proto.InternalMessageInfo
func (m *Backup) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Backup) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Backup) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Backup) GetSourceClusterId() string {
if m != nil {
return m.SourceClusterId
}
return ""
}
func (m *Backup) GetSourceShardNames() []string {
if m != nil {
return m.SourceShardNames
}
return nil
}
func (m *Backup) GetStartedAt() *timestamp.Timestamp {
if m != nil {
return m.StartedAt
}
return nil
}
func init() {
proto.RegisterType((*Backup)(nil), "yandex.cloud.mdb.clickhouse.v1.Backup")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/clickhouse/v1/backup.proto", fileDescriptor_backup_63c80d0c65f0a55c)
}
var fileDescriptor_backup_63c80d0c65f0a55c = []byte{
// 297 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x91, 0xcd, 0x4e, 0x02, 0x31,
0x14, 0x85, 0xc3, 0xa0, 0xc4, 0xa9, 0x89, 0x3f, 0x5d, 0x4d, 0x30, 0x51, 0xe2, 0x8a, 0xa8, 0xb4,
0x41, 0x57, 0xc6, 0x15, 0xb8, 0x62, 0xa1, 0x26, 0xe8, 0xca, 0xcd, 0xa4, 0xed, 0x2d, 0x43, 0xc3,
0x94, 0x92, 0xfe, 0x10, 0x7d, 0x00, 0xdf, 0xdb, 0x4c, 0x3b, 0x84, 0x9d, 0x2e, 0x7b, 0xee, 0x77,
0xcf, 0x39, 0xe9, 0x45, 0xb7, 0xdf, 0x6c, 0x0d, 0xf2, 0x8b, 0x8a, 0xda, 0x04, 0xa0, 0x1a, 0x38,
0x15, 0xb5, 0x12, 0xab, 0xa5, 0x09, 0x4e, 0xd2, 0xed, 0x98, 0x72, 0x26, 0x56, 0x61, 0x43, 0x36,
0xd6, 0x78, 0x83, 0x2f, 0x13, 0x4c, 0x22, 0x4c, 0x34, 0x70, 0xb2, 0x87, 0xc9, 0x76, 0xdc, 0xbf,
0xaa, 0x8c, 0xa9, 0x6a, 0x49, 0x23, 0xcd, 0xc3, 0x82, 0x7a, 0xa5, 0xa5, 0xf3, 0x4c, 0xb7, 0x06,
0xd7, 0x3f, 0x19, 0xea, 0x4d, 0xa3, 0x23, 0x3e, 0x41, 0x99, 0x82, 0xa2, 0x33, 0xe8, 0x0c, 0xf3,
0x79, 0xa6, 0x00, 0x5f, 0xa0, 0x7c, 0x61, 0x6a, 0x90, 0xb6, 0x54, 0x50, 0x64, 0x51, 0x3e, 0x4a,
0xc2, 0x0c, 0xf0, 0x23, 0x42, 0xc2, 0x4a, 0xe6, 0x25, 0x94, 0xcc, 0x17, 0xdd, 0x41, 0x67, 0x78,
0x7c, 0xdf, 0x27, 0x29, 0x8d, 0xec, 0xd2, 0xc8, 0xc7, 0x2e, 0x6d, 0x9e, 0xb7, 0xf4, 0xc4, 0xe3,
0x1b, 0x74, 0xee, 0x4c, 0xb0, 0x42, 0x96, 0xa2, 0x0e, 0xce, 0x27, 0xff, 0x83, 0xe8, 0x7f, 0x9a,
0x06, 0xcf, 0x49, 0x9f, 0x01, 0xbe, 0x43, 0xb8, 0x65, 0xdd, 0x92, 0x59, 0x28, 0xd7, 0x4c, 0x4b,
0x57, 0xf4, 0x06, 0xdd, 0x61, 0x3e, 0x3f, 0x4b, 0x93, 0xf7, 0x66, 0xf0, 0xda, 0xe8, 0x4d, 0x29,
0xe7, 0x99, 0x6d, 0x4b, 0x1d, 0xfe, 0x5f, 0xaa, 0xa5, 0x27, 0x7e, 0xfa, 0xf6, 0xf9, 0x52, 0x29,
0xbf, 0x0c, 0x9c, 0x08, 0xa3, 0x69, 0xfa, 0xd5, 0x51, 0x3a, 0x41, 0x65, 0x46, 0x95, 0x5c, 0xc7,
0x75, 0xfa, 0xf7, 0x6d, 0x9e, 0xf6, 0x2f, 0xde, 0x8b, 0x0b, 0x0f, 0xbf, 0x01, 0x00, 0x00, 0xff,
0xff, 0xcc, 0x05, 0xcb, 0xe2, 0xcf, 0x01, 0x00, 0x00,
}

335
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/backup_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,335 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/clickhouse/v1/backup_service.proto
package clickhouse // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetBackupRequest struct {
// ID of the backup to return information about.
// To get the backup ID, use a [ClusterService.ListBackups] request.
BackupId string `protobuf:"bytes,1,opt,name=backup_id,json=backupId,proto3" json:"backup_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetBackupRequest) Reset() { *m = GetBackupRequest{} }
func (m *GetBackupRequest) String() string { return proto.CompactTextString(m) }
func (*GetBackupRequest) ProtoMessage() {}
func (*GetBackupRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_c0389392897d6e8b, []int{0}
}
func (m *GetBackupRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetBackupRequest.Unmarshal(m, b)
}
func (m *GetBackupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetBackupRequest.Marshal(b, m, deterministic)
}
func (dst *GetBackupRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetBackupRequest.Merge(dst, src)
}
func (m *GetBackupRequest) XXX_Size() int {
return xxx_messageInfo_GetBackupRequest.Size(m)
}
func (m *GetBackupRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetBackupRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetBackupRequest proto.InternalMessageInfo
func (m *GetBackupRequest) GetBackupId() string {
if m != nil {
return m.BackupId
}
return ""
}
type ListBackupsRequest struct {
// ID of the folder to list backups in.
// To get the folder ID, use a [yandex.cloud.resourcemanager.v1.FolderService.List] request.
FolderId string `protobuf:"bytes,1,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size], the service returns a [ListBackupsResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the [ListBackupsResponse.next_page_token]
// returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListBackupsRequest) Reset() { *m = ListBackupsRequest{} }
func (m *ListBackupsRequest) String() string { return proto.CompactTextString(m) }
func (*ListBackupsRequest) ProtoMessage() {}
func (*ListBackupsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_c0389392897d6e8b, []int{1}
}
func (m *ListBackupsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListBackupsRequest.Unmarshal(m, b)
}
func (m *ListBackupsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListBackupsRequest.Marshal(b, m, deterministic)
}
func (dst *ListBackupsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListBackupsRequest.Merge(dst, src)
}
func (m *ListBackupsRequest) XXX_Size() int {
return xxx_messageInfo_ListBackupsRequest.Size(m)
}
func (m *ListBackupsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListBackupsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListBackupsRequest proto.InternalMessageInfo
func (m *ListBackupsRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *ListBackupsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListBackupsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListBackupsResponse struct {
// List of Backup resources.
Backups []*Backup `protobuf:"bytes,1,rep,name=backups,proto3" json:"backups,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListBackupsRequest.page_size], use the [next_page_token] as the value
// for the [ListBackupsRequest.page_token] parameter in the next list request. Each subsequent
// list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListBackupsResponse) Reset() { *m = ListBackupsResponse{} }
func (m *ListBackupsResponse) String() string { return proto.CompactTextString(m) }
func (*ListBackupsResponse) ProtoMessage() {}
func (*ListBackupsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_c0389392897d6e8b, []int{2}
}
func (m *ListBackupsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListBackupsResponse.Unmarshal(m, b)
}
func (m *ListBackupsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListBackupsResponse.Marshal(b, m, deterministic)
}
func (dst *ListBackupsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListBackupsResponse.Merge(dst, src)
}
func (m *ListBackupsResponse) XXX_Size() int {
return xxx_messageInfo_ListBackupsResponse.Size(m)
}
func (m *ListBackupsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListBackupsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListBackupsResponse proto.InternalMessageInfo
func (m *ListBackupsResponse) GetBackups() []*Backup {
if m != nil {
return m.Backups
}
return nil
}
func (m *ListBackupsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetBackupRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.GetBackupRequest")
proto.RegisterType((*ListBackupsRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.ListBackupsRequest")
proto.RegisterType((*ListBackupsResponse)(nil), "yandex.cloud.mdb.clickhouse.v1.ListBackupsResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// BackupServiceClient is the client API for BackupService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type BackupServiceClient interface {
// Returns the specified ClickHouse Backup resource.
//
// To get the list of available ClickHouse Backup resources, make a [List] request.
Get(ctx context.Context, in *GetBackupRequest, opts ...grpc.CallOption) (*Backup, error)
// Retrieves the list of Backup resources available for the specified folder.
List(ctx context.Context, in *ListBackupsRequest, opts ...grpc.CallOption) (*ListBackupsResponse, error)
}
type backupServiceClient struct {
cc *grpc.ClientConn
}
func NewBackupServiceClient(cc *grpc.ClientConn) BackupServiceClient {
return &backupServiceClient{cc}
}
func (c *backupServiceClient) Get(ctx context.Context, in *GetBackupRequest, opts ...grpc.CallOption) (*Backup, error) {
out := new(Backup)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.BackupService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *backupServiceClient) List(ctx context.Context, in *ListBackupsRequest, opts ...grpc.CallOption) (*ListBackupsResponse, error) {
out := new(ListBackupsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.BackupService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// BackupServiceServer is the server API for BackupService service.
type BackupServiceServer interface {
// Returns the specified ClickHouse Backup resource.
//
// To get the list of available ClickHouse Backup resources, make a [List] request.
Get(context.Context, *GetBackupRequest) (*Backup, error)
// Retrieves the list of Backup resources available for the specified folder.
List(context.Context, *ListBackupsRequest) (*ListBackupsResponse, error)
}
func RegisterBackupServiceServer(s *grpc.Server, srv BackupServiceServer) {
s.RegisterService(&_BackupService_serviceDesc, srv)
}
func _BackupService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetBackupRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BackupServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.BackupService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BackupServiceServer).Get(ctx, req.(*GetBackupRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BackupService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListBackupsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BackupServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.BackupService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BackupServiceServer).List(ctx, req.(*ListBackupsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _BackupService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.mdb.clickhouse.v1.BackupService",
HandlerType: (*BackupServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _BackupService_Get_Handler,
},
{
MethodName: "List",
Handler: _BackupService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/mdb/clickhouse/v1/backup_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/clickhouse/v1/backup_service.proto", fileDescriptor_backup_service_c0389392897d6e8b)
}
var fileDescriptor_backup_service_c0389392897d6e8b = []byte{
// 466 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x93, 0x3f, 0x6f, 0xd3, 0x40,
0x14, 0xc0, 0xe5, 0x24, 0x94, 0xf8, 0xa0, 0x02, 0x1d, 0x4b, 0x14, 0x41, 0x15, 0x3c, 0x84, 0xf0,
0x27, 0x3e, 0x3b, 0x51, 0x27, 0x5a, 0x09, 0x65, 0xa9, 0x2a, 0x81, 0x40, 0x2e, 0x13, 0x4b, 0x74,
0xf6, 0x3d, 0xdc, 0x53, 0x9c, 0x3b, 0x93, 0x3b, 0x47, 0xa5, 0x08, 0x21, 0x31, 0x76, 0xa4, 0x03,
0x1f, 0x87, 0xb1, 0xdd, 0xf9, 0x0a, 0x0c, 0x7c, 0x06, 0x26, 0xe4, 0x3b, 0x87, 0x50, 0x40, 0x69,
0x18, 0x7d, 0xef, 0xfd, 0xde, 0xfb, 0xe9, 0xbd, 0x67, 0x34, 0x7c, 0x4b, 0x05, 0x83, 0x23, 0x92,
0x64, 0xb2, 0x60, 0x64, 0xca, 0x62, 0x92, 0x64, 0x3c, 0x99, 0x1c, 0xca, 0x42, 0x01, 0x99, 0x87,
0x24, 0xa6, 0xc9, 0xa4, 0xc8, 0xc7, 0x0a, 0x66, 0x73, 0x9e, 0x80, 0x9f, 0xcf, 0xa4, 0x96, 0x78,
0xcb, 0x42, 0xbe, 0x81, 0xfc, 0x29, 0x8b, 0xfd, 0x25, 0xe4, 0xcf, 0xc3, 0xf6, 0xed, 0x54, 0xca,
0x34, 0x03, 0x42, 0x73, 0x4e, 0xa8, 0x10, 0x52, 0x53, 0xcd, 0xa5, 0x50, 0x96, 0x6e, 0x3f, 0x5c,
0xab, 0x65, 0x95, 0x7c, 0xe7, 0x42, 0xf2, 0x9c, 0x66, 0x9c, 0x99, 0x62, 0x36, 0xec, 0x6d, 0xa3,
0x9b, 0x7b, 0xa0, 0x47, 0x86, 0x88, 0xe0, 0x4d, 0x01, 0x4a, 0xe3, 0xbb, 0xc8, 0xad, 0xac, 0x39,
0x6b, 0x39, 0x1d, 0xa7, 0xe7, 0x8e, 0x1a, 0xdf, 0xcf, 0x42, 0x27, 0x6a, 0xda, 0xe7, 0x7d, 0xe6,
0x7d, 0x72, 0x10, 0x7e, 0xca, 0x55, 0x05, 0xaa, 0x05, 0x79, 0x1f, 0xb9, 0xaf, 0x65, 0xc6, 0x60,
0xb6, 0x24, 0xaf, 0x97, 0xe4, 0xc9, 0x79, 0xd8, 0xd8, 0xd9, 0xdd, 0x0e, 0xa2, 0xa6, 0x0d, 0xef,
0x33, 0x7c, 0x0f, 0xb9, 0x39, 0x4d, 0x61, 0xac, 0xf8, 0x31, 0xb4, 0x6a, 0x1d, 0xa7, 0x57, 0x1f,
0xa1, 0x1f, 0x67, 0xe1, 0xc6, 0xce, 0x6e, 0x18, 0x04, 0x41, 0xd4, 0x2c, 0x83, 0x07, 0xfc, 0x18,
0x70, 0x0f, 0x21, 0x93, 0xa8, 0xe5, 0x04, 0x44, 0xab, 0x6e, 0x8a, 0xba, 0x27, 0xe7, 0xe1, 0x15,
0x93, 0x19, 0x99, 0x2a, 0x2f, 0xcb, 0x98, 0xf7, 0x01, 0xdd, 0xba, 0xe0, 0xa4, 0x72, 0x29, 0x14,
0xe0, 0x27, 0xe8, 0xaa, 0xf5, 0x56, 0x2d, 0xa7, 0x53, 0xef, 0x5d, 0x1b, 0x74, 0xfd, 0xd5, 0xe3,
0xf7, 0xab, 0x71, 0x2c, 0x30, 0xdc, 0x45, 0x37, 0x04, 0x1c, 0xe9, 0xf1, 0x6f, 0x1e, 0xa5, 0xb1,
0x1b, 0x6d, 0x96, 0xcf, 0x2f, 0x16, 0x02, 0x83, 0x2f, 0x35, 0xb4, 0x69, 0xd9, 0x03, 0xbb, 0x6e,
0x7c, 0xea, 0xa0, 0xfa, 0x1e, 0x68, 0x1c, 0x5c, 0xd6, 0xf2, 0xcf, 0x25, 0xb4, 0xd7, 0x94, 0xf4,
0x06, 0x1f, 0xbf, 0x7e, 0x3b, 0xad, 0x3d, 0xc2, 0x0f, 0xc8, 0x94, 0x0a, 0x9a, 0x02, 0xeb, 0xff,
0xeb, 0x18, 0x14, 0x79, 0xf7, 0x6b, 0xa5, 0xef, 0xf1, 0x67, 0x07, 0x35, 0xca, 0x49, 0xe1, 0xc1,
0x65, 0x4d, 0xfe, 0xde, 0x71, 0x7b, 0xf8, 0x5f, 0x8c, 0xdd, 0x81, 0xd7, 0x35, 0x96, 0x1d, 0xbc,
0xb5, 0xda, 0x72, 0xf4, 0xfc, 0xd5, 0xb3, 0x94, 0xeb, 0xc3, 0x22, 0xf6, 0x13, 0x39, 0x25, 0xb6,
0x51, 0xdf, 0x9e, 0x6e, 0x2a, 0xfb, 0x29, 0x08, 0x73, 0xb5, 0x64, 0xf5, 0x0f, 0xf0, 0x78, 0xf9,
0x15, 0x6f, 0x18, 0x60, 0xf8, 0x33, 0x00, 0x00, 0xff, 0xff, 0xda, 0x84, 0x09, 0x05, 0xa7, 0x03,
0x00, 0x00,
}

1079
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/cluster.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

3437
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/cluster_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1867
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/config/clickhouse.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

137
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/database.pb.go generated vendored Normal file
View File

@ -0,0 +1,137 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/clickhouse/v1/database.proto
package clickhouse // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// A ClickHouse Database resource. For more information, see the
// [Developer's Guide](/docs/managed-clickhouse/concepts).
type Database struct {
// Name of the database.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// ID of the ClickHouse cluster that the database belongs to.
ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Database) Reset() { *m = Database{} }
func (m *Database) String() string { return proto.CompactTextString(m) }
func (*Database) ProtoMessage() {}
func (*Database) Descriptor() ([]byte, []int) {
return fileDescriptor_database_d83bcea5c6482814, []int{0}
}
func (m *Database) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Database.Unmarshal(m, b)
}
func (m *Database) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Database.Marshal(b, m, deterministic)
}
func (dst *Database) XXX_Merge(src proto.Message) {
xxx_messageInfo_Database.Merge(dst, src)
}
func (m *Database) XXX_Size() int {
return xxx_messageInfo_Database.Size(m)
}
func (m *Database) XXX_DiscardUnknown() {
xxx_messageInfo_Database.DiscardUnknown(m)
}
var xxx_messageInfo_Database proto.InternalMessageInfo
func (m *Database) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Database) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
type DatabaseSpec struct {
// Name of the ClickHouse database. 1-63 characters long.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DatabaseSpec) Reset() { *m = DatabaseSpec{} }
func (m *DatabaseSpec) String() string { return proto.CompactTextString(m) }
func (*DatabaseSpec) ProtoMessage() {}
func (*DatabaseSpec) Descriptor() ([]byte, []int) {
return fileDescriptor_database_d83bcea5c6482814, []int{1}
}
func (m *DatabaseSpec) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DatabaseSpec.Unmarshal(m, b)
}
func (m *DatabaseSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DatabaseSpec.Marshal(b, m, deterministic)
}
func (dst *DatabaseSpec) XXX_Merge(src proto.Message) {
xxx_messageInfo_DatabaseSpec.Merge(dst, src)
}
func (m *DatabaseSpec) XXX_Size() int {
return xxx_messageInfo_DatabaseSpec.Size(m)
}
func (m *DatabaseSpec) XXX_DiscardUnknown() {
xxx_messageInfo_DatabaseSpec.DiscardUnknown(m)
}
var xxx_messageInfo_DatabaseSpec proto.InternalMessageInfo
func (m *DatabaseSpec) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func init() {
proto.RegisterType((*Database)(nil), "yandex.cloud.mdb.clickhouse.v1.Database")
proto.RegisterType((*DatabaseSpec)(nil), "yandex.cloud.mdb.clickhouse.v1.DatabaseSpec")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/clickhouse/v1/database.proto", fileDescriptor_database_d83bcea5c6482814)
}
var fileDescriptor_database_d83bcea5c6482814 = []byte{
// 240 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xad, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0xcf, 0x4d, 0x49, 0xd2, 0x4f, 0xce, 0xc9,
0x4c, 0xce, 0xce, 0xc8, 0x2f, 0x2d, 0x4e, 0xd5, 0x2f, 0x33, 0xd4, 0x4f, 0x49, 0x2c, 0x49, 0x4c,
0x4a, 0x2c, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x92, 0x83, 0x28, 0xd7, 0x03, 0x2b,
0xd7, 0xcb, 0x4d, 0x49, 0xd2, 0x43, 0x28, 0xd7, 0x2b, 0x33, 0x94, 0x92, 0x45, 0x31, 0xae, 0x2c,
0x31, 0x27, 0x33, 0x25, 0xb1, 0x24, 0x33, 0x3f, 0x0f, 0xa2, 0x5d, 0xc9, 0x96, 0x8b, 0xc3, 0x05,
0x6a, 0xa0, 0x90, 0x10, 0x17, 0x4b, 0x5e, 0x62, 0x6e, 0xaa, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x67,
0x10, 0x98, 0x2d, 0x24, 0xcb, 0xc5, 0x95, 0x9c, 0x53, 0x5a, 0x5c, 0x92, 0x5a, 0x14, 0x9f, 0x99,
0x22, 0xc1, 0x04, 0x96, 0xe1, 0x84, 0x8a, 0x78, 0xa6, 0x28, 0x39, 0x71, 0xf1, 0xc0, 0xb4, 0x07,
0x17, 0xa4, 0x26, 0x0b, 0x19, 0x21, 0x1b, 0xe1, 0x24, 0xf7, 0xe2, 0xb8, 0x21, 0xe3, 0xa7, 0xe3,
0x86, 0x7c, 0xd1, 0x89, 0xba, 0x55, 0x8e, 0xba, 0x51, 0x06, 0xba, 0x96, 0xf1, 0xba, 0xb1, 0x5a,
0x5d, 0x27, 0x0c, 0x59, 0x6c, 0x6c, 0xcd, 0x8c, 0x21, 0x56, 0x38, 0xf9, 0x47, 0xf9, 0xa6, 0x67,
0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x43, 0x9c, 0xab, 0x0b, 0x71, 0x6e, 0x7a,
0xbe, 0x6e, 0x7a, 0x6a, 0x1e, 0xd8, 0xa5, 0xfa, 0xf8, 0x83, 0xc5, 0x1a, 0xc1, 0x4b, 0x62, 0x03,
0x6b, 0x30, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x76, 0xaf, 0x2f, 0xc6, 0x4a, 0x01, 0x00, 0x00,
}

630
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/database_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,630 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/clickhouse/v1/database_service.proto
package clickhouse // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/api"
import operation "github.com/yandex-cloud/go-genproto/yandex/cloud/operation"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetDatabaseRequest struct {
// ID of the ClickHouse cluster that the database belongs to.
// To get the cluster ID, use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the ClickHouse Database resource to return.
// To get the name of the database, use a [DatabaseService.List] request.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetDatabaseRequest) Reset() { *m = GetDatabaseRequest{} }
func (m *GetDatabaseRequest) String() string { return proto.CompactTextString(m) }
func (*GetDatabaseRequest) ProtoMessage() {}
func (*GetDatabaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_08aeb62acbe585c3, []int{0}
}
func (m *GetDatabaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetDatabaseRequest.Unmarshal(m, b)
}
func (m *GetDatabaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetDatabaseRequest.Marshal(b, m, deterministic)
}
func (dst *GetDatabaseRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetDatabaseRequest.Merge(dst, src)
}
func (m *GetDatabaseRequest) XXX_Size() int {
return xxx_messageInfo_GetDatabaseRequest.Size(m)
}
func (m *GetDatabaseRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetDatabaseRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetDatabaseRequest proto.InternalMessageInfo
func (m *GetDatabaseRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *GetDatabaseRequest) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type ListDatabasesRequest struct {
// ID of the ClickHouse cluster to list databases in.
// To get the cluster ID, use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size], the service returns a [ListDatabasesResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. to get the next page of results, set [page_token] to the [ListDatabasesResponse.next_page_token]
// returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListDatabasesRequest) Reset() { *m = ListDatabasesRequest{} }
func (m *ListDatabasesRequest) String() string { return proto.CompactTextString(m) }
func (*ListDatabasesRequest) ProtoMessage() {}
func (*ListDatabasesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_08aeb62acbe585c3, []int{1}
}
func (m *ListDatabasesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListDatabasesRequest.Unmarshal(m, b)
}
func (m *ListDatabasesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListDatabasesRequest.Marshal(b, m, deterministic)
}
func (dst *ListDatabasesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListDatabasesRequest.Merge(dst, src)
}
func (m *ListDatabasesRequest) XXX_Size() int {
return xxx_messageInfo_ListDatabasesRequest.Size(m)
}
func (m *ListDatabasesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListDatabasesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListDatabasesRequest proto.InternalMessageInfo
func (m *ListDatabasesRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *ListDatabasesRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListDatabasesRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListDatabasesResponse struct {
// List of ClickHouse Database resources.
Databases []*Database `protobuf:"bytes,1,rep,name=databases,proto3" json:"databases,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListDatabasesRequest.page_size], use the [next_page_token] as the value
// for the [ListDatabasesRequest.page_token] parameter in the next list request. Each subsequent
// list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListDatabasesResponse) Reset() { *m = ListDatabasesResponse{} }
func (m *ListDatabasesResponse) String() string { return proto.CompactTextString(m) }
func (*ListDatabasesResponse) ProtoMessage() {}
func (*ListDatabasesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_08aeb62acbe585c3, []int{2}
}
func (m *ListDatabasesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListDatabasesResponse.Unmarshal(m, b)
}
func (m *ListDatabasesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListDatabasesResponse.Marshal(b, m, deterministic)
}
func (dst *ListDatabasesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListDatabasesResponse.Merge(dst, src)
}
func (m *ListDatabasesResponse) XXX_Size() int {
return xxx_messageInfo_ListDatabasesResponse.Size(m)
}
func (m *ListDatabasesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListDatabasesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListDatabasesResponse proto.InternalMessageInfo
func (m *ListDatabasesResponse) GetDatabases() []*Database {
if m != nil {
return m.Databases
}
return nil
}
func (m *ListDatabasesResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type CreateDatabaseRequest struct {
// ID of the ClickHouse cluster to create a database in.
// To get the cluster ID, use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Configuration of the database to create.
DatabaseSpec *DatabaseSpec `protobuf:"bytes,2,opt,name=database_spec,json=databaseSpec,proto3" json:"database_spec,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateDatabaseRequest) Reset() { *m = CreateDatabaseRequest{} }
func (m *CreateDatabaseRequest) String() string { return proto.CompactTextString(m) }
func (*CreateDatabaseRequest) ProtoMessage() {}
func (*CreateDatabaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_08aeb62acbe585c3, []int{3}
}
func (m *CreateDatabaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateDatabaseRequest.Unmarshal(m, b)
}
func (m *CreateDatabaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateDatabaseRequest.Marshal(b, m, deterministic)
}
func (dst *CreateDatabaseRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateDatabaseRequest.Merge(dst, src)
}
func (m *CreateDatabaseRequest) XXX_Size() int {
return xxx_messageInfo_CreateDatabaseRequest.Size(m)
}
func (m *CreateDatabaseRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateDatabaseRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateDatabaseRequest proto.InternalMessageInfo
func (m *CreateDatabaseRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *CreateDatabaseRequest) GetDatabaseSpec() *DatabaseSpec {
if m != nil {
return m.DatabaseSpec
}
return nil
}
type CreateDatabaseMetadata struct {
// ID of the ClickHouse cluster where a database is being created.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the ClickHouse database that is being created.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateDatabaseMetadata) Reset() { *m = CreateDatabaseMetadata{} }
func (m *CreateDatabaseMetadata) String() string { return proto.CompactTextString(m) }
func (*CreateDatabaseMetadata) ProtoMessage() {}
func (*CreateDatabaseMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_08aeb62acbe585c3, []int{4}
}
func (m *CreateDatabaseMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateDatabaseMetadata.Unmarshal(m, b)
}
func (m *CreateDatabaseMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateDatabaseMetadata.Marshal(b, m, deterministic)
}
func (dst *CreateDatabaseMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateDatabaseMetadata.Merge(dst, src)
}
func (m *CreateDatabaseMetadata) XXX_Size() int {
return xxx_messageInfo_CreateDatabaseMetadata.Size(m)
}
func (m *CreateDatabaseMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_CreateDatabaseMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_CreateDatabaseMetadata proto.InternalMessageInfo
func (m *CreateDatabaseMetadata) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *CreateDatabaseMetadata) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type DeleteDatabaseRequest struct {
// ID of the ClickHouse cluster to delete a database in.
// To get the cluster ID, use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the database to delete.
// To get the name of the database, use a [DatabaseService.List] request.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteDatabaseRequest) Reset() { *m = DeleteDatabaseRequest{} }
func (m *DeleteDatabaseRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteDatabaseRequest) ProtoMessage() {}
func (*DeleteDatabaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_08aeb62acbe585c3, []int{5}
}
func (m *DeleteDatabaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteDatabaseRequest.Unmarshal(m, b)
}
func (m *DeleteDatabaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteDatabaseRequest.Marshal(b, m, deterministic)
}
func (dst *DeleteDatabaseRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteDatabaseRequest.Merge(dst, src)
}
func (m *DeleteDatabaseRequest) XXX_Size() int {
return xxx_messageInfo_DeleteDatabaseRequest.Size(m)
}
func (m *DeleteDatabaseRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteDatabaseRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteDatabaseRequest proto.InternalMessageInfo
func (m *DeleteDatabaseRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *DeleteDatabaseRequest) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type DeleteDatabaseMetadata struct {
// ID of the ClickHouse cluster where a database is being deleted.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the ClickHouse database that is being deleted.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteDatabaseMetadata) Reset() { *m = DeleteDatabaseMetadata{} }
func (m *DeleteDatabaseMetadata) String() string { return proto.CompactTextString(m) }
func (*DeleteDatabaseMetadata) ProtoMessage() {}
func (*DeleteDatabaseMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_08aeb62acbe585c3, []int{6}
}
func (m *DeleteDatabaseMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteDatabaseMetadata.Unmarshal(m, b)
}
func (m *DeleteDatabaseMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteDatabaseMetadata.Marshal(b, m, deterministic)
}
func (dst *DeleteDatabaseMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteDatabaseMetadata.Merge(dst, src)
}
func (m *DeleteDatabaseMetadata) XXX_Size() int {
return xxx_messageInfo_DeleteDatabaseMetadata.Size(m)
}
func (m *DeleteDatabaseMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteDatabaseMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteDatabaseMetadata proto.InternalMessageInfo
func (m *DeleteDatabaseMetadata) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *DeleteDatabaseMetadata) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
func init() {
proto.RegisterType((*GetDatabaseRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.GetDatabaseRequest")
proto.RegisterType((*ListDatabasesRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.ListDatabasesRequest")
proto.RegisterType((*ListDatabasesResponse)(nil), "yandex.cloud.mdb.clickhouse.v1.ListDatabasesResponse")
proto.RegisterType((*CreateDatabaseRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.CreateDatabaseRequest")
proto.RegisterType((*CreateDatabaseMetadata)(nil), "yandex.cloud.mdb.clickhouse.v1.CreateDatabaseMetadata")
proto.RegisterType((*DeleteDatabaseRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.DeleteDatabaseRequest")
proto.RegisterType((*DeleteDatabaseMetadata)(nil), "yandex.cloud.mdb.clickhouse.v1.DeleteDatabaseMetadata")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// DatabaseServiceClient is the client API for DatabaseService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DatabaseServiceClient interface {
// Returns the specified ClickHouse Database resource.
//
// To get the list of available ClickHouse Database resources, make a [List] request.
Get(ctx context.Context, in *GetDatabaseRequest, opts ...grpc.CallOption) (*Database, error)
// Retrieves the list of ClickHouse Database resources in the specified cluster.
List(ctx context.Context, in *ListDatabasesRequest, opts ...grpc.CallOption) (*ListDatabasesResponse, error)
// Creates a new ClickHouse database in the specified cluster.
Create(ctx context.Context, in *CreateDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error)
// Deletes the specified ClickHouse database.
Delete(ctx context.Context, in *DeleteDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error)
}
type databaseServiceClient struct {
cc *grpc.ClientConn
}
func NewDatabaseServiceClient(cc *grpc.ClientConn) DatabaseServiceClient {
return &databaseServiceClient{cc}
}
func (c *databaseServiceClient) Get(ctx context.Context, in *GetDatabaseRequest, opts ...grpc.CallOption) (*Database, error) {
out := new(Database)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *databaseServiceClient) List(ctx context.Context, in *ListDatabasesRequest, opts ...grpc.CallOption) (*ListDatabasesResponse, error) {
out := new(ListDatabasesResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *databaseServiceClient) Create(ctx context.Context, in *CreateDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/Create", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *databaseServiceClient) Delete(ctx context.Context, in *DeleteDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/Delete", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// DatabaseServiceServer is the server API for DatabaseService service.
type DatabaseServiceServer interface {
// Returns the specified ClickHouse Database resource.
//
// To get the list of available ClickHouse Database resources, make a [List] request.
Get(context.Context, *GetDatabaseRequest) (*Database, error)
// Retrieves the list of ClickHouse Database resources in the specified cluster.
List(context.Context, *ListDatabasesRequest) (*ListDatabasesResponse, error)
// Creates a new ClickHouse database in the specified cluster.
Create(context.Context, *CreateDatabaseRequest) (*operation.Operation, error)
// Deletes the specified ClickHouse database.
Delete(context.Context, *DeleteDatabaseRequest) (*operation.Operation, error)
}
func RegisterDatabaseServiceServer(s *grpc.Server, srv DatabaseServiceServer) {
s.RegisterService(&_DatabaseService_serviceDesc, srv)
}
func _DatabaseService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetDatabaseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).Get(ctx, req.(*GetDatabaseRequest))
}
return interceptor(ctx, in, info, handler)
}
func _DatabaseService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListDatabasesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).List(ctx, req.(*ListDatabasesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _DatabaseService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateDatabaseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).Create(ctx, req.(*CreateDatabaseRequest))
}
return interceptor(ctx, in, info, handler)
}
func _DatabaseService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteDatabaseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).Delete(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.DatabaseService/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).Delete(ctx, req.(*DeleteDatabaseRequest))
}
return interceptor(ctx, in, info, handler)
}
var _DatabaseService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.mdb.clickhouse.v1.DatabaseService",
HandlerType: (*DatabaseServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _DatabaseService_Get_Handler,
},
{
MethodName: "List",
Handler: _DatabaseService_List_Handler,
},
{
MethodName: "Create",
Handler: _DatabaseService_Create_Handler,
},
{
MethodName: "Delete",
Handler: _DatabaseService_Delete_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/mdb/clickhouse/v1/database_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/clickhouse/v1/database_service.proto", fileDescriptor_database_service_08aeb62acbe585c3)
}
var fileDescriptor_database_service_08aeb62acbe585c3 = []byte{
// 702 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x5f, 0x4f, 0x13, 0x4b,
0x1c, 0xcd, 0x50, 0x6e, 0x43, 0x07, 0xb8, 0x24, 0x93, 0x5b, 0xd2, 0x34, 0x17, 0xc2, 0xdd, 0x9b,
0x60, 0x53, 0xdd, 0xdd, 0x6e, 0x11, 0xa2, 0x02, 0x26, 0x16, 0x04, 0x4d, 0x04, 0x4c, 0x31, 0x31,
0x41, 0x4c, 0x33, 0xdd, 0xfd, 0xb9, 0x6c, 0x68, 0x77, 0xd7, 0xce, 0xb4, 0xe1, 0x4f, 0x78, 0xd0,
0x07, 0x8d, 0xbc, 0x9a, 0xf8, 0xe6, 0x97, 0x40, 0xbf, 0x03, 0x24, 0xbe, 0xe1, 0x57, 0x30, 0xc6,
0x67, 0x1f, 0x7d, 0x32, 0xbb, 0xd3, 0x6e, 0xbb, 0x50, 0x68, 0x05, 0xde, 0x76, 0xe7, 0xf7, 0x3b,
0x33, 0xe7, 0xcc, 0x9c, 0x33, 0x83, 0x27, 0xb7, 0xa9, 0x6d, 0xc0, 0x96, 0xaa, 0x97, 0x9c, 0xaa,
0xa1, 0x96, 0x8d, 0xa2, 0xaa, 0x97, 0x2c, 0x7d, 0x73, 0xc3, 0xa9, 0x32, 0x50, 0x6b, 0x9a, 0x6a,
0x50, 0x4e, 0x8b, 0x94, 0x41, 0x81, 0x41, 0xa5, 0x66, 0xe9, 0xa0, 0xb8, 0x15, 0x87, 0x3b, 0x64,
0x54, 0xc0, 0x14, 0x1f, 0xa6, 0x94, 0x8d, 0xa2, 0xd2, 0x84, 0x29, 0x35, 0x2d, 0xf9, 0xaf, 0xe9,
0x38, 0x66, 0x09, 0x54, 0xea, 0x5a, 0x2a, 0xb5, 0x6d, 0x87, 0x53, 0x6e, 0x39, 0x36, 0x13, 0xe8,
0x64, 0xb2, 0xbe, 0xa8, 0x57, 0x75, 0x5c, 0xa8, 0xf8, 0xc5, 0x7a, 0x6d, 0x3c, 0x44, 0x28, 0xa8,
0x9e, 0xea, 0x1b, 0x09, 0xf5, 0xd5, 0x68, 0xc9, 0x32, 0x5a, 0xcb, 0x72, 0x97, 0xba, 0x44, 0xbb,
0xf4, 0x06, 0x61, 0xb2, 0x08, 0x7c, 0xbe, 0x3e, 0x9a, 0x87, 0x97, 0x55, 0x60, 0x9c, 0x5c, 0xc7,
0x58, 0x2f, 0x55, 0x19, 0x87, 0x4a, 0xc1, 0x32, 0x12, 0x68, 0x0c, 0xa5, 0x62, 0xb9, 0x81, 0x1f,
0x87, 0x1a, 0xda, 0x3f, 0xd2, 0x7a, 0x67, 0x66, 0x27, 0x33, 0xf9, 0x58, 0xbd, 0xfe, 0xd0, 0x20,
0x73, 0x78, 0x30, 0xd8, 0x2d, 0x9b, 0x96, 0x21, 0xd1, 0xe3, 0xf7, 0x8f, 0x7a, 0xfd, 0x3f, 0x0f,
0xb5, 0xbf, 0x9f, 0x51, 0x79, 0xe7, 0x9e, 0xbc, 0x96, 0x91, 0x6f, 0x17, 0xe4, 0xe7, 0x69, 0x31,
0xc3, 0xd4, 0x44, 0x7e, 0xa0, 0x01, 0x5a, 0xa6, 0x65, 0x90, 0x3e, 0x20, 0xfc, 0xcf, 0x23, 0x8b,
0x05, 0x4c, 0xd8, 0x85, 0xa8, 0x5c, 0xc3, 0x31, 0x97, 0x9a, 0x50, 0x60, 0xd6, 0x8e, 0xa0, 0x11,
0xc9, 0xe1, 0x5f, 0x87, 0x5a, 0x74, 0x66, 0x56, 0xcb, 0x64, 0x32, 0xf9, 0x3e, 0xaf, 0xb8, 0x6a,
0xed, 0x00, 0x49, 0x61, 0xec, 0x37, 0x72, 0x67, 0x13, 0xec, 0x44, 0xc4, 0x9f, 0x35, 0xb6, 0x7f,
0xa4, 0xfd, 0xe5, 0x77, 0xe6, 0xfd, 0x59, 0x9e, 0x78, 0x35, 0xe9, 0x2d, 0xc2, 0xf1, 0x13, 0xc4,
0x98, 0xeb, 0xd8, 0x0c, 0xc8, 0x02, 0x8e, 0x35, 0x24, 0xb0, 0x04, 0x1a, 0x8b, 0xa4, 0xfa, 0xb3,
0x29, 0xe5, 0x7c, 0x7f, 0x28, 0xc1, 0x46, 0x37, 0xa1, 0x64, 0x1c, 0x0f, 0xd9, 0xb0, 0xc5, 0x0b,
0x2d, 0x84, 0xfc, 0x1d, 0xcc, 0x0f, 0x7a, 0xc3, 0x8f, 0x03, 0x26, 0x1f, 0x11, 0x8e, 0xcf, 0x55,
0x80, 0x72, 0xb8, 0xd4, 0x71, 0x3d, 0x6d, 0x39, 0x2e, 0xe6, 0x82, 0xee, 0x2f, 0xd6, 0x9f, 0xbd,
0xd1, 0x2d, 0xf5, 0x55, 0x17, 0xf4, 0x5c, 0xaf, 0x37, 0x7b, 0xf3, 0x08, 0xbd, 0x31, 0x69, 0x1d,
0x0f, 0x87, 0xe9, 0x2d, 0x01, 0xa7, 0x5e, 0x07, 0x19, 0x39, 0xcd, 0xaf, 0x95, 0xd1, 0xff, 0x6d,
0x0d, 0x74, 0xc2, 0x20, 0xef, 0x10, 0x8e, 0xcf, 0x43, 0x09, 0x2e, 0xa9, 0xfe, 0x4a, 0xcc, 0xba,
0x8e, 0x87, 0xc3, 0x54, 0xae, 0x52, 0x69, 0xf6, 0x73, 0x14, 0x0f, 0x05, 0x9b, 0x2d, 0x6e, 0x1f,
0xf2, 0x09, 0xe1, 0xc8, 0x22, 0x70, 0x92, 0xed, 0x74, 0x4a, 0xa7, 0xc3, 0x9c, 0xec, 0xda, 0x94,
0xd2, 0xf2, 0xeb, 0xaf, 0xdf, 0xde, 0xf7, 0x3c, 0x20, 0x0b, 0x6a, 0x99, 0xda, 0xd4, 0x04, 0x43,
0x0e, 0x5f, 0x1e, 0x75, 0x21, 0x4c, 0xdd, 0x6d, 0x8a, 0xdc, 0x0b, 0xae, 0x14, 0xa6, 0xee, 0x86,
0xc4, 0xed, 0x79, 0xac, 0x7b, 0xbd, 0xec, 0x90, 0x9b, 0x9d, 0x28, 0xb4, 0x8b, 0x7e, 0x72, 0xf2,
0x0f, 0x51, 0x22, 0x97, 0xd2, 0x5d, 0x5f, 0xc5, 0x2d, 0x32, 0x75, 0x31, 0x15, 0xe4, 0x0b, 0xc2,
0x51, 0x61, 0x64, 0xd2, 0x91, 0x41, 0xdb, 0x3c, 0x26, 0xff, 0x0b, 0xc3, 0x9a, 0x57, 0xf8, 0x4a,
0xe3, 0x4b, 0x32, 0x0f, 0x8e, 0xd3, 0xd2, 0x99, 0x81, 0xe9, 0x6b, 0x8c, 0xf8, 0x52, 0xa6, 0xa5,
0x0b, 0x4a, 0xb9, 0x83, 0xd2, 0xe4, 0x3b, 0xc2, 0x51, 0x61, 0xd6, 0xce, 0x6a, 0xda, 0xe6, 0xab,
0x1b, 0x35, 0xaf, 0xd0, 0xc1, 0x71, 0x5a, 0x3d, 0x33, 0x15, 0x71, 0xf1, 0x2a, 0x8a, 0x37, 0xa7,
0x58, 0x7d, 0xa1, 0xdc, 0x2f, 0xbb, 0x7c, 0x5b, 0x98, 0x2d, 0x7d, 0x45, 0x66, 0xcb, 0xad, 0xac,
0x2d, 0x99, 0x16, 0xdf, 0xa8, 0x16, 0x15, 0xdd, 0x29, 0xab, 0x82, 0xb2, 0x2c, 0x9e, 0x41, 0xd3,
0x91, 0x4d, 0xb0, 0xfd, 0xd5, 0xd5, 0xf3, 0xdf, 0xc7, 0xe9, 0xe6, 0x5f, 0x31, 0xea, 0x03, 0x26,
0x7e, 0x07, 0x00, 0x00, 0xff, 0xff, 0x9e, 0x81, 0xf7, 0x00, 0x2b, 0x08, 0x00, 0x00,
}

112
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/resource_preset.pb.go generated vendored Normal file
View File

@ -0,0 +1,112 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/clickhouse/v1/resource_preset.proto
package clickhouse // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// A ResourcePreset resource for describing hardware configuration presets.
type ResourcePreset struct {
// ID of the ResourcePreset resource.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// IDs of availability zones where the resource preset is available.
ZoneIds []string `protobuf:"bytes,2,rep,name=zone_ids,json=zoneIds,proto3" json:"zone_ids,omitempty"`
// Number of CPU cores for a ClickHouse host created with the preset.
Cores int64 `protobuf:"varint,3,opt,name=cores,proto3" json:"cores,omitempty"`
// RAM volume for a ClickHouse host created with the preset, in bytes.
Memory int64 `protobuf:"varint,4,opt,name=memory,proto3" json:"memory,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ResourcePreset) Reset() { *m = ResourcePreset{} }
func (m *ResourcePreset) String() string { return proto.CompactTextString(m) }
func (*ResourcePreset) ProtoMessage() {}
func (*ResourcePreset) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_8b47fe1881d4dab9, []int{0}
}
func (m *ResourcePreset) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ResourcePreset.Unmarshal(m, b)
}
func (m *ResourcePreset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ResourcePreset.Marshal(b, m, deterministic)
}
func (dst *ResourcePreset) XXX_Merge(src proto.Message) {
xxx_messageInfo_ResourcePreset.Merge(dst, src)
}
func (m *ResourcePreset) XXX_Size() int {
return xxx_messageInfo_ResourcePreset.Size(m)
}
func (m *ResourcePreset) XXX_DiscardUnknown() {
xxx_messageInfo_ResourcePreset.DiscardUnknown(m)
}
var xxx_messageInfo_ResourcePreset proto.InternalMessageInfo
func (m *ResourcePreset) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *ResourcePreset) GetZoneIds() []string {
if m != nil {
return m.ZoneIds
}
return nil
}
func (m *ResourcePreset) GetCores() int64 {
if m != nil {
return m.Cores
}
return 0
}
func (m *ResourcePreset) GetMemory() int64 {
if m != nil {
return m.Memory
}
return 0
}
func init() {
proto.RegisterType((*ResourcePreset)(nil), "yandex.cloud.mdb.clickhouse.v1.ResourcePreset")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/clickhouse/v1/resource_preset.proto", fileDescriptor_resource_preset_8b47fe1881d4dab9)
}
var fileDescriptor_resource_preset_8b47fe1881d4dab9 = []byte{
// 215 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0xcf, 0xb1, 0x4b, 0x03, 0x31,
0x14, 0xc7, 0x71, 0xee, 0x4e, 0xab, 0xcd, 0xd0, 0x21, 0x88, 0xc4, 0x45, 0x0e, 0xa7, 0x5b, 0x9a,
0x50, 0x74, 0x73, 0x73, 0x73, 0x10, 0x25, 0xa3, 0x4b, 0x31, 0x79, 0x8f, 0x6b, 0xb0, 0xb9, 0x57,
0x92, 0x4b, 0xb1, 0xfe, 0xf5, 0x62, 0x72, 0x70, 0x5b, 0xc7, 0xef, 0x83, 0x0f, 0xbc, 0x1f, 0x7b,
0x3a, 0x7d, 0x0d, 0x80, 0x3f, 0xca, 0xee, 0x29, 0x81, 0xf2, 0x60, 0x94, 0xdd, 0x3b, 0xfb, 0xbd,
0xa3, 0x14, 0x51, 0x1d, 0x37, 0x2a, 0x60, 0xa4, 0x14, 0x2c, 0x6e, 0x0f, 0x01, 0x23, 0x8e, 0xf2,
0x10, 0x68, 0x24, 0x7e, 0x5f, 0x94, 0xcc, 0x4a, 0x7a, 0x30, 0x72, 0x56, 0xf2, 0xb8, 0x79, 0x70,
0x6c, 0xa5, 0x27, 0xf8, 0x91, 0x1d, 0x5f, 0xb1, 0xda, 0x81, 0xa8, 0xda, 0xaa, 0x5b, 0xea, 0xda,
0x01, 0xbf, 0x63, 0xd7, 0xbf, 0x34, 0xe0, 0xd6, 0x41, 0x14, 0x75, 0xdb, 0x74, 0x4b, 0x7d, 0xf5,
0xdf, 0xaf, 0x10, 0xf9, 0x0d, 0xbb, 0xb4, 0x14, 0x30, 0x8a, 0xa6, 0xad, 0xba, 0x46, 0x97, 0xe0,
0xb7, 0x6c, 0xe1, 0xd1, 0x53, 0x38, 0x89, 0x8b, 0x7c, 0x9e, 0xea, 0xe5, 0xfd, 0xf3, 0xad, 0x77,
0xe3, 0x2e, 0x19, 0x69, 0xc9, 0xab, 0xf2, 0xd7, 0xba, 0xac, 0xe9, 0x69, 0xdd, 0xe3, 0x90, 0x3f,
0x56, 0xe7, 0x67, 0x3e, 0xcf, 0x65, 0x16, 0x19, 0x3c, 0xfe, 0x05, 0x00, 0x00, 0xff, 0xff, 0x10,
0xb1, 0xd0, 0xe7, 0x1a, 0x01, 0x00, 0x00,
}

325
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/resource_preset_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,325 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/clickhouse/v1/resource_preset_service.proto
package clickhouse // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetResourcePresetRequest struct {
// ID of the resource preset to return.
// To get the resource preset ID, use a [ResourcePresetService.List] request.
ResourcePresetId string `protobuf:"bytes,1,opt,name=resource_preset_id,json=resourcePresetId,proto3" json:"resource_preset_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetResourcePresetRequest) Reset() { *m = GetResourcePresetRequest{} }
func (m *GetResourcePresetRequest) String() string { return proto.CompactTextString(m) }
func (*GetResourcePresetRequest) ProtoMessage() {}
func (*GetResourcePresetRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_service_3c94510b9cb0b96a, []int{0}
}
func (m *GetResourcePresetRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetResourcePresetRequest.Unmarshal(m, b)
}
func (m *GetResourcePresetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetResourcePresetRequest.Marshal(b, m, deterministic)
}
func (dst *GetResourcePresetRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetResourcePresetRequest.Merge(dst, src)
}
func (m *GetResourcePresetRequest) XXX_Size() int {
return xxx_messageInfo_GetResourcePresetRequest.Size(m)
}
func (m *GetResourcePresetRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetResourcePresetRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetResourcePresetRequest proto.InternalMessageInfo
func (m *GetResourcePresetRequest) GetResourcePresetId() string {
if m != nil {
return m.ResourcePresetId
}
return ""
}
type ListResourcePresetsRequest struct {
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size], the service returns a [ListResourcePresetsResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, Set [page_token] to the [ListResourcePresetsResponse.next_page_token]
// returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListResourcePresetsRequest) Reset() { *m = ListResourcePresetsRequest{} }
func (m *ListResourcePresetsRequest) String() string { return proto.CompactTextString(m) }
func (*ListResourcePresetsRequest) ProtoMessage() {}
func (*ListResourcePresetsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_service_3c94510b9cb0b96a, []int{1}
}
func (m *ListResourcePresetsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListResourcePresetsRequest.Unmarshal(m, b)
}
func (m *ListResourcePresetsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListResourcePresetsRequest.Marshal(b, m, deterministic)
}
func (dst *ListResourcePresetsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListResourcePresetsRequest.Merge(dst, src)
}
func (m *ListResourcePresetsRequest) XXX_Size() int {
return xxx_messageInfo_ListResourcePresetsRequest.Size(m)
}
func (m *ListResourcePresetsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListResourcePresetsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListResourcePresetsRequest proto.InternalMessageInfo
func (m *ListResourcePresetsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListResourcePresetsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListResourcePresetsResponse struct {
// List of ResourcePreset resources.
ResourcePresets []*ResourcePreset `protobuf:"bytes,1,rep,name=resource_presets,json=resourcePresets,proto3" json:"resource_presets,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListResourcePresetsRequest.page_size], use the [next_page_token] as the value
// for the [ListResourcePresetsRequest.page_token] parameter in the next list request. Each subsequent
// list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListResourcePresetsResponse) Reset() { *m = ListResourcePresetsResponse{} }
func (m *ListResourcePresetsResponse) String() string { return proto.CompactTextString(m) }
func (*ListResourcePresetsResponse) ProtoMessage() {}
func (*ListResourcePresetsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_service_3c94510b9cb0b96a, []int{2}
}
func (m *ListResourcePresetsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListResourcePresetsResponse.Unmarshal(m, b)
}
func (m *ListResourcePresetsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListResourcePresetsResponse.Marshal(b, m, deterministic)
}
func (dst *ListResourcePresetsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListResourcePresetsResponse.Merge(dst, src)
}
func (m *ListResourcePresetsResponse) XXX_Size() int {
return xxx_messageInfo_ListResourcePresetsResponse.Size(m)
}
func (m *ListResourcePresetsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListResourcePresetsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListResourcePresetsResponse proto.InternalMessageInfo
func (m *ListResourcePresetsResponse) GetResourcePresets() []*ResourcePreset {
if m != nil {
return m.ResourcePresets
}
return nil
}
func (m *ListResourcePresetsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetResourcePresetRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.GetResourcePresetRequest")
proto.RegisterType((*ListResourcePresetsRequest)(nil), "yandex.cloud.mdb.clickhouse.v1.ListResourcePresetsRequest")
proto.RegisterType((*ListResourcePresetsResponse)(nil), "yandex.cloud.mdb.clickhouse.v1.ListResourcePresetsResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// ResourcePresetServiceClient is the client API for ResourcePresetService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ResourcePresetServiceClient interface {
// Returns the specified ResourcePreset resource.
//
// To get the list of available ResourcePreset resources, make a [List] request.
Get(ctx context.Context, in *GetResourcePresetRequest, opts ...grpc.CallOption) (*ResourcePreset, error)
// Retrieves the list of available ResourcePreset resources.
List(ctx context.Context, in *ListResourcePresetsRequest, opts ...grpc.CallOption) (*ListResourcePresetsResponse, error)
}
type resourcePresetServiceClient struct {
cc *grpc.ClientConn
}
func NewResourcePresetServiceClient(cc *grpc.ClientConn) ResourcePresetServiceClient {
return &resourcePresetServiceClient{cc}
}
func (c *resourcePresetServiceClient) Get(ctx context.Context, in *GetResourcePresetRequest, opts ...grpc.CallOption) (*ResourcePreset, error) {
out := new(ResourcePreset)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.ResourcePresetService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *resourcePresetServiceClient) List(ctx context.Context, in *ListResourcePresetsRequest, opts ...grpc.CallOption) (*ListResourcePresetsResponse, error) {
out := new(ListResourcePresetsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.clickhouse.v1.ResourcePresetService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// ResourcePresetServiceServer is the server API for ResourcePresetService service.
type ResourcePresetServiceServer interface {
// Returns the specified ResourcePreset resource.
//
// To get the list of available ResourcePreset resources, make a [List] request.
Get(context.Context, *GetResourcePresetRequest) (*ResourcePreset, error)
// Retrieves the list of available ResourcePreset resources.
List(context.Context, *ListResourcePresetsRequest) (*ListResourcePresetsResponse, error)
}
func RegisterResourcePresetServiceServer(s *grpc.Server, srv ResourcePresetServiceServer) {
s.RegisterService(&_ResourcePresetService_serviceDesc, srv)
}
func _ResourcePresetService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetResourcePresetRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ResourcePresetServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.ResourcePresetService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ResourcePresetServiceServer).Get(ctx, req.(*GetResourcePresetRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ResourcePresetService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListResourcePresetsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ResourcePresetServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.clickhouse.v1.ResourcePresetService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ResourcePresetServiceServer).List(ctx, req.(*ListResourcePresetsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ResourcePresetService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.mdb.clickhouse.v1.ResourcePresetService",
HandlerType: (*ResourcePresetServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _ResourcePresetService_Get_Handler,
},
{
MethodName: "List",
Handler: _ResourcePresetService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/mdb/clickhouse/v1/resource_preset_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/clickhouse/v1/resource_preset_service.proto", fileDescriptor_resource_preset_service_3c94510b9cb0b96a)
}
var fileDescriptor_resource_preset_service_3c94510b9cb0b96a = []byte{
// 470 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x53, 0x4d, 0x6b, 0x13, 0x41,
0x18, 0x66, 0xba, 0xb5, 0x98, 0x51, 0x69, 0x19, 0x10, 0x96, 0xf5, 0x83, 0xb0, 0x87, 0xba, 0x97,
0xcc, 0x64, 0xab, 0x82, 0x34, 0xc9, 0x25, 0x1e, 0x8a, 0xa0, 0x58, 0xb6, 0x22, 0xe8, 0x25, 0x4c,
0x76, 0x5e, 0xb6, 0x43, 0x93, 0x99, 0x75, 0x67, 0x36, 0xd4, 0x8a, 0x20, 0x1e, 0x7b, 0xf5, 0x0f,
0xf8, 0x0f, 0xbc, 0xf8, 0x1f, 0xda, 0xbb, 0x7f, 0xc1, 0x83, 0xbf, 0xc1, 0x93, 0xec, 0x6c, 0x4a,
0x4d, 0xec, 0x87, 0xe9, 0x71, 0xf7, 0x99, 0xe7, 0x79, 0xde, 0xe7, 0xfd, 0xc0, 0xdd, 0xf7, 0x5c,
0x09, 0xd8, 0x67, 0xe9, 0x48, 0x97, 0x82, 0x8d, 0xc5, 0x90, 0xa5, 0x23, 0x99, 0xee, 0xed, 0xea,
0xd2, 0x00, 0x9b, 0xc4, 0xac, 0x00, 0xa3, 0xcb, 0x22, 0x85, 0x41, 0x5e, 0x80, 0x01, 0x3b, 0x30,
0x50, 0x4c, 0x64, 0x0a, 0x34, 0x2f, 0xb4, 0xd5, 0xe4, 0x7e, 0xcd, 0xa6, 0x8e, 0x4d, 0xc7, 0x62,
0x48, 0x4f, 0xd9, 0x74, 0x12, 0x07, 0x77, 0x33, 0xad, 0xb3, 0x11, 0x30, 0x9e, 0x4b, 0xc6, 0x95,
0xd2, 0x96, 0x5b, 0xa9, 0x95, 0xa9, 0xd9, 0xc1, 0xbd, 0x19, 0xef, 0x09, 0x1f, 0x49, 0xe1, 0xf0,
0x29, 0xfc, 0x68, 0xb1, 0xd2, 0x6a, 0x56, 0xf8, 0x1a, 0xfb, 0x5b, 0x60, 0x93, 0x29, 0xb6, 0xed,
0xa0, 0x04, 0xde, 0x95, 0x60, 0x2c, 0xd9, 0xc4, 0x64, 0x3e, 0x8f, 0x14, 0x3e, 0x6a, 0xa2, 0xa8,
0xd1, 0xbf, 0xf9, 0xeb, 0x28, 0x46, 0x87, 0xc7, 0xf1, 0x72, 0xb7, 0xf7, 0xb8, 0x9d, 0xac, 0x15,
0x33, 0x02, 0xcf, 0x44, 0xa8, 0x71, 0xf0, 0x5c, 0x9a, 0x39, 0x61, 0x73, 0xa2, 0xfc, 0x00, 0x37,
0x72, 0x9e, 0xc1, 0xc0, 0xc8, 0x03, 0xf0, 0x97, 0x9a, 0x28, 0xf2, 0xfa, 0xf8, 0xf7, 0x51, 0xbc,
0xd2, 0xed, 0xc5, 0xed, 0x76, 0x3b, 0xb9, 0x5e, 0x81, 0x3b, 0xf2, 0x00, 0x48, 0x84, 0xb1, 0x7b,
0x68, 0xf5, 0x1e, 0x28, 0xdf, 0x73, 0xd6, 0x8d, 0xc3, 0xe3, 0xf8, 0x9a, 0x7b, 0x99, 0x38, 0x95,
0x57, 0x15, 0x16, 0x7e, 0x45, 0xf8, 0xce, 0x99, 0x8e, 0x26, 0xd7, 0xca, 0x00, 0x79, 0x83, 0xd7,
0xe6, 0xc2, 0x18, 0x1f, 0x35, 0xbd, 0xe8, 0xc6, 0x06, 0xa5, 0x17, 0x8f, 0x85, 0xce, 0x75, 0x67,
0x75, 0x36, 0xac, 0x21, 0xeb, 0x78, 0x55, 0xc1, 0xbe, 0x1d, 0xfc, 0x55, 0x69, 0x95, 0xa9, 0x91,
0xdc, 0xaa, 0x7e, 0x6f, 0x9f, 0x94, 0xb8, 0xf1, 0xc9, 0xc3, 0xb7, 0x67, 0xb5, 0x76, 0xea, 0xf5,
0x20, 0xdf, 0x11, 0xf6, 0xb6, 0xc0, 0x92, 0x27, 0x97, 0x95, 0x72, 0xde, 0xac, 0x82, 0x05, 0x43,
0x84, 0x4f, 0x3f, 0xff, 0xf8, 0xf9, 0x65, 0xa9, 0x47, 0x3a, 0x6c, 0xcc, 0x15, 0xcf, 0x40, 0xb4,
0xce, 0xde, 0x96, 0x69, 0x46, 0xf6, 0xe1, 0xdf, 0x4d, 0xf8, 0x48, 0xbe, 0x21, 0xbc, 0x5c, 0xf5,
0x9c, 0x6c, 0x5e, 0xe6, 0x7e, 0xfe, 0x2e, 0x04, 0x9d, 0x2b, 0x71, 0xeb, 0xa9, 0x86, 0xd4, 0xc5,
0x88, 0xc8, 0xfa, 0xff, 0xc5, 0xe8, 0xbf, 0x7c, 0xfb, 0x22, 0x93, 0x76, 0xb7, 0x1c, 0xd2, 0x54,
0x8f, 0x59, 0x6d, 0xdc, 0xaa, 0x2f, 0x26, 0xd3, 0xad, 0x0c, 0x94, 0xbb, 0x0a, 0x76, 0xf1, 0x29,
0x75, 0x4e, 0xbf, 0x86, 0x2b, 0x8e, 0xf0, 0xf0, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8a, 0xea,
0x85, 0x77, 0x19, 0x04, 0x00, 0x00,
}

210
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/user.pb.go generated vendored Normal file
View File

@ -0,0 +1,210 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/clickhouse/v1/user.proto
package clickhouse // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// A ClickHouse User resource. For more information, see
// the [Developer's guide](/docs/managed-clickhouse/concepts).
type User struct {
// Name of the ClickHouse user.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// ID of the ClickHouse cluster the user belongs to.
ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Set of permissions granted to the user.
Permissions []*Permission `protobuf:"bytes,3,rep,name=permissions,proto3" json:"permissions,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *User) Reset() { *m = User{} }
func (m *User) String() string { return proto.CompactTextString(m) }
func (*User) ProtoMessage() {}
func (*User) Descriptor() ([]byte, []int) {
return fileDescriptor_user_002833f6340c62e6, []int{0}
}
func (m *User) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_User.Unmarshal(m, b)
}
func (m *User) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_User.Marshal(b, m, deterministic)
}
func (dst *User) XXX_Merge(src proto.Message) {
xxx_messageInfo_User.Merge(dst, src)
}
func (m *User) XXX_Size() int {
return xxx_messageInfo_User.Size(m)
}
func (m *User) XXX_DiscardUnknown() {
xxx_messageInfo_User.DiscardUnknown(m)
}
var xxx_messageInfo_User proto.InternalMessageInfo
func (m *User) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *User) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *User) GetPermissions() []*Permission {
if m != nil {
return m.Permissions
}
return nil
}
type Permission struct {
// Name of the database that the permission grants access to.
DatabaseName string `protobuf:"bytes,1,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Permission) Reset() { *m = Permission{} }
func (m *Permission) String() string { return proto.CompactTextString(m) }
func (*Permission) ProtoMessage() {}
func (*Permission) Descriptor() ([]byte, []int) {
return fileDescriptor_user_002833f6340c62e6, []int{1}
}
func (m *Permission) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Permission.Unmarshal(m, b)
}
func (m *Permission) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Permission.Marshal(b, m, deterministic)
}
func (dst *Permission) XXX_Merge(src proto.Message) {
xxx_messageInfo_Permission.Merge(dst, src)
}
func (m *Permission) XXX_Size() int {
return xxx_messageInfo_Permission.Size(m)
}
func (m *Permission) XXX_DiscardUnknown() {
xxx_messageInfo_Permission.DiscardUnknown(m)
}
var xxx_messageInfo_Permission proto.InternalMessageInfo
func (m *Permission) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type UserSpec struct {
// Name of the ClickHouse user.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Password of the ClickHouse user.
Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
// Set of permissions to grant to the user.
Permissions []*Permission `protobuf:"bytes,3,rep,name=permissions,proto3" json:"permissions,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UserSpec) Reset() { *m = UserSpec{} }
func (m *UserSpec) String() string { return proto.CompactTextString(m) }
func (*UserSpec) ProtoMessage() {}
func (*UserSpec) Descriptor() ([]byte, []int) {
return fileDescriptor_user_002833f6340c62e6, []int{2}
}
func (m *UserSpec) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UserSpec.Unmarshal(m, b)
}
func (m *UserSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UserSpec.Marshal(b, m, deterministic)
}
func (dst *UserSpec) XXX_Merge(src proto.Message) {
xxx_messageInfo_UserSpec.Merge(dst, src)
}
func (m *UserSpec) XXX_Size() int {
return xxx_messageInfo_UserSpec.Size(m)
}
func (m *UserSpec) XXX_DiscardUnknown() {
xxx_messageInfo_UserSpec.DiscardUnknown(m)
}
var xxx_messageInfo_UserSpec proto.InternalMessageInfo
func (m *UserSpec) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *UserSpec) GetPassword() string {
if m != nil {
return m.Password
}
return ""
}
func (m *UserSpec) GetPermissions() []*Permission {
if m != nil {
return m.Permissions
}
return nil
}
func init() {
proto.RegisterType((*User)(nil), "yandex.cloud.mdb.clickhouse.v1.User")
proto.RegisterType((*Permission)(nil), "yandex.cloud.mdb.clickhouse.v1.Permission")
proto.RegisterType((*UserSpec)(nil), "yandex.cloud.mdb.clickhouse.v1.UserSpec")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/clickhouse/v1/user.proto", fileDescriptor_user_002833f6340c62e6)
}
var fileDescriptor_user_002833f6340c62e6 = []byte{
// 332 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xac, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0xcf, 0x4d, 0x49, 0xd2, 0x4f, 0xce, 0xc9,
0x4c, 0xce, 0xce, 0xc8, 0x2f, 0x2d, 0x4e, 0xd5, 0x2f, 0x33, 0xd4, 0x2f, 0x2d, 0x4e, 0x2d, 0xd2,
0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x92, 0x83, 0x28, 0xd5, 0x03, 0x2b, 0xd5, 0xcb, 0x4d, 0x49,
0xd2, 0x43, 0x28, 0xd5, 0x2b, 0x33, 0x94, 0x92, 0x45, 0x31, 0xaa, 0x2c, 0x31, 0x27, 0x33, 0x25,
0xb1, 0x24, 0x33, 0x3f, 0x0f, 0xa2, 0x5d, 0xa9, 0x9d, 0x91, 0x8b, 0x25, 0xb4, 0x38, 0xb5, 0x48,
0x48, 0x88, 0x8b, 0x25, 0x2f, 0x31, 0x37, 0x55, 0x82, 0x51, 0x81, 0x51, 0x83, 0x33, 0x08, 0xcc,
0x16, 0x92, 0xe5, 0xe2, 0x4a, 0xce, 0x29, 0x2d, 0x2e, 0x49, 0x2d, 0x8a, 0xcf, 0x4c, 0x91, 0x60,
0x02, 0xcb, 0x70, 0x42, 0x45, 0x3c, 0x53, 0x84, 0x7c, 0xb8, 0xb8, 0x0b, 0x52, 0x8b, 0x72, 0x33,
0x8b, 0x8b, 0x33, 0xf3, 0xf3, 0x8a, 0x25, 0x98, 0x15, 0x98, 0x35, 0xb8, 0x8d, 0xb4, 0xf4, 0xf0,
0x3b, 0x48, 0x2f, 0x00, 0xae, 0x25, 0x08, 0x59, 0xbb, 0x92, 0x21, 0x17, 0x17, 0x42, 0x4a, 0x48,
0x99, 0x8b, 0x37, 0x25, 0xb1, 0x24, 0x31, 0x29, 0xb1, 0x38, 0x35, 0x1e, 0xc9, 0x5d, 0x3c, 0x30,
0x41, 0xbf, 0xc4, 0xdc, 0x54, 0xa5, 0x6d, 0x8c, 0x5c, 0x1c, 0x20, 0xc7, 0x07, 0x17, 0xa4, 0x26,
0x0b, 0x19, 0x22, 0x7b, 0xc0, 0x49, 0xf6, 0xc5, 0x71, 0x43, 0xc6, 0x4f, 0xc7, 0x0d, 0x79, 0xa3,
0x13, 0x75, 0xab, 0x1c, 0x75, 0xa3, 0x0c, 0x74, 0x2d, 0xe3, 0x63, 0xb5, 0xba, 0x4e, 0x18, 0xb2,
0xd8, 0xd8, 0x9a, 0x19, 0x43, 0xfd, 0xa7, 0xc9, 0xc5, 0x51, 0x90, 0x58, 0x5c, 0x5c, 0x9e, 0x5f,
0x04, 0xf5, 0x9d, 0x13, 0x2f, 0x48, 0x5b, 0xd7, 0x09, 0x43, 0x56, 0x0b, 0x5d, 0x43, 0x23, 0x8b,
0x20, 0xb8, 0x34, 0x75, 0xfd, 0xea, 0xe4, 0x1f, 0xe5, 0x9b, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4,
0x97, 0x9c, 0x9f, 0xab, 0x0f, 0x31, 0x44, 0x17, 0x12, 0x43, 0xe9, 0xf9, 0xba, 0xe9, 0xa9, 0x79,
0xe0, 0xc8, 0xd1, 0xc7, 0x9f, 0x0a, 0xac, 0x11, 0xbc, 0x24, 0x36, 0xb0, 0x06, 0x63, 0x40, 0x00,
0x00, 0x00, 0xff, 0xff, 0x8b, 0x24, 0x59, 0x97, 0x39, 0x02, 0x00, 0x00,
}

1099
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/clickhouse/v1/user_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

127
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/backup.pb.go generated vendored Normal file
View File

@ -0,0 +1,127 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/mongodb/v1/backup.proto
package mongodb // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// A MongoDB Backup resource. For more information, see the
// [Developer's Guide](/docs/managed-mongodb/concepts).
type Backup struct {
// ID of the backup.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the backup belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format
// (i.e. when the backup operation was completed).
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// ID of the MongoDB cluster that the backup was created for.
SourceClusterId string `protobuf:"bytes,4,opt,name=source_cluster_id,json=sourceClusterId,proto3" json:"source_cluster_id,omitempty"`
// Time when the backup operation was started.
StartedAt *timestamp.Timestamp `protobuf:"bytes,5,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Backup) Reset() { *m = Backup{} }
func (m *Backup) String() string { return proto.CompactTextString(m) }
func (*Backup) ProtoMessage() {}
func (*Backup) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_7bed62cf0a79db64, []int{0}
}
func (m *Backup) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Backup.Unmarshal(m, b)
}
func (m *Backup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Backup.Marshal(b, m, deterministic)
}
func (dst *Backup) XXX_Merge(src proto.Message) {
xxx_messageInfo_Backup.Merge(dst, src)
}
func (m *Backup) XXX_Size() int {
return xxx_messageInfo_Backup.Size(m)
}
func (m *Backup) XXX_DiscardUnknown() {
xxx_messageInfo_Backup.DiscardUnknown(m)
}
var xxx_messageInfo_Backup proto.InternalMessageInfo
func (m *Backup) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Backup) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Backup) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Backup) GetSourceClusterId() string {
if m != nil {
return m.SourceClusterId
}
return ""
}
func (m *Backup) GetStartedAt() *timestamp.Timestamp {
if m != nil {
return m.StartedAt
}
return nil
}
func init() {
proto.RegisterType((*Backup)(nil), "yandex.cloud.mdb.mongodb.v1.Backup")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/mongodb/v1/backup.proto", fileDescriptor_backup_7bed62cf0a79db64)
}
var fileDescriptor_backup_7bed62cf0a79db64 = []byte{
// 261 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x90, 0xc1, 0x4b, 0xc3, 0x30,
0x14, 0xc6, 0x69, 0xd5, 0x61, 0x23, 0x28, 0xf6, 0x54, 0xb6, 0x83, 0xc3, 0x53, 0x11, 0x96, 0x30,
0x3d, 0x89, 0xa7, 0xcd, 0x83, 0xec, 0x3a, 0x3c, 0x79, 0x29, 0x49, 0x5e, 0x16, 0x8b, 0x4d, 0xdf,
0x68, 0x5f, 0x86, 0xfe, 0xa5, 0xfe, 0x3b, 0x42, 0x92, 0x5d, 0xdd, 0x2d, 0x7c, 0xf9, 0xbd, 0xef,
0x07, 0x1f, 0xab, 0x7f, 0x64, 0x0f, 0xe6, 0x5b, 0xe8, 0x0e, 0x3d, 0x08, 0x07, 0x4a, 0x38, 0xec,
0x2d, 0x82, 0x12, 0x87, 0xa5, 0x50, 0x52, 0x7f, 0xf9, 0x3d, 0xdf, 0x0f, 0x48, 0x58, 0xce, 0x22,
0xc9, 0x03, 0xc9, 0x1d, 0x28, 0x9e, 0x48, 0x7e, 0x58, 0x4e, 0xef, 0x2c, 0xa2, 0xed, 0x8c, 0x08,
0xa8, 0xf2, 0x3b, 0x41, 0xad, 0x33, 0x23, 0x49, 0x97, 0xae, 0xef, 0x7f, 0x33, 0x36, 0x59, 0x87,
0xba, 0xf2, 0x9a, 0xe5, 0x2d, 0x54, 0xd9, 0x3c, 0xab, 0x8b, 0x6d, 0xde, 0x42, 0x39, 0x63, 0xc5,
0x0e, 0x3b, 0x30, 0x43, 0xd3, 0x42, 0x95, 0x87, 0xf8, 0x32, 0x06, 0x1b, 0x28, 0x9f, 0x19, 0xd3,
0x83, 0x91, 0x64, 0xa0, 0x91, 0x54, 0x9d, 0xcd, 0xb3, 0xfa, 0xea, 0x71, 0xca, 0xa3, 0x8d, 0x1f,
0x6d, 0xfc, 0xfd, 0x68, 0xdb, 0x16, 0x89, 0x5e, 0x51, 0xf9, 0xc0, 0x6e, 0x47, 0xf4, 0x83, 0x36,
0x8d, 0xee, 0xfc, 0x48, 0xb1, 0xff, 0x3c, 0xf4, 0xdf, 0xc4, 0x8f, 0xd7, 0x98, 0x47, 0xcd, 0x48,
0x72, 0x48, 0x9a, 0x8b, 0xd3, 0x9a, 0x44, 0xaf, 0x68, 0xbd, 0xf9, 0x78, 0xb3, 0x2d, 0x7d, 0x7a,
0xc5, 0x35, 0x3a, 0x11, 0x47, 0x5a, 0xc4, 0x39, 0x2d, 0x2e, 0xac, 0xe9, 0xc3, 0xb9, 0xf8, 0x67,
0xe7, 0x97, 0xf4, 0x54, 0x93, 0x80, 0x3e, 0xfd, 0x05, 0x00, 0x00, 0xff, 0xff, 0xae, 0x68, 0xff,
0xeb, 0x95, 0x01, 0x00, 0x00,
}

331
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/backup_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,331 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/mongodb/v1/backup_service.proto
package mongodb // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetBackupRequest struct {
// ID of the backup to return information about.
// To get the backup ID, use a [ClusterService.ListBackups] request.
BackupId string `protobuf:"bytes,1,opt,name=backup_id,json=backupId,proto3" json:"backup_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetBackupRequest) Reset() { *m = GetBackupRequest{} }
func (m *GetBackupRequest) String() string { return proto.CompactTextString(m) }
func (*GetBackupRequest) ProtoMessage() {}
func (*GetBackupRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_8136fe766e84b00c, []int{0}
}
func (m *GetBackupRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetBackupRequest.Unmarshal(m, b)
}
func (m *GetBackupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetBackupRequest.Marshal(b, m, deterministic)
}
func (dst *GetBackupRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetBackupRequest.Merge(dst, src)
}
func (m *GetBackupRequest) XXX_Size() int {
return xxx_messageInfo_GetBackupRequest.Size(m)
}
func (m *GetBackupRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetBackupRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetBackupRequest proto.InternalMessageInfo
func (m *GetBackupRequest) GetBackupId() string {
if m != nil {
return m.BackupId
}
return ""
}
type ListBackupsRequest struct {
// ID of the folder to list backups in.
// To get the folder ID, use a [yandex.cloud.resourcemanager.v1.FolderService.List] request.
FolderId string `protobuf:"bytes,1,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListBackupsResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListBackupsRequest) Reset() { *m = ListBackupsRequest{} }
func (m *ListBackupsRequest) String() string { return proto.CompactTextString(m) }
func (*ListBackupsRequest) ProtoMessage() {}
func (*ListBackupsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_8136fe766e84b00c, []int{1}
}
func (m *ListBackupsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListBackupsRequest.Unmarshal(m, b)
}
func (m *ListBackupsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListBackupsRequest.Marshal(b, m, deterministic)
}
func (dst *ListBackupsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListBackupsRequest.Merge(dst, src)
}
func (m *ListBackupsRequest) XXX_Size() int {
return xxx_messageInfo_ListBackupsRequest.Size(m)
}
func (m *ListBackupsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListBackupsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListBackupsRequest proto.InternalMessageInfo
func (m *ListBackupsRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *ListBackupsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListBackupsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListBackupsResponse struct {
// List of Backup resources.
Backups []*Backup `protobuf:"bytes,1,rep,name=backups,proto3" json:"backups,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListBackupsRequest.page_size], use the [next_page_token] as the value
// for the [ListBackupsRequest.page_token] parameter in the next list request. Each subsequent
// list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListBackupsResponse) Reset() { *m = ListBackupsResponse{} }
func (m *ListBackupsResponse) String() string { return proto.CompactTextString(m) }
func (*ListBackupsResponse) ProtoMessage() {}
func (*ListBackupsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_8136fe766e84b00c, []int{2}
}
func (m *ListBackupsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListBackupsResponse.Unmarshal(m, b)
}
func (m *ListBackupsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListBackupsResponse.Marshal(b, m, deterministic)
}
func (dst *ListBackupsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListBackupsResponse.Merge(dst, src)
}
func (m *ListBackupsResponse) XXX_Size() int {
return xxx_messageInfo_ListBackupsResponse.Size(m)
}
func (m *ListBackupsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListBackupsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListBackupsResponse proto.InternalMessageInfo
func (m *ListBackupsResponse) GetBackups() []*Backup {
if m != nil {
return m.Backups
}
return nil
}
func (m *ListBackupsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetBackupRequest)(nil), "yandex.cloud.mdb.mongodb.v1.GetBackupRequest")
proto.RegisterType((*ListBackupsRequest)(nil), "yandex.cloud.mdb.mongodb.v1.ListBackupsRequest")
proto.RegisterType((*ListBackupsResponse)(nil), "yandex.cloud.mdb.mongodb.v1.ListBackupsResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// BackupServiceClient is the client API for BackupService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type BackupServiceClient interface {
// Returns the specified MongoDB Backup resource.
//
// To get the list of available MongoDB Backup resources, make a [List] request.
Get(ctx context.Context, in *GetBackupRequest, opts ...grpc.CallOption) (*Backup, error)
// Retrieves the list of Backup resources available for the specified folder.
List(ctx context.Context, in *ListBackupsRequest, opts ...grpc.CallOption) (*ListBackupsResponse, error)
}
type backupServiceClient struct {
cc *grpc.ClientConn
}
func NewBackupServiceClient(cc *grpc.ClientConn) BackupServiceClient {
return &backupServiceClient{cc}
}
func (c *backupServiceClient) Get(ctx context.Context, in *GetBackupRequest, opts ...grpc.CallOption) (*Backup, error) {
out := new(Backup)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.mongodb.v1.BackupService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *backupServiceClient) List(ctx context.Context, in *ListBackupsRequest, opts ...grpc.CallOption) (*ListBackupsResponse, error) {
out := new(ListBackupsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.mongodb.v1.BackupService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// BackupServiceServer is the server API for BackupService service.
type BackupServiceServer interface {
// Returns the specified MongoDB Backup resource.
//
// To get the list of available MongoDB Backup resources, make a [List] request.
Get(context.Context, *GetBackupRequest) (*Backup, error)
// Retrieves the list of Backup resources available for the specified folder.
List(context.Context, *ListBackupsRequest) (*ListBackupsResponse, error)
}
func RegisterBackupServiceServer(s *grpc.Server, srv BackupServiceServer) {
s.RegisterService(&_BackupService_serviceDesc, srv)
}
func _BackupService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetBackupRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BackupServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.mongodb.v1.BackupService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BackupServiceServer).Get(ctx, req.(*GetBackupRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BackupService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListBackupsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BackupServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.mongodb.v1.BackupService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BackupServiceServer).List(ctx, req.(*ListBackupsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _BackupService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.mdb.mongodb.v1.BackupService",
HandlerType: (*BackupServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _BackupService_Get_Handler,
},
{
MethodName: "List",
Handler: _BackupService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/mdb/mongodb/v1/backup_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/mongodb/v1/backup_service.proto", fileDescriptor_backup_service_8136fe766e84b00c)
}
var fileDescriptor_backup_service_8136fe766e84b00c = []byte{
// 459 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x31, 0x6f, 0xd3, 0x40,
0x14, 0xc7, 0xe5, 0x24, 0x94, 0xf8, 0xa0, 0x02, 0x1d, 0x4b, 0x94, 0x52, 0x29, 0xb8, 0x12, 0x75,
0x87, 0xf8, 0xec, 0xa2, 0x4e, 0x34, 0x4b, 0x96, 0x28, 0x12, 0x03, 0x72, 0x99, 0x58, 0xa2, 0x73,
0xee, 0x71, 0x9c, 0x1a, 0xdf, 0x99, 0xdc, 0xc5, 0x2a, 0x05, 0x16, 0xc6, 0x0c, 0x0c, 0xf0, 0x39,
0xf8, 0x1c, 0xed, 0xce, 0x57, 0x60, 0xe0, 0x33, 0x30, 0x21, 0xdf, 0x39, 0x40, 0xa9, 0x64, 0xba,
0x9d, 0xee, 0xff, 0x7e, 0xef, 0xfd, 0xf5, 0x7f, 0x0f, 0xc5, 0x6f, 0xa9, 0x64, 0x70, 0x46, 0xe6,
0x0b, 0xb5, 0x62, 0x24, 0x67, 0x19, 0xc9, 0x95, 0xe4, 0x8a, 0x65, 0xa4, 0x4c, 0x48, 0x46, 0xe7,
0xa7, 0xab, 0x62, 0xa6, 0x61, 0x59, 0x8a, 0x39, 0x44, 0xc5, 0x52, 0x19, 0x85, 0x77, 0x1c, 0x11,
0x59, 0x22, 0xca, 0x59, 0x16, 0xd5, 0x44, 0x54, 0x26, 0xfd, 0x87, 0x5c, 0x29, 0xbe, 0x00, 0x42,
0x0b, 0x41, 0xa8, 0x94, 0xca, 0x50, 0x23, 0x94, 0xd4, 0x0e, 0xed, 0xef, 0x5e, 0x19, 0x56, 0xd2,
0x85, 0x60, 0x56, 0xaf, 0xe5, 0xf0, 0xff, 0x5e, 0x5c, 0x65, 0x70, 0x84, 0xee, 0x4f, 0xc0, 0x8c,
0xed, 0x57, 0x0a, 0x6f, 0x56, 0xa0, 0x0d, 0x7e, 0x84, 0xfc, 0xda, 0xaf, 0x60, 0x3d, 0x6f, 0xe0,
0x85, 0xfe, 0xb8, 0xf3, 0xe3, 0x22, 0xf1, 0xd2, 0xae, 0xfb, 0x9e, 0xb2, 0xe0, 0xb3, 0x87, 0xf0,
0x33, 0xa1, 0x6b, 0x50, 0x6f, 0xc8, 0x03, 0xe4, 0xbf, 0x52, 0x0b, 0x06, 0xcb, 0x3f, 0xe4, 0xdd,
0x8a, 0x5c, 0x5f, 0x26, 0x9d, 0xe3, 0xd1, 0x51, 0x9c, 0x76, 0x9d, 0x3c, 0x65, 0x78, 0x1f, 0xf9,
0x05, 0xe5, 0x30, 0xd3, 0xe2, 0x1c, 0x7a, 0xad, 0x81, 0x17, 0xb6, 0xc7, 0xe8, 0xe7, 0x45, 0xb2,
0x75, 0x3c, 0x4a, 0xe2, 0x38, 0x4e, 0xbb, 0x95, 0x78, 0x22, 0xce, 0x01, 0x87, 0x08, 0xd9, 0x42,
0xa3, 0x4e, 0x41, 0xf6, 0xda, 0xb6, 0xa9, 0xbf, 0xbe, 0x4c, 0x6e, 0xd9, 0xca, 0xd4, 0x76, 0x79,
0x51, 0x69, 0xc1, 0x7b, 0xf4, 0xe0, 0x8a, 0x27, 0x5d, 0x28, 0xa9, 0x01, 0x8f, 0xd0, 0x6d, 0xe7,
0x5b, 0xf7, 0xbc, 0x41, 0x3b, 0xbc, 0x73, 0xb8, 0x17, 0x35, 0x04, 0x1f, 0xd5, 0x59, 0x6c, 0x18,
0xfc, 0x18, 0xdd, 0x93, 0x70, 0x66, 0x66, 0x7f, 0x99, 0xa8, 0xec, 0xfa, 0xe9, 0x76, 0xf5, 0xfd,
0x7c, 0x33, 0xfd, 0xf0, 0x6b, 0x0b, 0x6d, 0x3b, 0xf6, 0xc4, 0x6d, 0x19, 0xaf, 0x3d, 0xd4, 0x9e,
0x80, 0xc1, 0xc3, 0xc6, 0x79, 0xff, 0xc6, 0xdf, 0xbf, 0x89, 0xbd, 0x80, 0x7c, 0xfc, 0xf6, 0xfd,
0x4b, 0xeb, 0x00, 0xef, 0x93, 0x9c, 0x4a, 0xca, 0x81, 0x0d, 0xaf, 0x6d, 0x58, 0x93, 0x77, 0xbf,
0xd7, 0xf8, 0x01, 0x7f, 0xf2, 0x50, 0xa7, 0x4a, 0x07, 0x93, 0xc6, 0xf6, 0xd7, 0x97, 0xda, 0x8f,
0x6f, 0x0e, 0xb8, 0xc4, 0x83, 0x3d, 0x6b, 0x6e, 0x17, 0xef, 0x34, 0x98, 0x1b, 0x4f, 0x5f, 0x4e,
0xb8, 0x30, 0xaf, 0x57, 0x59, 0x34, 0x57, 0x39, 0x71, 0x23, 0x86, 0xee, 0x60, 0xb9, 0x1a, 0x72,
0x90, 0xf6, 0x40, 0x49, 0xc3, 0x25, 0x3f, 0xad, 0x9f, 0xd9, 0x96, 0x2d, 0x7d, 0xf2, 0x2b, 0x00,
0x00, 0xff, 0xff, 0x1f, 0x32, 0xcb, 0x4a, 0x83, 0x03, 0x00, 0x00,
}

987
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/cluster.pb.go generated vendored Normal file
View File

@ -0,0 +1,987 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/mongodb/v1/cluster.proto
package mongodb // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
import config "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/config"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Deployment environment.
type Cluster_Environment int32
const (
Cluster_ENVIRONMENT_UNSPECIFIED Cluster_Environment = 0
// Stable environment with a conservative update policy:
// only hotfixes are applied during regular maintenance.
Cluster_PRODUCTION Cluster_Environment = 1
// Environment with more aggressive update policy: new versions
// are rolled out irrespective of backward compatibility.
Cluster_PRESTABLE Cluster_Environment = 2
)
var Cluster_Environment_name = map[int32]string{
0: "ENVIRONMENT_UNSPECIFIED",
1: "PRODUCTION",
2: "PRESTABLE",
}
var Cluster_Environment_value = map[string]int32{
"ENVIRONMENT_UNSPECIFIED": 0,
"PRODUCTION": 1,
"PRESTABLE": 2,
}
func (x Cluster_Environment) String() string {
return proto.EnumName(Cluster_Environment_name, int32(x))
}
func (Cluster_Environment) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_cluster_939f865571591ca8, []int{0, 0}
}
type Cluster_Health int32
const (
// State of the cluster is unknown ([Host.health] for every host in the cluster is UNKNOWN).
Cluster_HEALTH_UNKNOWN Cluster_Health = 0
// Cluster is alive and well ([Host.health] for every host in the cluster is ALIVE).
Cluster_ALIVE Cluster_Health = 1
// Cluster is inoperable ([Host.health] for every host in the cluster is DEAD).
Cluster_DEAD Cluster_Health = 2
// Cluster is working below capacity ([Host.health] for at least one host in the cluster is not ALIVE).
Cluster_DEGRADED Cluster_Health = 3
)
var Cluster_Health_name = map[int32]string{
0: "HEALTH_UNKNOWN",
1: "ALIVE",
2: "DEAD",
3: "DEGRADED",
}
var Cluster_Health_value = map[string]int32{
"HEALTH_UNKNOWN": 0,
"ALIVE": 1,
"DEAD": 2,
"DEGRADED": 3,
}
func (x Cluster_Health) String() string {
return proto.EnumName(Cluster_Health_name, int32(x))
}
func (Cluster_Health) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_cluster_939f865571591ca8, []int{0, 1}
}
type Cluster_Status int32
const (
// Cluster state is unknown.
Cluster_STATUS_UNKNOWN Cluster_Status = 0
// Cluster is being created.
Cluster_CREATING Cluster_Status = 1
// Cluster is running normally.
Cluster_RUNNING Cluster_Status = 2
// Cluster encountered a problem and cannot operate.
Cluster_ERROR Cluster_Status = 3
// Cluster is being updated.
Cluster_UPDATING Cluster_Status = 4
// Cluster is stopping.
Cluster_STOPPING Cluster_Status = 5
// Cluster stopped.
Cluster_STOPPED Cluster_Status = 6
// Cluster is starting.
Cluster_STARTING Cluster_Status = 7
)
var Cluster_Status_name = map[int32]string{
0: "STATUS_UNKNOWN",
1: "CREATING",
2: "RUNNING",
3: "ERROR",
4: "UPDATING",
5: "STOPPING",
6: "STOPPED",
7: "STARTING",
}
var Cluster_Status_value = map[string]int32{
"STATUS_UNKNOWN": 0,
"CREATING": 1,
"RUNNING": 2,
"ERROR": 3,
"UPDATING": 4,
"STOPPING": 5,
"STOPPED": 6,
"STARTING": 7,
}
func (x Cluster_Status) String() string {
return proto.EnumName(Cluster_Status_name, int32(x))
}
func (Cluster_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_cluster_939f865571591ca8, []int{0, 2}
}
type Host_Role int32
const (
// Role of the host in the cluster is unknown.
Host_ROLE_UNKNOWN Host_Role = 0
// Host is the primary MongoDB server in the cluster.
Host_PRIMARY Host_Role = 1
// Host is a secondary MongoDB server in the cluster.
Host_SECONDARY Host_Role = 2
)
var Host_Role_name = map[int32]string{
0: "ROLE_UNKNOWN",
1: "PRIMARY",
2: "SECONDARY",
}
var Host_Role_value = map[string]int32{
"ROLE_UNKNOWN": 0,
"PRIMARY": 1,
"SECONDARY": 2,
}
func (x Host_Role) String() string {
return proto.EnumName(Host_Role_name, int32(x))
}
func (Host_Role) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_cluster_939f865571591ca8, []int{4, 0}
}
type Host_Health int32
const (
// Health of the host is unknown.
Host_HEALTH_UNKNOWN Host_Health = 0
// The host is performing all its functions normally.
Host_ALIVE Host_Health = 1
// The host is inoperable, and cannot perform any of its essential functions.
Host_DEAD Host_Health = 2
// The host is degraded, and can perform only some of its essential functions.
Host_DEGRADED Host_Health = 3
)
var Host_Health_name = map[int32]string{
0: "HEALTH_UNKNOWN",
1: "ALIVE",
2: "DEAD",
3: "DEGRADED",
}
var Host_Health_value = map[string]int32{
"HEALTH_UNKNOWN": 0,
"ALIVE": 1,
"DEAD": 2,
"DEGRADED": 3,
}
func (x Host_Health) String() string {
return proto.EnumName(Host_Health_name, int32(x))
}
func (Host_Health) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_cluster_939f865571591ca8, []int{4, 1}
}
type Service_Type int32
const (
Service_TYPE_UNSPECIFIED Service_Type = 0
// The host is running a mongod daemon.
Service_MONGOD Service_Type = 1
// The host is running a mongos daemon.
Service_MONGOS Service_Type = 2
// The host is running a MongoDB config server.
Service_MONGOCFG Service_Type = 3
)
var Service_Type_name = map[int32]string{
0: "TYPE_UNSPECIFIED",
1: "MONGOD",
2: "MONGOS",
3: "MONGOCFG",
}
var Service_Type_value = map[string]int32{
"TYPE_UNSPECIFIED": 0,
"MONGOD": 1,
"MONGOS": 2,
"MONGOCFG": 3,
}
func (x Service_Type) String() string {
return proto.EnumName(Service_Type_name, int32(x))
}
func (Service_Type) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_cluster_939f865571591ca8, []int{5, 0}
}
type Service_Health int32
const (
// Health of the server is unknown.
Service_HEALTH_UNKNOWN Service_Health = 0
// The server is working normally.
Service_ALIVE Service_Health = 1
// The server is dead or unresponsive.
Service_DEAD Service_Health = 2
)
var Service_Health_name = map[int32]string{
0: "HEALTH_UNKNOWN",
1: "ALIVE",
2: "DEAD",
}
var Service_Health_value = map[string]int32{
"HEALTH_UNKNOWN": 0,
"ALIVE": 1,
"DEAD": 2,
}
func (x Service_Health) String() string {
return proto.EnumName(Service_Health_name, int32(x))
}
func (Service_Health) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_cluster_939f865571591ca8, []int{5, 1}
}
// A MongoDB Cluster resource. For more information, see the
// [Cluster](/docs/managed-mongodb/concepts) section in the Developer's Guide.
type Cluster struct {
// ID of the MongoDB cluster.
// This ID is assigned by MDB at creation time.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the MongoDB cluster belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Name of the MongoDB cluster.
// The name is unique within the folder. 1-63 characters long.
Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
// Description of the MongoDB cluster. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
// Custom labels for the MongoDB cluster as `` key:value `` pairs. Maximum 64 per resource.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Deployment environment of the MongoDB cluster.
Environment Cluster_Environment `protobuf:"varint,7,opt,name=environment,proto3,enum=yandex.cloud.mdb.mongodb.v1.Cluster_Environment" json:"environment,omitempty"`
// Description of monitoring systems relevant to the MongoDB cluster.
Monitoring []*Monitoring `protobuf:"bytes,8,rep,name=monitoring,proto3" json:"monitoring,omitempty"`
// Configuration of the MongoDB cluster.
Config *ClusterConfig `protobuf:"bytes,9,opt,name=config,proto3" json:"config,omitempty"`
// ID of the network that the cluster belongs to.
NetworkId string `protobuf:"bytes,10,opt,name=network_id,json=networkId,proto3" json:"network_id,omitempty"`
// Aggregated cluster health.
Health Cluster_Health `protobuf:"varint,11,opt,name=health,proto3,enum=yandex.cloud.mdb.mongodb.v1.Cluster_Health" json:"health,omitempty"`
// Current state of the cluster.
Status Cluster_Status `protobuf:"varint,12,opt,name=status,proto3,enum=yandex.cloud.mdb.mongodb.v1.Cluster_Status" json:"status,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Cluster) Reset() { *m = Cluster{} }
func (m *Cluster) String() string { return proto.CompactTextString(m) }
func (*Cluster) ProtoMessage() {}
func (*Cluster) Descriptor() ([]byte, []int) {
return fileDescriptor_cluster_939f865571591ca8, []int{0}
}
func (m *Cluster) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Cluster.Unmarshal(m, b)
}
func (m *Cluster) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Cluster.Marshal(b, m, deterministic)
}
func (dst *Cluster) XXX_Merge(src proto.Message) {
xxx_messageInfo_Cluster.Merge(dst, src)
}
func (m *Cluster) XXX_Size() int {
return xxx_messageInfo_Cluster.Size(m)
}
func (m *Cluster) XXX_DiscardUnknown() {
xxx_messageInfo_Cluster.DiscardUnknown(m)
}
var xxx_messageInfo_Cluster proto.InternalMessageInfo
func (m *Cluster) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Cluster) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Cluster) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Cluster) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Cluster) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Cluster) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *Cluster) GetEnvironment() Cluster_Environment {
if m != nil {
return m.Environment
}
return Cluster_ENVIRONMENT_UNSPECIFIED
}
func (m *Cluster) GetMonitoring() []*Monitoring {
if m != nil {
return m.Monitoring
}
return nil
}
func (m *Cluster) GetConfig() *ClusterConfig {
if m != nil {
return m.Config
}
return nil
}
func (m *Cluster) GetNetworkId() string {
if m != nil {
return m.NetworkId
}
return ""
}
func (m *Cluster) GetHealth() Cluster_Health {
if m != nil {
return m.Health
}
return Cluster_HEALTH_UNKNOWN
}
func (m *Cluster) GetStatus() Cluster_Status {
if m != nil {
return m.Status
}
return Cluster_STATUS_UNKNOWN
}
// Monitoring system.
type Monitoring struct {
// Name of the monitoring system.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Description of the monitoring system.
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
// Link to the monitoring system charts for the MongoDB cluster.
Link string `protobuf:"bytes,3,opt,name=link,proto3" json:"link,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Monitoring) Reset() { *m = Monitoring{} }
func (m *Monitoring) String() string { return proto.CompactTextString(m) }
func (*Monitoring) ProtoMessage() {}
func (*Monitoring) Descriptor() ([]byte, []int) {
return fileDescriptor_cluster_939f865571591ca8, []int{1}
}
func (m *Monitoring) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Monitoring.Unmarshal(m, b)
}
func (m *Monitoring) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Monitoring.Marshal(b, m, deterministic)
}
func (dst *Monitoring) XXX_Merge(src proto.Message) {
xxx_messageInfo_Monitoring.Merge(dst, src)
}
func (m *Monitoring) XXX_Size() int {
return xxx_messageInfo_Monitoring.Size(m)
}
func (m *Monitoring) XXX_DiscardUnknown() {
xxx_messageInfo_Monitoring.DiscardUnknown(m)
}
var xxx_messageInfo_Monitoring proto.InternalMessageInfo
func (m *Monitoring) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Monitoring) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Monitoring) GetLink() string {
if m != nil {
return m.Link
}
return ""
}
type ClusterConfig struct {
// Version of MongoDB server software.
Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
// Configuration for MongoDB servers in the cluster.
//
// Types that are valid to be assigned to Mongodb:
// *ClusterConfig_Mongodb_3_6
Mongodb isClusterConfig_Mongodb `protobuf_oneof:"mongodb"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ClusterConfig) Reset() { *m = ClusterConfig{} }
func (m *ClusterConfig) String() string { return proto.CompactTextString(m) }
func (*ClusterConfig) ProtoMessage() {}
func (*ClusterConfig) Descriptor() ([]byte, []int) {
return fileDescriptor_cluster_939f865571591ca8, []int{2}
}
func (m *ClusterConfig) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ClusterConfig.Unmarshal(m, b)
}
func (m *ClusterConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ClusterConfig.Marshal(b, m, deterministic)
}
func (dst *ClusterConfig) XXX_Merge(src proto.Message) {
xxx_messageInfo_ClusterConfig.Merge(dst, src)
}
func (m *ClusterConfig) XXX_Size() int {
return xxx_messageInfo_ClusterConfig.Size(m)
}
func (m *ClusterConfig) XXX_DiscardUnknown() {
xxx_messageInfo_ClusterConfig.DiscardUnknown(m)
}
var xxx_messageInfo_ClusterConfig proto.InternalMessageInfo
func (m *ClusterConfig) GetVersion() string {
if m != nil {
return m.Version
}
return ""
}
type isClusterConfig_Mongodb interface {
isClusterConfig_Mongodb()
}
type ClusterConfig_Mongodb_3_6 struct {
Mongodb_3_6 *Mongodb3_6 `protobuf:"bytes,2,opt,name=mongodb_3_6,json=mongodb36,proto3,oneof"`
}
func (*ClusterConfig_Mongodb_3_6) isClusterConfig_Mongodb() {}
func (m *ClusterConfig) GetMongodb() isClusterConfig_Mongodb {
if m != nil {
return m.Mongodb
}
return nil
}
func (m *ClusterConfig) GetMongodb_3_6() *Mongodb3_6 {
if x, ok := m.GetMongodb().(*ClusterConfig_Mongodb_3_6); ok {
return x.Mongodb_3_6
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*ClusterConfig) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _ClusterConfig_OneofMarshaler, _ClusterConfig_OneofUnmarshaler, _ClusterConfig_OneofSizer, []interface{}{
(*ClusterConfig_Mongodb_3_6)(nil),
}
}
func _ClusterConfig_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*ClusterConfig)
// mongodb
switch x := m.Mongodb.(type) {
case *ClusterConfig_Mongodb_3_6:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.Mongodb_3_6); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("ClusterConfig.Mongodb has unexpected type %T", x)
}
return nil
}
func _ClusterConfig_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*ClusterConfig)
switch tag {
case 2: // mongodb.mongodb_3_6
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(Mongodb3_6)
err := b.DecodeMessage(msg)
m.Mongodb = &ClusterConfig_Mongodb_3_6{msg}
return true, err
default:
return false, nil
}
}
func _ClusterConfig_OneofSizer(msg proto.Message) (n int) {
m := msg.(*ClusterConfig)
// mongodb
switch x := m.Mongodb.(type) {
case *ClusterConfig_Mongodb_3_6:
s := proto.Size(x.Mongodb_3_6)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
type Mongodb3_6 struct {
// Configuration and resource allocation for a MongoDB 3.6 cluster.
Mongod *Mongodb3_6_Mongod `protobuf:"bytes,1,opt,name=mongod,proto3" json:"mongod,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Mongodb3_6) Reset() { *m = Mongodb3_6{} }
func (m *Mongodb3_6) String() string { return proto.CompactTextString(m) }
func (*Mongodb3_6) ProtoMessage() {}
func (*Mongodb3_6) Descriptor() ([]byte, []int) {
return fileDescriptor_cluster_939f865571591ca8, []int{3}
}
func (m *Mongodb3_6) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Mongodb3_6.Unmarshal(m, b)
}
func (m *Mongodb3_6) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Mongodb3_6.Marshal(b, m, deterministic)
}
func (dst *Mongodb3_6) XXX_Merge(src proto.Message) {
xxx_messageInfo_Mongodb3_6.Merge(dst, src)
}
func (m *Mongodb3_6) XXX_Size() int {
return xxx_messageInfo_Mongodb3_6.Size(m)
}
func (m *Mongodb3_6) XXX_DiscardUnknown() {
xxx_messageInfo_Mongodb3_6.DiscardUnknown(m)
}
var xxx_messageInfo_Mongodb3_6 proto.InternalMessageInfo
func (m *Mongodb3_6) GetMongod() *Mongodb3_6_Mongod {
if m != nil {
return m.Mongod
}
return nil
}
type Mongodb3_6_Mongod struct {
// Configuration of a MongoDB 3.6 server.
Config *config.MongodConfigSet3_6 `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
// Resources allocated to MongoDB hosts.
Resources *Resources `protobuf:"bytes,2,opt,name=resources,proto3" json:"resources,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Mongodb3_6_Mongod) Reset() { *m = Mongodb3_6_Mongod{} }
func (m *Mongodb3_6_Mongod) String() string { return proto.CompactTextString(m) }
func (*Mongodb3_6_Mongod) ProtoMessage() {}
func (*Mongodb3_6_Mongod) Descriptor() ([]byte, []int) {
return fileDescriptor_cluster_939f865571591ca8, []int{3, 0}
}
func (m *Mongodb3_6_Mongod) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Mongodb3_6_Mongod.Unmarshal(m, b)
}
func (m *Mongodb3_6_Mongod) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Mongodb3_6_Mongod.Marshal(b, m, deterministic)
}
func (dst *Mongodb3_6_Mongod) XXX_Merge(src proto.Message) {
xxx_messageInfo_Mongodb3_6_Mongod.Merge(dst, src)
}
func (m *Mongodb3_6_Mongod) XXX_Size() int {
return xxx_messageInfo_Mongodb3_6_Mongod.Size(m)
}
func (m *Mongodb3_6_Mongod) XXX_DiscardUnknown() {
xxx_messageInfo_Mongodb3_6_Mongod.DiscardUnknown(m)
}
var xxx_messageInfo_Mongodb3_6_Mongod proto.InternalMessageInfo
func (m *Mongodb3_6_Mongod) GetConfig() *config.MongodConfigSet3_6 {
if m != nil {
return m.Config
}
return nil
}
func (m *Mongodb3_6_Mongod) GetResources() *Resources {
if m != nil {
return m.Resources
}
return nil
}
type Host struct {
// Name of the MongoDB host. The host name is assigned by MDB at creation time, and cannot be changed.
// 1-63 characters long.
//
// The name is unique across all existing MDB hosts in Yandex.Cloud, as it defines the FQDN of the host.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// ID of the MongoDB host. The ID is assigned by MDB at creation time.
ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// ID of the availability zone where the MongoDB host resides.
ZoneId string `protobuf:"bytes,3,opt,name=zone_id,json=zoneId,proto3" json:"zone_id,omitempty"`
// Resources allocated to the MongoDB host.
Resources *Resources `protobuf:"bytes,4,opt,name=resources,proto3" json:"resources,omitempty"`
// Role of the host in the cluster.
Role Host_Role `protobuf:"varint,5,opt,name=role,proto3,enum=yandex.cloud.mdb.mongodb.v1.Host_Role" json:"role,omitempty"`
// Status code of the aggregated health of the host.
Health Host_Health `protobuf:"varint,6,opt,name=health,proto3,enum=yandex.cloud.mdb.mongodb.v1.Host_Health" json:"health,omitempty"`
// Services provided by the host.
Services []*Service `protobuf:"bytes,7,rep,name=services,proto3" json:"services,omitempty"`
// ID of the subnet that the host belongs to.
SubnetId string `protobuf:"bytes,8,opt,name=subnet_id,json=subnetId,proto3" json:"subnet_id,omitempty"`
// Flag showing public IP assignment status to this host.
AssignPublicIp bool `protobuf:"varint,9,opt,name=assign_public_ip,json=assignPublicIp,proto3" json:"assign_public_ip,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Host) Reset() { *m = Host{} }
func (m *Host) String() string { return proto.CompactTextString(m) }
func (*Host) ProtoMessage() {}
func (*Host) Descriptor() ([]byte, []int) {
return fileDescriptor_cluster_939f865571591ca8, []int{4}
}
func (m *Host) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Host.Unmarshal(m, b)
}
func (m *Host) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Host.Marshal(b, m, deterministic)
}
func (dst *Host) XXX_Merge(src proto.Message) {
xxx_messageInfo_Host.Merge(dst, src)
}
func (m *Host) XXX_Size() int {
return xxx_messageInfo_Host.Size(m)
}
func (m *Host) XXX_DiscardUnknown() {
xxx_messageInfo_Host.DiscardUnknown(m)
}
var xxx_messageInfo_Host proto.InternalMessageInfo
func (m *Host) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Host) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *Host) GetZoneId() string {
if m != nil {
return m.ZoneId
}
return ""
}
func (m *Host) GetResources() *Resources {
if m != nil {
return m.Resources
}
return nil
}
func (m *Host) GetRole() Host_Role {
if m != nil {
return m.Role
}
return Host_ROLE_UNKNOWN
}
func (m *Host) GetHealth() Host_Health {
if m != nil {
return m.Health
}
return Host_HEALTH_UNKNOWN
}
func (m *Host) GetServices() []*Service {
if m != nil {
return m.Services
}
return nil
}
func (m *Host) GetSubnetId() string {
if m != nil {
return m.SubnetId
}
return ""
}
func (m *Host) GetAssignPublicIp() bool {
if m != nil {
return m.AssignPublicIp
}
return false
}
type Service struct {
// Type of the service provided by the host.
Type Service_Type `protobuf:"varint,1,opt,name=type,proto3,enum=yandex.cloud.mdb.mongodb.v1.Service_Type" json:"type,omitempty"`
// Status code of server availability.
Health Service_Health `protobuf:"varint,2,opt,name=health,proto3,enum=yandex.cloud.mdb.mongodb.v1.Service_Health" json:"health,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Service) Reset() { *m = Service{} }
func (m *Service) String() string { return proto.CompactTextString(m) }
func (*Service) ProtoMessage() {}
func (*Service) Descriptor() ([]byte, []int) {
return fileDescriptor_cluster_939f865571591ca8, []int{5}
}
func (m *Service) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Service.Unmarshal(m, b)
}
func (m *Service) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Service.Marshal(b, m, deterministic)
}
func (dst *Service) XXX_Merge(src proto.Message) {
xxx_messageInfo_Service.Merge(dst, src)
}
func (m *Service) XXX_Size() int {
return xxx_messageInfo_Service.Size(m)
}
func (m *Service) XXX_DiscardUnknown() {
xxx_messageInfo_Service.DiscardUnknown(m)
}
var xxx_messageInfo_Service proto.InternalMessageInfo
func (m *Service) GetType() Service_Type {
if m != nil {
return m.Type
}
return Service_TYPE_UNSPECIFIED
}
func (m *Service) GetHealth() Service_Health {
if m != nil {
return m.Health
}
return Service_HEALTH_UNKNOWN
}
type Resources struct {
// ID of the preset for computational resources available to a host (CPU, memory etc.).
// All available presets are listed in the [documentation](/docs/managed-mongodb/concepts/instance-types).
ResourcePresetId string `protobuf:"bytes,1,opt,name=resource_preset_id,json=resourcePresetId,proto3" json:"resource_preset_id,omitempty"`
// Volume of the storage available to a host, in bytes.
DiskSize int64 `protobuf:"varint,2,opt,name=disk_size,json=diskSize,proto3" json:"disk_size,omitempty"`
// Type of the storage environment for the host.
// Possible values:
// * network-hdd — network HDD drive,
// * network-nvme — network SSD drive,
// * local-nvme — local SSD storage.
DiskTypeId string `protobuf:"bytes,3,opt,name=disk_type_id,json=diskTypeId,proto3" json:"disk_type_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Resources) Reset() { *m = Resources{} }
func (m *Resources) String() string { return proto.CompactTextString(m) }
func (*Resources) ProtoMessage() {}
func (*Resources) Descriptor() ([]byte, []int) {
return fileDescriptor_cluster_939f865571591ca8, []int{6}
}
func (m *Resources) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Resources.Unmarshal(m, b)
}
func (m *Resources) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Resources.Marshal(b, m, deterministic)
}
func (dst *Resources) XXX_Merge(src proto.Message) {
xxx_messageInfo_Resources.Merge(dst, src)
}
func (m *Resources) XXX_Size() int {
return xxx_messageInfo_Resources.Size(m)
}
func (m *Resources) XXX_DiscardUnknown() {
xxx_messageInfo_Resources.DiscardUnknown(m)
}
var xxx_messageInfo_Resources proto.InternalMessageInfo
func (m *Resources) GetResourcePresetId() string {
if m != nil {
return m.ResourcePresetId
}
return ""
}
func (m *Resources) GetDiskSize() int64 {
if m != nil {
return m.DiskSize
}
return 0
}
func (m *Resources) GetDiskTypeId() string {
if m != nil {
return m.DiskTypeId
}
return ""
}
func init() {
proto.RegisterType((*Cluster)(nil), "yandex.cloud.mdb.mongodb.v1.Cluster")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.mdb.mongodb.v1.Cluster.LabelsEntry")
proto.RegisterType((*Monitoring)(nil), "yandex.cloud.mdb.mongodb.v1.Monitoring")
proto.RegisterType((*ClusterConfig)(nil), "yandex.cloud.mdb.mongodb.v1.ClusterConfig")
proto.RegisterType((*Mongodb3_6)(nil), "yandex.cloud.mdb.mongodb.v1.Mongodb3_6")
proto.RegisterType((*Mongodb3_6_Mongod)(nil), "yandex.cloud.mdb.mongodb.v1.Mongodb3_6.Mongod")
proto.RegisterType((*Host)(nil), "yandex.cloud.mdb.mongodb.v1.Host")
proto.RegisterType((*Service)(nil), "yandex.cloud.mdb.mongodb.v1.Service")
proto.RegisterType((*Resources)(nil), "yandex.cloud.mdb.mongodb.v1.Resources")
proto.RegisterEnum("yandex.cloud.mdb.mongodb.v1.Cluster_Environment", Cluster_Environment_name, Cluster_Environment_value)
proto.RegisterEnum("yandex.cloud.mdb.mongodb.v1.Cluster_Health", Cluster_Health_name, Cluster_Health_value)
proto.RegisterEnum("yandex.cloud.mdb.mongodb.v1.Cluster_Status", Cluster_Status_name, Cluster_Status_value)
proto.RegisterEnum("yandex.cloud.mdb.mongodb.v1.Host_Role", Host_Role_name, Host_Role_value)
proto.RegisterEnum("yandex.cloud.mdb.mongodb.v1.Host_Health", Host_Health_name, Host_Health_value)
proto.RegisterEnum("yandex.cloud.mdb.mongodb.v1.Service_Type", Service_Type_name, Service_Type_value)
proto.RegisterEnum("yandex.cloud.mdb.mongodb.v1.Service_Health", Service_Health_name, Service_Health_value)
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/mongodb/v1/cluster.proto", fileDescriptor_cluster_939f865571591ca8)
}
var fileDescriptor_cluster_939f865571591ca8 = []byte{
// 1093 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xdf, 0x6f, 0xda, 0xd6,
0x17, 0xaf, 0xc1, 0x31, 0xf8, 0x90, 0x22, 0xeb, 0xaa, 0x52, 0xad, 0x54, 0xd5, 0x37, 0xb2, 0xbe,
0xda, 0xe8, 0xb6, 0x9a, 0x25, 0x99, 0xa2, 0xb5, 0xd3, 0xb4, 0x12, 0xec, 0x80, 0xb5, 0xc4, 0xa0,
0x6b, 0x93, 0xa9, 0x7b, 0xb1, 0x00, 0xdf, 0x10, 0x2b, 0xc6, 0x46, 0xb6, 0x61, 0x25, 0x2f, 0x7b,
0xd9, 0xdf, 0xb0, 0xc7, 0xfd, 0x27, 0xfb, 0xb3, 0xf6, 0x3e, 0xdd, 0x1f, 0x10, 0xd2, 0x6d, 0x94,
0x4e, 0x7b, 0xbb, 0xe7, 0xdc, 0xf3, 0xf9, 0xf8, 0xfc, 0xbe, 0x86, 0x17, 0xcb, 0x61, 0x12, 0x92,
0x77, 0xcd, 0x71, 0x9c, 0xce, 0xc3, 0xe6, 0x34, 0x1c, 0x35, 0xa7, 0x69, 0x32, 0x49, 0xc3, 0x51,
0x73, 0x71, 0xd4, 0x1c, 0xc7, 0xf3, 0xbc, 0x20, 0x99, 0x39, 0xcb, 0xd2, 0x22, 0x45, 0xcf, 0xb8,
0xa9, 0xc9, 0x4c, 0xcd, 0x69, 0x38, 0x32, 0x85, 0xa9, 0xb9, 0x38, 0x3a, 0xf8, 0xdf, 0x24, 0x4d,
0x27, 0x31, 0x69, 0x32, 0xd3, 0xd1, 0xfc, 0xba, 0x59, 0x44, 0x53, 0x92, 0x17, 0xc3, 0xe9, 0x8c,
0xa3, 0x0f, 0x4e, 0xb6, 0x7e, 0x28, 0x4d, 0xae, 0xa3, 0xc9, 0x4a, 0x73, 0x12, 0x9c, 0x72, 0x90,
0xf1, 0x7b, 0x05, 0x2a, 0x6d, 0xee, 0x04, 0xaa, 0x43, 0x29, 0x0a, 0x75, 0xe9, 0x50, 0x6a, 0xa8,
0xb8, 0x14, 0x85, 0xe8, 0x19, 0xa8, 0xd7, 0x69, 0x1c, 0x92, 0x2c, 0x88, 0x42, 0xbd, 0xc4, 0xd4,
0x55, 0xae, 0x70, 0x42, 0xf4, 0x0a, 0x60, 0x9c, 0x91, 0x61, 0x41, 0xc2, 0x60, 0x58, 0xe8, 0xe5,
0x43, 0xa9, 0x51, 0x3b, 0x3e, 0x30, 0xb9, 0x8f, 0xe6, 0xca, 0x47, 0xd3, 0x5f, 0xf9, 0x88, 0x55,
0x61, 0xdd, 0x2a, 0x10, 0x02, 0x39, 0x19, 0x4e, 0x89, 0x2e, 0x33, 0x4a, 0x76, 0x46, 0x87, 0x50,
0x0b, 0x49, 0x3e, 0xce, 0xa2, 0x59, 0x11, 0xa5, 0x89, 0xbe, 0xc7, 0xae, 0x36, 0x55, 0xa8, 0x0b,
0x4a, 0x3c, 0x1c, 0x91, 0x38, 0xd7, 0x95, 0xc3, 0x72, 0xa3, 0x76, 0xfc, 0xa5, 0xb9, 0x25, 0x5b,
0xa6, 0x88, 0xc9, 0xbc, 0x60, 0x10, 0x3b, 0x29, 0xb2, 0x25, 0x16, 0x78, 0x84, 0xa1, 0x46, 0x92,
0x45, 0x94, 0xa5, 0xc9, 0x94, 0x24, 0x85, 0x5e, 0x39, 0x94, 0x1a, 0xf5, 0x1d, 0xe9, 0xec, 0x7b,
0x1c, 0xde, 0x24, 0x41, 0x1d, 0x80, 0x69, 0x9a, 0x44, 0x45, 0x9a, 0x45, 0xc9, 0x44, 0xaf, 0x32,
0x0f, 0x3f, 0xdd, 0x4a, 0x79, 0xb9, 0x36, 0xc7, 0x1b, 0x50, 0x74, 0x06, 0x0a, 0xaf, 0x95, 0xae,
0xb2, 0x9c, 0x7e, 0xb6, 0x8b, 0x5f, 0x6d, 0x86, 0xc0, 0x02, 0x89, 0x9e, 0x03, 0x24, 0xa4, 0xf8,
0x29, 0xcd, 0x6e, 0x69, 0xe5, 0x80, 0xe5, 0x52, 0x15, 0x1a, 0x27, 0x44, 0x6d, 0x50, 0x6e, 0xc8,
0x30, 0x2e, 0x6e, 0xf4, 0x1a, 0x0b, 0xfd, 0xf3, 0x9d, 0x42, 0xef, 0x32, 0x08, 0x16, 0x50, 0x4a,
0x92, 0x17, 0xc3, 0x62, 0x9e, 0xeb, 0xfb, 0x1f, 0x41, 0xe2, 0x31, 0x08, 0x16, 0xd0, 0x83, 0x57,
0x50, 0xdb, 0x28, 0x10, 0xd2, 0xa0, 0x7c, 0x4b, 0x96, 0xa2, 0x03, 0xe9, 0x11, 0x3d, 0x81, 0xbd,
0xc5, 0x30, 0x9e, 0x13, 0xd1, 0x7e, 0x5c, 0x78, 0x5d, 0xfa, 0x5a, 0x32, 0x1c, 0xa8, 0x6d, 0x14,
0x03, 0x3d, 0x83, 0xa7, 0xb6, 0x7b, 0xe5, 0xe0, 0x9e, 0x7b, 0x69, 0xbb, 0x7e, 0x30, 0x70, 0xbd,
0xbe, 0xdd, 0x76, 0xce, 0x1d, 0xdb, 0xd2, 0x1e, 0xa1, 0x3a, 0x40, 0x1f, 0xf7, 0xac, 0x41, 0xdb,
0x77, 0x7a, 0xae, 0x26, 0xa1, 0xc7, 0xa0, 0xf6, 0xb1, 0xed, 0xf9, 0xad, 0xb3, 0x0b, 0x5b, 0x2b,
0x19, 0xdf, 0x81, 0xc2, 0x83, 0x43, 0x08, 0xea, 0x5d, 0xbb, 0x75, 0xe1, 0x77, 0x83, 0x81, 0xfb,
0xbd, 0xdb, 0xfb, 0xc1, 0xd5, 0x1e, 0x21, 0x15, 0xf6, 0x5a, 0x17, 0xce, 0x95, 0xad, 0x49, 0xa8,
0x0a, 0xb2, 0x65, 0xb7, 0x2c, 0xad, 0x84, 0xf6, 0xa1, 0x6a, 0xd9, 0x1d, 0xdc, 0xb2, 0x6c, 0x4b,
0x2b, 0x1b, 0x4b, 0x50, 0x78, 0x60, 0x94, 0xc0, 0xf3, 0x5b, 0xfe, 0xc0, 0xdb, 0x20, 0xd8, 0x87,
0x6a, 0x1b, 0xdb, 0x2d, 0xdf, 0x71, 0x3b, 0x9a, 0x84, 0x6a, 0x50, 0xc1, 0x03, 0xd7, 0xa5, 0x42,
0x89, 0x72, 0xdb, 0x18, 0xf7, 0xb0, 0x56, 0xa6, 0x56, 0x83, 0xbe, 0xc5, 0xad, 0x64, 0x2a, 0x79,
0x7e, 0xaf, 0xdf, 0xa7, 0xd2, 0x1e, 0xc5, 0x30, 0xc9, 0xb6, 0x34, 0x85, 0x5f, 0xb5, 0x30, 0x33,
0xac, 0x18, 0x57, 0x00, 0xf7, 0x8d, 0xb4, 0x9e, 0x2c, 0xe9, 0x9f, 0x27, 0xab, 0xf4, 0xd7, 0xc9,
0x42, 0x20, 0xc7, 0x51, 0x72, 0xcb, 0x86, 0x58, 0xc5, 0xec, 0x6c, 0xfc, 0x0c, 0x8f, 0x1f, 0xf4,
0x16, 0xd2, 0xa1, 0xb2, 0x20, 0x59, 0x4e, 0x29, 0x38, 0xfb, 0x4a, 0x44, 0x0e, 0xd4, 0x44, 0xa5,
0x83, 0x93, 0xe0, 0x94, 0x7d, 0x60, 0x87, 0xde, 0x17, 0x6b, 0xa8, 0xfb, 0x08, 0xab, 0xab, 0xa5,
0x74, 0x7a, 0xa6, 0x42, 0x45, 0x08, 0xc6, 0x1f, 0x12, 0x8b, 0x4c, 0x98, 0xa1, 0x73, 0x50, 0xf8,
0x0d, 0xfb, 0x7a, 0xed, 0xd8, 0xdc, 0x91, 0x5f, 0x1c, 0xb1, 0x40, 0x1f, 0xfc, 0x26, 0x81, 0xc2,
0x55, 0xc8, 0x5d, 0x4f, 0x1a, 0xa7, 0x3c, 0xdd, 0x4a, 0xc9, 0x4d, 0x05, 0x1d, 0xcf, 0x89, 0x47,
0x8a, 0x93, 0xe0, 0x74, 0x3d, 0x75, 0x16, 0xa8, 0x19, 0xc9, 0xd3, 0x79, 0x36, 0x26, 0xb9, 0xc8,
0xc2, 0x27, 0x5b, 0x29, 0xf1, 0xca, 0x1a, 0xdf, 0x03, 0x8d, 0x5f, 0x65, 0x90, 0xbb, 0x69, 0x5e,
0xfc, 0x6d, 0x2d, 0x9f, 0x03, 0x88, 0x17, 0xe3, 0x7e, 0x25, 0xab, 0x42, 0xe3, 0x84, 0xe8, 0x29,
0x54, 0xee, 0xd2, 0x84, 0xd0, 0x3b, 0x5e, 0x4b, 0x85, 0x8a, 0x4e, 0xf8, 0xd0, 0x35, 0xf9, 0x5f,
0xba, 0x86, 0x5e, 0x83, 0x9c, 0xa5, 0x31, 0x61, 0xcb, 0xb9, 0xfe, 0x01, 0x02, 0x1a, 0x82, 0x89,
0xd3, 0x98, 0x60, 0x86, 0x41, 0x6f, 0xd6, 0x3b, 0x47, 0x61, 0xe8, 0xc6, 0x87, 0xd1, 0xef, 0x2d,
0x9c, 0x37, 0x50, 0xcd, 0x49, 0xb6, 0x88, 0x68, 0x08, 0x15, 0xb6, 0x5f, 0xff, 0xbf, 0x95, 0xc3,
0xe3, 0xc6, 0x78, 0x8d, 0xa2, 0xef, 0x59, 0x3e, 0x1f, 0x25, 0xa4, 0xa0, 0x09, 0xaa, 0xf2, 0xf7,
0x8c, 0x2b, 0x9c, 0x10, 0x35, 0x40, 0x1b, 0xe6, 0x79, 0x34, 0x49, 0x82, 0xd9, 0x7c, 0x14, 0x47,
0xe3, 0x20, 0x9a, 0xb1, 0x0d, 0x5c, 0xc5, 0x75, 0xae, 0xef, 0x33, 0xb5, 0x33, 0x33, 0xbe, 0x02,
0x99, 0x06, 0x86, 0x34, 0xd8, 0xc7, 0xbd, 0x0b, 0x7b, 0x63, 0xd2, 0x6b, 0x50, 0xe9, 0x63, 0xe7,
0xb2, 0x85, 0xdf, 0xf2, 0x25, 0xe3, 0xd9, 0xed, 0x9e, 0x6b, 0x51, 0xf1, 0x3f, 0x58, 0x32, 0xbf,
0x94, 0xa0, 0x22, 0x62, 0x42, 0xdf, 0x82, 0x5c, 0x2c, 0x67, 0xbc, 0x37, 0xea, 0xc7, 0x2f, 0x76,
0xc9, 0x83, 0xe9, 0x2f, 0x67, 0x04, 0x33, 0xd8, 0xc6, 0x03, 0x50, 0xda, 0x61, 0x77, 0xaf, 0x08,
0x1e, 0xd6, 0xc3, 0x38, 0x03, 0x99, 0x52, 0xa2, 0x27, 0xa0, 0xf9, 0x6f, 0xfb, 0xf6, 0x7b, 0x2b,
0x17, 0x40, 0xb9, 0xec, 0xb9, 0x9d, 0x9e, 0xa5, 0x49, 0xeb, 0xb3, 0xc7, 0x63, 0x62, 0xe7, 0xf6,
0x79, 0x47, 0x2b, 0x1b, 0x47, 0x1f, 0x9d, 0x14, 0xe3, 0x1d, 0xa8, 0xeb, 0xe6, 0x44, 0x5f, 0x00,
0x5a, 0xb5, 0x67, 0x30, 0xcb, 0x48, 0xce, 0x4b, 0xcb, 0x27, 0x46, 0x5b, 0xdd, 0xf4, 0xd9, 0x85,
0xc3, 0xfe, 0x67, 0xc2, 0x28, 0xbf, 0x0d, 0xf2, 0xe8, 0x8e, 0x3f, 0x28, 0x65, 0x5c, 0xa5, 0x0a,
0x2f, 0xba, 0xa3, 0x6b, 0x72, 0x9f, 0x5d, 0xd2, 0x04, 0xdd, 0x0f, 0x10, 0x50, 0x1d, 0x0d, 0xd3,
0x09, 0xcf, 0x9c, 0x1f, 0x3b, 0x93, 0xa8, 0xb8, 0x99, 0x8f, 0xcc, 0x71, 0x3a, 0x6d, 0xf2, 0x8c,
0xbd, 0xe4, 0x3f, 0x5b, 0x93, 0xf4, 0xe5, 0x84, 0x24, 0xec, 0xaf, 0xa7, 0xb9, 0xe5, 0x2f, 0xec,
0x1b, 0x71, 0x1c, 0x29, 0xcc, 0xf4, 0xe4, 0xcf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x59, 0x37, 0x33,
0x3d, 0x1c, 0x0a, 0x00, 0x00,
}

2712
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/cluster_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

600
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/config/mongodb3_6.pb.go generated vendored Normal file
View File

@ -0,0 +1,600 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/mongodb/v1/config/mongodb3_6.proto
package mongodb // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/config"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import wrappers "github.com/golang/protobuf/ptypes/wrappers"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor int32
const (
MongodConfig3_6_Storage_WiredTiger_CollectionConfig_COMPRESSOR_UNSPECIFIED MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor = 0
// No compression.
MongodConfig3_6_Storage_WiredTiger_CollectionConfig_NONE MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor = 1
// The [Snappy](https://docs.mongodb.com/v3.6/reference/glossary/#term-snappy) compression.
MongodConfig3_6_Storage_WiredTiger_CollectionConfig_SNAPPY MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor = 2
// The [zlib](https://docs.mongodb.com/v3.6/reference/glossary/#term-zlib) compression.
MongodConfig3_6_Storage_WiredTiger_CollectionConfig_ZLIB MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor = 3
)
var MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor_name = map[int32]string{
0: "COMPRESSOR_UNSPECIFIED",
1: "NONE",
2: "SNAPPY",
3: "ZLIB",
}
var MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor_value = map[string]int32{
"COMPRESSOR_UNSPECIFIED": 0,
"NONE": 1,
"SNAPPY": 2,
"ZLIB": 3,
}
func (x MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor) String() string {
return proto.EnumName(MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor_name, int32(x))
}
func (MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_mongodb3_6_b6b4a9da8ede6ac2, []int{0, 0, 0, 1, 0}
}
type MongodConfig3_6_OperationProfiling_Mode int32
const (
MongodConfig3_6_OperationProfiling_MODE_UNSPECIFIED MongodConfig3_6_OperationProfiling_Mode = 0
// The profiler is off and does not collect any data.
MongodConfig3_6_OperationProfiling_OFF MongodConfig3_6_OperationProfiling_Mode = 1
// The profiler collects data for operations that take longer than the value of [slow_op_threshold].
MongodConfig3_6_OperationProfiling_SLOW_OP MongodConfig3_6_OperationProfiling_Mode = 2
// The profiler collects data for all operations.
MongodConfig3_6_OperationProfiling_ALL MongodConfig3_6_OperationProfiling_Mode = 3
)
var MongodConfig3_6_OperationProfiling_Mode_name = map[int32]string{
0: "MODE_UNSPECIFIED",
1: "OFF",
2: "SLOW_OP",
3: "ALL",
}
var MongodConfig3_6_OperationProfiling_Mode_value = map[string]int32{
"MODE_UNSPECIFIED": 0,
"OFF": 1,
"SLOW_OP": 2,
"ALL": 3,
}
func (x MongodConfig3_6_OperationProfiling_Mode) String() string {
return proto.EnumName(MongodConfig3_6_OperationProfiling_Mode_name, int32(x))
}
func (MongodConfig3_6_OperationProfiling_Mode) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_mongodb3_6_b6b4a9da8ede6ac2, []int{0, 1, 0}
}
// Configuration of a mongod daemon. Supported options are a limited subset of all
// options described in [MongoDB documentation](https://docs.mongodb.com/v3.6/reference/configuration-options/).
type MongodConfig3_6 struct {
// `storage` section of mongod configuration.
Storage *MongodConfig3_6_Storage `protobuf:"bytes,1,opt,name=storage,proto3" json:"storage,omitempty"`
// `operationProfiling` section of mongod configuration.
OperationProfiling *MongodConfig3_6_OperationProfiling `protobuf:"bytes,2,opt,name=operation_profiling,json=operationProfiling,proto3" json:"operation_profiling,omitempty"`
// `net` section of mongod configuration.
Net *MongodConfig3_6_Network `protobuf:"bytes,3,opt,name=net,proto3" json:"net,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *MongodConfig3_6) Reset() { *m = MongodConfig3_6{} }
func (m *MongodConfig3_6) String() string { return proto.CompactTextString(m) }
func (*MongodConfig3_6) ProtoMessage() {}
func (*MongodConfig3_6) Descriptor() ([]byte, []int) {
return fileDescriptor_mongodb3_6_b6b4a9da8ede6ac2, []int{0}
}
func (m *MongodConfig3_6) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MongodConfig3_6.Unmarshal(m, b)
}
func (m *MongodConfig3_6) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_MongodConfig3_6.Marshal(b, m, deterministic)
}
func (dst *MongodConfig3_6) XXX_Merge(src proto.Message) {
xxx_messageInfo_MongodConfig3_6.Merge(dst, src)
}
func (m *MongodConfig3_6) XXX_Size() int {
return xxx_messageInfo_MongodConfig3_6.Size(m)
}
func (m *MongodConfig3_6) XXX_DiscardUnknown() {
xxx_messageInfo_MongodConfig3_6.DiscardUnknown(m)
}
var xxx_messageInfo_MongodConfig3_6 proto.InternalMessageInfo
func (m *MongodConfig3_6) GetStorage() *MongodConfig3_6_Storage {
if m != nil {
return m.Storage
}
return nil
}
func (m *MongodConfig3_6) GetOperationProfiling() *MongodConfig3_6_OperationProfiling {
if m != nil {
return m.OperationProfiling
}
return nil
}
func (m *MongodConfig3_6) GetNet() *MongodConfig3_6_Network {
if m != nil {
return m.Net
}
return nil
}
type MongodConfig3_6_Storage struct {
// Configuration of the WiredTiger storage engine.
WiredTiger *MongodConfig3_6_Storage_WiredTiger `protobuf:"bytes,1,opt,name=wired_tiger,json=wiredTiger,proto3" json:"wired_tiger,omitempty"`
// Configuration of the MongoDB [journal](https://docs.mongodb.com/v3.6/reference/glossary/#term-journal).
Journal *MongodConfig3_6_Storage_Journal `protobuf:"bytes,2,opt,name=journal,proto3" json:"journal,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *MongodConfig3_6_Storage) Reset() { *m = MongodConfig3_6_Storage{} }
func (m *MongodConfig3_6_Storage) String() string { return proto.CompactTextString(m) }
func (*MongodConfig3_6_Storage) ProtoMessage() {}
func (*MongodConfig3_6_Storage) Descriptor() ([]byte, []int) {
return fileDescriptor_mongodb3_6_b6b4a9da8ede6ac2, []int{0, 0}
}
func (m *MongodConfig3_6_Storage) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MongodConfig3_6_Storage.Unmarshal(m, b)
}
func (m *MongodConfig3_6_Storage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_MongodConfig3_6_Storage.Marshal(b, m, deterministic)
}
func (dst *MongodConfig3_6_Storage) XXX_Merge(src proto.Message) {
xxx_messageInfo_MongodConfig3_6_Storage.Merge(dst, src)
}
func (m *MongodConfig3_6_Storage) XXX_Size() int {
return xxx_messageInfo_MongodConfig3_6_Storage.Size(m)
}
func (m *MongodConfig3_6_Storage) XXX_DiscardUnknown() {
xxx_messageInfo_MongodConfig3_6_Storage.DiscardUnknown(m)
}
var xxx_messageInfo_MongodConfig3_6_Storage proto.InternalMessageInfo
func (m *MongodConfig3_6_Storage) GetWiredTiger() *MongodConfig3_6_Storage_WiredTiger {
if m != nil {
return m.WiredTiger
}
return nil
}
func (m *MongodConfig3_6_Storage) GetJournal() *MongodConfig3_6_Storage_Journal {
if m != nil {
return m.Journal
}
return nil
}
// Configuration of WiredTiger storage engine.
type MongodConfig3_6_Storage_WiredTiger struct {
// Engine configuration for WiredTiger.
EngineConfig *MongodConfig3_6_Storage_WiredTiger_EngineConfig `protobuf:"bytes,1,opt,name=engine_config,json=engineConfig,proto3" json:"engine_config,omitempty"`
// Collection configuration for WiredTiger.
CollectionConfig *MongodConfig3_6_Storage_WiredTiger_CollectionConfig `protobuf:"bytes,2,opt,name=collection_config,json=collectionConfig,proto3" json:"collection_config,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *MongodConfig3_6_Storage_WiredTiger) Reset() { *m = MongodConfig3_6_Storage_WiredTiger{} }
func (m *MongodConfig3_6_Storage_WiredTiger) String() string { return proto.CompactTextString(m) }
func (*MongodConfig3_6_Storage_WiredTiger) ProtoMessage() {}
func (*MongodConfig3_6_Storage_WiredTiger) Descriptor() ([]byte, []int) {
return fileDescriptor_mongodb3_6_b6b4a9da8ede6ac2, []int{0, 0, 0}
}
func (m *MongodConfig3_6_Storage_WiredTiger) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger.Unmarshal(m, b)
}
func (m *MongodConfig3_6_Storage_WiredTiger) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger.Marshal(b, m, deterministic)
}
func (dst *MongodConfig3_6_Storage_WiredTiger) XXX_Merge(src proto.Message) {
xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger.Merge(dst, src)
}
func (m *MongodConfig3_6_Storage_WiredTiger) XXX_Size() int {
return xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger.Size(m)
}
func (m *MongodConfig3_6_Storage_WiredTiger) XXX_DiscardUnknown() {
xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger.DiscardUnknown(m)
}
var xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger proto.InternalMessageInfo
func (m *MongodConfig3_6_Storage_WiredTiger) GetEngineConfig() *MongodConfig3_6_Storage_WiredTiger_EngineConfig {
if m != nil {
return m.EngineConfig
}
return nil
}
func (m *MongodConfig3_6_Storage_WiredTiger) GetCollectionConfig() *MongodConfig3_6_Storage_WiredTiger_CollectionConfig {
if m != nil {
return m.CollectionConfig
}
return nil
}
type MongodConfig3_6_Storage_WiredTiger_EngineConfig struct {
// The maximum size of the internal cache that WiredTiger will use for all data.
CacheSizeGb *wrappers.DoubleValue `protobuf:"bytes,1,opt,name=cache_size_gb,json=cacheSizeGb,proto3" json:"cache_size_gb,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *MongodConfig3_6_Storage_WiredTiger_EngineConfig) Reset() {
*m = MongodConfig3_6_Storage_WiredTiger_EngineConfig{}
}
func (m *MongodConfig3_6_Storage_WiredTiger_EngineConfig) String() string {
return proto.CompactTextString(m)
}
func (*MongodConfig3_6_Storage_WiredTiger_EngineConfig) ProtoMessage() {}
func (*MongodConfig3_6_Storage_WiredTiger_EngineConfig) Descriptor() ([]byte, []int) {
return fileDescriptor_mongodb3_6_b6b4a9da8ede6ac2, []int{0, 0, 0, 0}
}
func (m *MongodConfig3_6_Storage_WiredTiger_EngineConfig) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger_EngineConfig.Unmarshal(m, b)
}
func (m *MongodConfig3_6_Storage_WiredTiger_EngineConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger_EngineConfig.Marshal(b, m, deterministic)
}
func (dst *MongodConfig3_6_Storage_WiredTiger_EngineConfig) XXX_Merge(src proto.Message) {
xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger_EngineConfig.Merge(dst, src)
}
func (m *MongodConfig3_6_Storage_WiredTiger_EngineConfig) XXX_Size() int {
return xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger_EngineConfig.Size(m)
}
func (m *MongodConfig3_6_Storage_WiredTiger_EngineConfig) XXX_DiscardUnknown() {
xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger_EngineConfig.DiscardUnknown(m)
}
var xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger_EngineConfig proto.InternalMessageInfo
func (m *MongodConfig3_6_Storage_WiredTiger_EngineConfig) GetCacheSizeGb() *wrappers.DoubleValue {
if m != nil {
return m.CacheSizeGb
}
return nil
}
type MongodConfig3_6_Storage_WiredTiger_CollectionConfig struct {
// Default type of compression to use for collection data.
BlockCompressor MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor `protobuf:"varint,1,opt,name=block_compressor,json=blockCompressor,proto3,enum=yandex.cloud.mdb.mongodb.v1.config.MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor" json:"block_compressor,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *MongodConfig3_6_Storage_WiredTiger_CollectionConfig) Reset() {
*m = MongodConfig3_6_Storage_WiredTiger_CollectionConfig{}
}
func (m *MongodConfig3_6_Storage_WiredTiger_CollectionConfig) String() string {
return proto.CompactTextString(m)
}
func (*MongodConfig3_6_Storage_WiredTiger_CollectionConfig) ProtoMessage() {}
func (*MongodConfig3_6_Storage_WiredTiger_CollectionConfig) Descriptor() ([]byte, []int) {
return fileDescriptor_mongodb3_6_b6b4a9da8ede6ac2, []int{0, 0, 0, 1}
}
func (m *MongodConfig3_6_Storage_WiredTiger_CollectionConfig) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger_CollectionConfig.Unmarshal(m, b)
}
func (m *MongodConfig3_6_Storage_WiredTiger_CollectionConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger_CollectionConfig.Marshal(b, m, deterministic)
}
func (dst *MongodConfig3_6_Storage_WiredTiger_CollectionConfig) XXX_Merge(src proto.Message) {
xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger_CollectionConfig.Merge(dst, src)
}
func (m *MongodConfig3_6_Storage_WiredTiger_CollectionConfig) XXX_Size() int {
return xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger_CollectionConfig.Size(m)
}
func (m *MongodConfig3_6_Storage_WiredTiger_CollectionConfig) XXX_DiscardUnknown() {
xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger_CollectionConfig.DiscardUnknown(m)
}
var xxx_messageInfo_MongodConfig3_6_Storage_WiredTiger_CollectionConfig proto.InternalMessageInfo
func (m *MongodConfig3_6_Storage_WiredTiger_CollectionConfig) GetBlockCompressor() MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor {
if m != nil {
return m.BlockCompressor
}
return MongodConfig3_6_Storage_WiredTiger_CollectionConfig_COMPRESSOR_UNSPECIFIED
}
type MongodConfig3_6_Storage_Journal struct {
// Whether the journal is enabled or disabled.
// Possible values:
// * true (default) — the journal is enabled.
// * false — the journal is disabled.
Enabled *wrappers.BoolValue `protobuf:"bytes,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
// Commit interval between journal operations, in milliseconds.
// Default: 100.
CommitInterval *wrappers.Int64Value `protobuf:"bytes,2,opt,name=commit_interval,json=commitInterval,proto3" json:"commit_interval,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *MongodConfig3_6_Storage_Journal) Reset() { *m = MongodConfig3_6_Storage_Journal{} }
func (m *MongodConfig3_6_Storage_Journal) String() string { return proto.CompactTextString(m) }
func (*MongodConfig3_6_Storage_Journal) ProtoMessage() {}
func (*MongodConfig3_6_Storage_Journal) Descriptor() ([]byte, []int) {
return fileDescriptor_mongodb3_6_b6b4a9da8ede6ac2, []int{0, 0, 1}
}
func (m *MongodConfig3_6_Storage_Journal) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MongodConfig3_6_Storage_Journal.Unmarshal(m, b)
}
func (m *MongodConfig3_6_Storage_Journal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_MongodConfig3_6_Storage_Journal.Marshal(b, m, deterministic)
}
func (dst *MongodConfig3_6_Storage_Journal) XXX_Merge(src proto.Message) {
xxx_messageInfo_MongodConfig3_6_Storage_Journal.Merge(dst, src)
}
func (m *MongodConfig3_6_Storage_Journal) XXX_Size() int {
return xxx_messageInfo_MongodConfig3_6_Storage_Journal.Size(m)
}
func (m *MongodConfig3_6_Storage_Journal) XXX_DiscardUnknown() {
xxx_messageInfo_MongodConfig3_6_Storage_Journal.DiscardUnknown(m)
}
var xxx_messageInfo_MongodConfig3_6_Storage_Journal proto.InternalMessageInfo
func (m *MongodConfig3_6_Storage_Journal) GetEnabled() *wrappers.BoolValue {
if m != nil {
return m.Enabled
}
return nil
}
func (m *MongodConfig3_6_Storage_Journal) GetCommitInterval() *wrappers.Int64Value {
if m != nil {
return m.CommitInterval
}
return nil
}
type MongodConfig3_6_OperationProfiling struct {
// Mode which specifies operations that should be profiled.
Mode MongodConfig3_6_OperationProfiling_Mode `protobuf:"varint,1,opt,name=mode,proto3,enum=yandex.cloud.mdb.mongodb.v1.config.MongodConfig3_6_OperationProfiling_Mode" json:"mode,omitempty"`
// The slow operation time threshold, in milliseconds. Operations that run
// for longer than this threshold are considered slow, and are processed by the profiler
// running in the SLOW_OP mode.
SlowOpThreshold *wrappers.Int64Value `protobuf:"bytes,2,opt,name=slow_op_threshold,json=slowOpThreshold,proto3" json:"slow_op_threshold,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *MongodConfig3_6_OperationProfiling) Reset() { *m = MongodConfig3_6_OperationProfiling{} }
func (m *MongodConfig3_6_OperationProfiling) String() string { return proto.CompactTextString(m) }
func (*MongodConfig3_6_OperationProfiling) ProtoMessage() {}
func (*MongodConfig3_6_OperationProfiling) Descriptor() ([]byte, []int) {
return fileDescriptor_mongodb3_6_b6b4a9da8ede6ac2, []int{0, 1}
}
func (m *MongodConfig3_6_OperationProfiling) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MongodConfig3_6_OperationProfiling.Unmarshal(m, b)
}
func (m *MongodConfig3_6_OperationProfiling) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_MongodConfig3_6_OperationProfiling.Marshal(b, m, deterministic)
}
func (dst *MongodConfig3_6_OperationProfiling) XXX_Merge(src proto.Message) {
xxx_messageInfo_MongodConfig3_6_OperationProfiling.Merge(dst, src)
}
func (m *MongodConfig3_6_OperationProfiling) XXX_Size() int {
return xxx_messageInfo_MongodConfig3_6_OperationProfiling.Size(m)
}
func (m *MongodConfig3_6_OperationProfiling) XXX_DiscardUnknown() {
xxx_messageInfo_MongodConfig3_6_OperationProfiling.DiscardUnknown(m)
}
var xxx_messageInfo_MongodConfig3_6_OperationProfiling proto.InternalMessageInfo
func (m *MongodConfig3_6_OperationProfiling) GetMode() MongodConfig3_6_OperationProfiling_Mode {
if m != nil {
return m.Mode
}
return MongodConfig3_6_OperationProfiling_MODE_UNSPECIFIED
}
func (m *MongodConfig3_6_OperationProfiling) GetSlowOpThreshold() *wrappers.Int64Value {
if m != nil {
return m.SlowOpThreshold
}
return nil
}
type MongodConfig3_6_Network struct {
// The maximum number of simultaneous connections that mongod will accept.
MaxIncomingConnections *wrappers.Int64Value `protobuf:"bytes,1,opt,name=max_incoming_connections,json=maxIncomingConnections,proto3" json:"max_incoming_connections,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *MongodConfig3_6_Network) Reset() { *m = MongodConfig3_6_Network{} }
func (m *MongodConfig3_6_Network) String() string { return proto.CompactTextString(m) }
func (*MongodConfig3_6_Network) ProtoMessage() {}
func (*MongodConfig3_6_Network) Descriptor() ([]byte, []int) {
return fileDescriptor_mongodb3_6_b6b4a9da8ede6ac2, []int{0, 2}
}
func (m *MongodConfig3_6_Network) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MongodConfig3_6_Network.Unmarshal(m, b)
}
func (m *MongodConfig3_6_Network) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_MongodConfig3_6_Network.Marshal(b, m, deterministic)
}
func (dst *MongodConfig3_6_Network) XXX_Merge(src proto.Message) {
xxx_messageInfo_MongodConfig3_6_Network.Merge(dst, src)
}
func (m *MongodConfig3_6_Network) XXX_Size() int {
return xxx_messageInfo_MongodConfig3_6_Network.Size(m)
}
func (m *MongodConfig3_6_Network) XXX_DiscardUnknown() {
xxx_messageInfo_MongodConfig3_6_Network.DiscardUnknown(m)
}
var xxx_messageInfo_MongodConfig3_6_Network proto.InternalMessageInfo
func (m *MongodConfig3_6_Network) GetMaxIncomingConnections() *wrappers.Int64Value {
if m != nil {
return m.MaxIncomingConnections
}
return nil
}
type MongodConfigSet3_6 struct {
// Effective settings for a MongoDB 3.6 cluster (a combination of settings defined
// in [user_config] and [default_config]).
EffectiveConfig *MongodConfig3_6 `protobuf:"bytes,1,opt,name=effective_config,json=effectiveConfig,proto3" json:"effective_config,omitempty"`
// User-defined settings for a MongoDB 3.6 cluster.
UserConfig *MongodConfig3_6 `protobuf:"bytes,2,opt,name=user_config,json=userConfig,proto3" json:"user_config,omitempty"`
// Default configuration for a MongoDB 3.6 cluster.
DefaultConfig *MongodConfig3_6 `protobuf:"bytes,3,opt,name=default_config,json=defaultConfig,proto3" json:"default_config,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *MongodConfigSet3_6) Reset() { *m = MongodConfigSet3_6{} }
func (m *MongodConfigSet3_6) String() string { return proto.CompactTextString(m) }
func (*MongodConfigSet3_6) ProtoMessage() {}
func (*MongodConfigSet3_6) Descriptor() ([]byte, []int) {
return fileDescriptor_mongodb3_6_b6b4a9da8ede6ac2, []int{1}
}
func (m *MongodConfigSet3_6) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_MongodConfigSet3_6.Unmarshal(m, b)
}
func (m *MongodConfigSet3_6) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_MongodConfigSet3_6.Marshal(b, m, deterministic)
}
func (dst *MongodConfigSet3_6) XXX_Merge(src proto.Message) {
xxx_messageInfo_MongodConfigSet3_6.Merge(dst, src)
}
func (m *MongodConfigSet3_6) XXX_Size() int {
return xxx_messageInfo_MongodConfigSet3_6.Size(m)
}
func (m *MongodConfigSet3_6) XXX_DiscardUnknown() {
xxx_messageInfo_MongodConfigSet3_6.DiscardUnknown(m)
}
var xxx_messageInfo_MongodConfigSet3_6 proto.InternalMessageInfo
func (m *MongodConfigSet3_6) GetEffectiveConfig() *MongodConfig3_6 {
if m != nil {
return m.EffectiveConfig
}
return nil
}
func (m *MongodConfigSet3_6) GetUserConfig() *MongodConfig3_6 {
if m != nil {
return m.UserConfig
}
return nil
}
func (m *MongodConfigSet3_6) GetDefaultConfig() *MongodConfig3_6 {
if m != nil {
return m.DefaultConfig
}
return nil
}
func init() {
proto.RegisterType((*MongodConfig3_6)(nil), "yandex.cloud.mdb.mongodb.v1.config.MongodConfig3_6")
proto.RegisterType((*MongodConfig3_6_Storage)(nil), "yandex.cloud.mdb.mongodb.v1.config.MongodConfig3_6.Storage")
proto.RegisterType((*MongodConfig3_6_Storage_WiredTiger)(nil), "yandex.cloud.mdb.mongodb.v1.config.MongodConfig3_6.Storage.WiredTiger")
proto.RegisterType((*MongodConfig3_6_Storage_WiredTiger_EngineConfig)(nil), "yandex.cloud.mdb.mongodb.v1.config.MongodConfig3_6.Storage.WiredTiger.EngineConfig")
proto.RegisterType((*MongodConfig3_6_Storage_WiredTiger_CollectionConfig)(nil), "yandex.cloud.mdb.mongodb.v1.config.MongodConfig3_6.Storage.WiredTiger.CollectionConfig")
proto.RegisterType((*MongodConfig3_6_Storage_Journal)(nil), "yandex.cloud.mdb.mongodb.v1.config.MongodConfig3_6.Storage.Journal")
proto.RegisterType((*MongodConfig3_6_OperationProfiling)(nil), "yandex.cloud.mdb.mongodb.v1.config.MongodConfig3_6.OperationProfiling")
proto.RegisterType((*MongodConfig3_6_Network)(nil), "yandex.cloud.mdb.mongodb.v1.config.MongodConfig3_6.Network")
proto.RegisterType((*MongodConfigSet3_6)(nil), "yandex.cloud.mdb.mongodb.v1.config.MongodConfigSet3_6")
proto.RegisterEnum("yandex.cloud.mdb.mongodb.v1.config.MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor", MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor_name, MongodConfig3_6_Storage_WiredTiger_CollectionConfig_Compressor_value)
proto.RegisterEnum("yandex.cloud.mdb.mongodb.v1.config.MongodConfig3_6_OperationProfiling_Mode", MongodConfig3_6_OperationProfiling_Mode_name, MongodConfig3_6_OperationProfiling_Mode_value)
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/mongodb/v1/config/mongodb3_6.proto", fileDescriptor_mongodb3_6_b6b4a9da8ede6ac2)
}
var fileDescriptor_mongodb3_6_b6b4a9da8ede6ac2 = []byte{
// 832 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x96, 0xdd, 0x6e, 0xe3, 0x44,
0x14, 0xc7, 0x71, 0x52, 0xea, 0xe5, 0xa4, 0x6d, 0xbc, 0x03, 0x5a, 0x55, 0xe6, 0x43, 0x28, 0x57,
0xdc, 0x74, 0x5c, 0x6f, 0x4a, 0x85, 0x54, 0x09, 0xb1, 0x4d, 0x13, 0x08, 0x34, 0xb1, 0x65, 0x77,
0xa9, 0xa8, 0x04, 0x96, 0x3f, 0x26, 0xae, 0x59, 0x7b, 0xc6, 0xf2, 0x47, 0x52, 0xf6, 0x16, 0x6e,
0x91, 0x78, 0x0a, 0xde, 0x80, 0x67, 0xe8, 0x1d, 0x8f, 0xc0, 0x13, 0xf0, 0x04, 0xbd, 0x42, 0xf6,
0x8c, 0xd3, 0x6e, 0x2a, 0xb1, 0x28, 0x5b, 0xee, 0xe2, 0x93, 0xf9, 0xff, 0xfe, 0x73, 0xce, 0x9c,
0x39, 0x36, 0xf4, 0x7f, 0x72, 0x69, 0x40, 0xae, 0x34, 0x3f, 0x66, 0x65, 0xa0, 0x25, 0x81, 0xa7,
0x25, 0x8c, 0x86, 0x2c, 0xf0, 0xb4, 0xb9, 0xae, 0xf9, 0x8c, 0xce, 0xa2, 0xb0, 0x89, 0xf4, 0x9d,
0x43, 0x9c, 0x66, 0xac, 0x60, 0xa8, 0xc7, 0x45, 0xb8, 0x16, 0xe1, 0x24, 0xf0, 0xb0, 0x58, 0x82,
0xe7, 0x3a, 0xe6, 0x22, 0xf5, 0xa3, 0x90, 0xb1, 0x30, 0x26, 0x5a, 0xad, 0xf0, 0xca, 0x99, 0xb6,
0xc8, 0xdc, 0x34, 0x25, 0x59, 0xce, 0x19, 0xea, 0x87, 0xaf, 0x18, 0xcf, 0xdd, 0x38, 0x0a, 0xdc,
0x22, 0x62, 0x94, 0xff, 0xdd, 0xfb, 0x6b, 0x0b, 0xba, 0x93, 0x1a, 0x3a, 0xa8, 0x79, 0x7d, 0xe7,
0x10, 0x3d, 0x07, 0x39, 0x2f, 0x58, 0xe6, 0x86, 0x64, 0x57, 0xfa, 0x58, 0xfa, 0xa4, 0xf3, 0xf4,
0x08, 0xbf, 0x7e, 0x23, 0x78, 0x85, 0x82, 0x6d, 0x8e, 0xb0, 0x1a, 0x16, 0x5a, 0xc0, 0xbb, 0x2c,
0x25, 0x59, 0xed, 0xee, 0xa4, 0x19, 0x9b, 0x45, 0x71, 0x44, 0xc3, 0xdd, 0x56, 0x6d, 0x31, 0x5a,
0xc7, 0xc2, 0x68, 0x70, 0x66, 0x43, 0xb3, 0x10, 0xbb, 0x17, 0x43, 0x13, 0x68, 0x53, 0x52, 0xec,
0xb6, 0xd7, 0xcf, 0x65, 0x4a, 0x8a, 0x05, 0xcb, 0x5e, 0x58, 0x15, 0x47, 0xfd, 0x43, 0x06, 0x59,
0x24, 0x87, 0x42, 0xe8, 0x2c, 0xa2, 0x8c, 0x04, 0x4e, 0x11, 0x85, 0x24, 0x13, 0xe5, 0x1a, 0xbd,
0x41, 0xb9, 0xf0, 0x79, 0x85, 0x3b, 0xab, 0x68, 0x16, 0x2c, 0x96, 0xbf, 0xd1, 0xf7, 0x20, 0xff,
0xc8, 0xca, 0x8c, 0xba, 0xb1, 0x28, 0xd8, 0xe0, 0x4d, 0x4c, 0xbe, 0xe6, 0x28, 0xab, 0x61, 0xaa,
0x7f, 0x6e, 0x00, 0xdc, 0x3a, 0xa3, 0x2b, 0xd8, 0x26, 0x34, 0x8c, 0x28, 0x71, 0x38, 0x48, 0x24,
0x66, 0x3f, 0x4c, 0x62, 0x78, 0x58, 0xb3, 0xf9, 0x12, 0x6b, 0x8b, 0xdc, 0x79, 0x42, 0xbf, 0x48,
0xf0, 0xd8, 0x67, 0x71, 0x4c, 0xfc, 0xba, 0x4d, 0x84, 0x3d, 0x4f, 0xf9, 0xfc, 0x81, 0xec, 0x07,
0x4b, 0xbe, 0xd8, 0x82, 0xe2, 0xaf, 0x44, 0x54, 0x13, 0xb6, 0xee, 0x6e, 0x12, 0x7d, 0x01, 0xdb,
0xbe, 0xeb, 0x5f, 0x12, 0x27, 0x8f, 0x5e, 0x12, 0x27, 0xf4, 0x44, 0x41, 0x3e, 0xc0, 0xfc, 0xf6,
0xe1, 0xe6, 0xf6, 0xe1, 0x13, 0x56, 0x7a, 0x31, 0xf9, 0xd6, 0x8d, 0x4b, 0x62, 0x75, 0x6a, 0x89,
0x1d, 0xbd, 0x24, 0x5f, 0x7a, 0xea, 0xdf, 0x12, 0x28, 0xab, 0xc6, 0xe8, 0x57, 0x09, 0x14, 0x2f,
0x66, 0xfe, 0x0b, 0xc7, 0x67, 0x49, 0x9a, 0x91, 0x3c, 0x67, 0xbc, 0x89, 0x76, 0x9e, 0x7a, 0xff,
0x53, 0xb2, 0x78, 0xb0, 0x74, 0xb2, 0xba, 0xb5, 0xf7, 0x6d, 0xa0, 0xf7, 0x15, 0xc0, 0xed, 0x13,
0x52, 0xe1, 0xc9, 0xc0, 0x98, 0x98, 0xd6, 0xd0, 0xb6, 0x0d, 0xcb, 0x79, 0x3e, 0xb5, 0xcd, 0xe1,
0x60, 0x3c, 0x1a, 0x0f, 0x4f, 0x94, 0xb7, 0xd0, 0x23, 0xd8, 0x98, 0x1a, 0xd3, 0xa1, 0x22, 0x21,
0x80, 0x4d, 0x7b, 0xfa, 0xcc, 0x34, 0xbf, 0x53, 0x5a, 0x55, 0xf4, 0xe2, 0x74, 0x7c, 0xac, 0xb4,
0xd5, 0xdf, 0x24, 0x90, 0x45, 0x97, 0xa1, 0x03, 0x90, 0x09, 0x75, 0xbd, 0x98, 0x04, 0xa2, 0x6c,
0xea, 0xbd, 0xb2, 0x1d, 0x33, 0x16, 0xf3, 0xa2, 0x35, 0x4b, 0x91, 0x01, 0x5d, 0x9f, 0x25, 0x49,
0x54, 0x38, 0x11, 0x2d, 0x48, 0x36, 0x5f, 0x76, 0xfe, 0xfb, 0xf7, 0xd4, 0x63, 0x5a, 0x1c, 0x1e,
0xd4, 0xf2, 0xe3, 0x77, 0x6e, 0xae, 0xf5, 0xb7, 0xf5, 0xbd, 0x4f, 0xf7, 0xf7, 0xad, 0x1d, 0x2e,
0x1f, 0x0b, 0xb5, 0xfa, 0x73, 0x0b, 0xd0, 0xfd, 0x89, 0x81, 0x1c, 0xd8, 0x48, 0x58, 0x40, 0x44,
0xd9, 0xbf, 0x79, 0x98, 0x39, 0x84, 0x27, 0x2c, 0x20, 0x56, 0x0d, 0x46, 0x06, 0x3c, 0xce, 0x63,
0xb6, 0x70, 0x58, 0xea, 0x14, 0x97, 0x19, 0xc9, 0x2f, 0x59, 0x1c, 0xfc, 0x97, 0x54, 0x36, 0x6f,
0xae, 0xf5, 0xd6, 0xe7, 0xfb, 0x56, 0xb7, 0x52, 0x1b, 0xe9, 0x59, 0xa3, 0xed, 0x1d, 0xc1, 0x46,
0x85, 0x47, 0xef, 0x81, 0x32, 0x31, 0x4e, 0x86, 0x2b, 0x27, 0x23, 0x43, 0xdb, 0x18, 0x8d, 0x14,
0x09, 0x75, 0x40, 0xb6, 0x4f, 0x8d, 0x73, 0xc7, 0x30, 0x95, 0x56, 0x15, 0x7d, 0x76, 0x7a, 0xaa,
0xb4, 0x55, 0x0a, 0xb2, 0x98, 0x66, 0xc8, 0x87, 0xdd, 0xc4, 0xbd, 0x72, 0x22, 0xea, 0xb3, 0x24,
0xa2, 0x61, 0x75, 0xd9, 0x28, 0x6f, 0x95, 0x5c, 0x1c, 0xd4, 0xbf, 0xee, 0x6f, 0xeb, 0xe6, 0x5a,
0x7f, 0xa4, 0xef, 0xef, 0xe9, 0x87, 0xfd, 0xcf, 0x0e, 0xac, 0x27, 0x89, 0x7b, 0x35, 0x16, 0xa4,
0xc1, 0x2d, 0xa8, 0xf7, 0x7b, 0x0b, 0xd0, 0xdd, 0x7a, 0xd9, 0xa4, 0xa8, 0xde, 0x31, 0x3f, 0x80,
0x42, 0x66, 0xb3, 0x6a, 0xd1, 0x7c, 0x65, 0xc8, 0xf4, 0xd7, 0x38, 0x01, 0xab, 0xbb, 0x84, 0x89,
0x9b, 0x75, 0x06, 0x9d, 0x32, 0x27, 0xd9, 0xab, 0x03, 0x64, 0x2d, 0x34, 0x54, 0x1c, 0x41, 0xbd,
0x80, 0x9d, 0x80, 0xcc, 0xdc, 0x32, 0x2e, 0x1a, 0x70, 0x7b, 0x7d, 0xf0, 0xb6, 0x40, 0xf1, 0xc8,
0xb1, 0x79, 0x31, 0x0d, 0xa3, 0xe2, 0xb2, 0xf4, 0xb0, 0xcf, 0x12, 0x8d, 0xf3, 0xf6, 0xf8, 0x5b,
0x3b, 0x64, 0x7b, 0x21, 0xa1, 0xf5, 0x19, 0x68, 0xaf, 0xff, 0x8e, 0x38, 0x12, 0x11, 0x6f, 0xb3,
0x56, 0xf4, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xbe, 0xb4, 0xd3, 0xe3, 0x7c, 0x08, 0x00, 0x00,
}

137
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/database.pb.go generated vendored Normal file
View File

@ -0,0 +1,137 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/mongodb/v1/database.proto
package mongodb // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// A MongoDB Database resource. For more information, see the
// [Developer's Guide](/docs/managed-mongodb/concepts).
type Database struct {
// Name of the database.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// ID of the MongoDB cluster that the database belongs to.
ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Database) Reset() { *m = Database{} }
func (m *Database) String() string { return proto.CompactTextString(m) }
func (*Database) ProtoMessage() {}
func (*Database) Descriptor() ([]byte, []int) {
return fileDescriptor_database_4ea16d4da2c264aa, []int{0}
}
func (m *Database) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Database.Unmarshal(m, b)
}
func (m *Database) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Database.Marshal(b, m, deterministic)
}
func (dst *Database) XXX_Merge(src proto.Message) {
xxx_messageInfo_Database.Merge(dst, src)
}
func (m *Database) XXX_Size() int {
return xxx_messageInfo_Database.Size(m)
}
func (m *Database) XXX_DiscardUnknown() {
xxx_messageInfo_Database.DiscardUnknown(m)
}
var xxx_messageInfo_Database proto.InternalMessageInfo
func (m *Database) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Database) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
type DatabaseSpec struct {
// Name of the MongoDB database. 1-63 characters long.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DatabaseSpec) Reset() { *m = DatabaseSpec{} }
func (m *DatabaseSpec) String() string { return proto.CompactTextString(m) }
func (*DatabaseSpec) ProtoMessage() {}
func (*DatabaseSpec) Descriptor() ([]byte, []int) {
return fileDescriptor_database_4ea16d4da2c264aa, []int{1}
}
func (m *DatabaseSpec) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DatabaseSpec.Unmarshal(m, b)
}
func (m *DatabaseSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DatabaseSpec.Marshal(b, m, deterministic)
}
func (dst *DatabaseSpec) XXX_Merge(src proto.Message) {
xxx_messageInfo_DatabaseSpec.Merge(dst, src)
}
func (m *DatabaseSpec) XXX_Size() int {
return xxx_messageInfo_DatabaseSpec.Size(m)
}
func (m *DatabaseSpec) XXX_DiscardUnknown() {
xxx_messageInfo_DatabaseSpec.DiscardUnknown(m)
}
var xxx_messageInfo_DatabaseSpec proto.InternalMessageInfo
func (m *DatabaseSpec) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func init() {
proto.RegisterType((*Database)(nil), "yandex.cloud.mdb.mongodb.v1.Database")
proto.RegisterType((*DatabaseSpec)(nil), "yandex.cloud.mdb.mongodb.v1.DatabaseSpec")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/mongodb/v1/database.proto", fileDescriptor_database_4ea16d4da2c264aa)
}
var fileDescriptor_database_4ea16d4da2c264aa = []byte{
// 237 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xaa, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0xcf, 0x4d, 0x49, 0xd2, 0xcf, 0xcd, 0xcf,
0x4b, 0xcf, 0x4f, 0x49, 0xd2, 0x2f, 0x33, 0xd4, 0x4f, 0x49, 0x2c, 0x49, 0x4c, 0x4a, 0x2c, 0x4e,
0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x92, 0x86, 0xa8, 0xd5, 0x03, 0xab, 0xd5, 0xcb, 0x4d,
0x49, 0xd2, 0x83, 0xaa, 0xd5, 0x2b, 0x33, 0x94, 0x92, 0x45, 0x31, 0xa8, 0x2c, 0x31, 0x27, 0x33,
0x25, 0xb1, 0x24, 0x33, 0x3f, 0x0f, 0xa2, 0x57, 0xc9, 0x96, 0x8b, 0xc3, 0x05, 0x6a, 0x9a, 0x90,
0x10, 0x17, 0x4b, 0x5e, 0x62, 0x6e, 0xaa, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x67, 0x10, 0x98, 0x2d,
0x24, 0xcb, 0xc5, 0x95, 0x9c, 0x53, 0x5a, 0x5c, 0x92, 0x5a, 0x14, 0x9f, 0x99, 0x22, 0xc1, 0x04,
0x96, 0xe1, 0x84, 0x8a, 0x78, 0xa6, 0x28, 0x39, 0x71, 0xf1, 0xc0, 0xb4, 0x07, 0x17, 0xa4, 0x26,
0x0b, 0x19, 0x21, 0x1b, 0xe1, 0x24, 0xf7, 0xe2, 0xb8, 0x21, 0xe3, 0xa7, 0xe3, 0x86, 0x7c, 0xd1,
0x89, 0xba, 0x55, 0x8e, 0xba, 0x51, 0x06, 0xba, 0x96, 0xf1, 0xba, 0xb1, 0x5a, 0x5d, 0x27, 0x0c,
0x59, 0x6c, 0x6c, 0xcd, 0x8c, 0x21, 0x56, 0x38, 0x79, 0x46, 0xb9, 0xa7, 0x67, 0x96, 0x64, 0x94,
0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x43, 0x9c, 0xab, 0x0b, 0x71, 0x6e, 0x7a, 0xbe, 0x6e, 0x7a,
0x6a, 0x1e, 0xd8, 0xa5, 0xfa, 0x78, 0x02, 0xc4, 0x1a, 0xca, 0x4c, 0x62, 0x03, 0x2b, 0x35, 0x06,
0x04, 0x00, 0x00, 0xff, 0xff, 0x89, 0x35, 0xe4, 0x5f, 0x3e, 0x01, 0x00, 0x00,
}

627
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/database_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,627 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/mongodb/v1/database_service.proto
package mongodb // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/api"
import operation "github.com/yandex-cloud/go-genproto/yandex/cloud/operation"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetDatabaseRequest struct {
// ID of the MongoDB cluster that the database belongs to.
// To get the cluster ID use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the MongoDB Database resource to return.
// To get the name of the database use a [DatabaseService.List] request.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetDatabaseRequest) Reset() { *m = GetDatabaseRequest{} }
func (m *GetDatabaseRequest) String() string { return proto.CompactTextString(m) }
func (*GetDatabaseRequest) ProtoMessage() {}
func (*GetDatabaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_9ac08729ed097c0a, []int{0}
}
func (m *GetDatabaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetDatabaseRequest.Unmarshal(m, b)
}
func (m *GetDatabaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetDatabaseRequest.Marshal(b, m, deterministic)
}
func (dst *GetDatabaseRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetDatabaseRequest.Merge(dst, src)
}
func (m *GetDatabaseRequest) XXX_Size() int {
return xxx_messageInfo_GetDatabaseRequest.Size(m)
}
func (m *GetDatabaseRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetDatabaseRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetDatabaseRequest proto.InternalMessageInfo
func (m *GetDatabaseRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *GetDatabaseRequest) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type ListDatabasesRequest struct {
// ID of the MongoDB cluster to list databases in.
// To get the cluster ID, use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListDatabasesResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListDatabasesRequest) Reset() { *m = ListDatabasesRequest{} }
func (m *ListDatabasesRequest) String() string { return proto.CompactTextString(m) }
func (*ListDatabasesRequest) ProtoMessage() {}
func (*ListDatabasesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_9ac08729ed097c0a, []int{1}
}
func (m *ListDatabasesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListDatabasesRequest.Unmarshal(m, b)
}
func (m *ListDatabasesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListDatabasesRequest.Marshal(b, m, deterministic)
}
func (dst *ListDatabasesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListDatabasesRequest.Merge(dst, src)
}
func (m *ListDatabasesRequest) XXX_Size() int {
return xxx_messageInfo_ListDatabasesRequest.Size(m)
}
func (m *ListDatabasesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListDatabasesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListDatabasesRequest proto.InternalMessageInfo
func (m *ListDatabasesRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *ListDatabasesRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListDatabasesRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListDatabasesResponse struct {
// List of MongoDB Database resources.
Databases []*Database `protobuf:"bytes,1,rep,name=databases,proto3" json:"databases,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListDatabasesRequest.page_size], use the [next_page_token] as the value
// for the [ListDatabasesRequest.page_token] parameter in the next list request. Each subsequent
// list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListDatabasesResponse) Reset() { *m = ListDatabasesResponse{} }
func (m *ListDatabasesResponse) String() string { return proto.CompactTextString(m) }
func (*ListDatabasesResponse) ProtoMessage() {}
func (*ListDatabasesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_9ac08729ed097c0a, []int{2}
}
func (m *ListDatabasesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListDatabasesResponse.Unmarshal(m, b)
}
func (m *ListDatabasesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListDatabasesResponse.Marshal(b, m, deterministic)
}
func (dst *ListDatabasesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListDatabasesResponse.Merge(dst, src)
}
func (m *ListDatabasesResponse) XXX_Size() int {
return xxx_messageInfo_ListDatabasesResponse.Size(m)
}
func (m *ListDatabasesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListDatabasesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListDatabasesResponse proto.InternalMessageInfo
func (m *ListDatabasesResponse) GetDatabases() []*Database {
if m != nil {
return m.Databases
}
return nil
}
func (m *ListDatabasesResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type CreateDatabaseRequest struct {
// ID of the MongoDB cluster to create a database in.
// To get the cluster ID, use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Configuration of the database to create.
DatabaseSpec *DatabaseSpec `protobuf:"bytes,2,opt,name=database_spec,json=databaseSpec,proto3" json:"database_spec,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateDatabaseRequest) Reset() { *m = CreateDatabaseRequest{} }
func (m *CreateDatabaseRequest) String() string { return proto.CompactTextString(m) }
func (*CreateDatabaseRequest) ProtoMessage() {}
func (*CreateDatabaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_9ac08729ed097c0a, []int{3}
}
func (m *CreateDatabaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateDatabaseRequest.Unmarshal(m, b)
}
func (m *CreateDatabaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateDatabaseRequest.Marshal(b, m, deterministic)
}
func (dst *CreateDatabaseRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateDatabaseRequest.Merge(dst, src)
}
func (m *CreateDatabaseRequest) XXX_Size() int {
return xxx_messageInfo_CreateDatabaseRequest.Size(m)
}
func (m *CreateDatabaseRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateDatabaseRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateDatabaseRequest proto.InternalMessageInfo
func (m *CreateDatabaseRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *CreateDatabaseRequest) GetDatabaseSpec() *DatabaseSpec {
if m != nil {
return m.DatabaseSpec
}
return nil
}
type CreateDatabaseMetadata struct {
// ID of the MongoDB cluster where a database is being created.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the MongoDB database that is being created.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateDatabaseMetadata) Reset() { *m = CreateDatabaseMetadata{} }
func (m *CreateDatabaseMetadata) String() string { return proto.CompactTextString(m) }
func (*CreateDatabaseMetadata) ProtoMessage() {}
func (*CreateDatabaseMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_9ac08729ed097c0a, []int{4}
}
func (m *CreateDatabaseMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateDatabaseMetadata.Unmarshal(m, b)
}
func (m *CreateDatabaseMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateDatabaseMetadata.Marshal(b, m, deterministic)
}
func (dst *CreateDatabaseMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateDatabaseMetadata.Merge(dst, src)
}
func (m *CreateDatabaseMetadata) XXX_Size() int {
return xxx_messageInfo_CreateDatabaseMetadata.Size(m)
}
func (m *CreateDatabaseMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_CreateDatabaseMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_CreateDatabaseMetadata proto.InternalMessageInfo
func (m *CreateDatabaseMetadata) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *CreateDatabaseMetadata) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type DeleteDatabaseRequest struct {
// ID of the MongoDB cluster to delete a database in.
// To get the cluster ID, use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the database to delete.
// To get the name of the database, use a [DatabaseService.List] request.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteDatabaseRequest) Reset() { *m = DeleteDatabaseRequest{} }
func (m *DeleteDatabaseRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteDatabaseRequest) ProtoMessage() {}
func (*DeleteDatabaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_9ac08729ed097c0a, []int{5}
}
func (m *DeleteDatabaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteDatabaseRequest.Unmarshal(m, b)
}
func (m *DeleteDatabaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteDatabaseRequest.Marshal(b, m, deterministic)
}
func (dst *DeleteDatabaseRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteDatabaseRequest.Merge(dst, src)
}
func (m *DeleteDatabaseRequest) XXX_Size() int {
return xxx_messageInfo_DeleteDatabaseRequest.Size(m)
}
func (m *DeleteDatabaseRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteDatabaseRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteDatabaseRequest proto.InternalMessageInfo
func (m *DeleteDatabaseRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *DeleteDatabaseRequest) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type DeleteDatabaseMetadata struct {
// ID of the MongoDB cluster where a database is being deleted.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the MongoDB database that is being deleted.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteDatabaseMetadata) Reset() { *m = DeleteDatabaseMetadata{} }
func (m *DeleteDatabaseMetadata) String() string { return proto.CompactTextString(m) }
func (*DeleteDatabaseMetadata) ProtoMessage() {}
func (*DeleteDatabaseMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_9ac08729ed097c0a, []int{6}
}
func (m *DeleteDatabaseMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteDatabaseMetadata.Unmarshal(m, b)
}
func (m *DeleteDatabaseMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteDatabaseMetadata.Marshal(b, m, deterministic)
}
func (dst *DeleteDatabaseMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteDatabaseMetadata.Merge(dst, src)
}
func (m *DeleteDatabaseMetadata) XXX_Size() int {
return xxx_messageInfo_DeleteDatabaseMetadata.Size(m)
}
func (m *DeleteDatabaseMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteDatabaseMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteDatabaseMetadata proto.InternalMessageInfo
func (m *DeleteDatabaseMetadata) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *DeleteDatabaseMetadata) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
func init() {
proto.RegisterType((*GetDatabaseRequest)(nil), "yandex.cloud.mdb.mongodb.v1.GetDatabaseRequest")
proto.RegisterType((*ListDatabasesRequest)(nil), "yandex.cloud.mdb.mongodb.v1.ListDatabasesRequest")
proto.RegisterType((*ListDatabasesResponse)(nil), "yandex.cloud.mdb.mongodb.v1.ListDatabasesResponse")
proto.RegisterType((*CreateDatabaseRequest)(nil), "yandex.cloud.mdb.mongodb.v1.CreateDatabaseRequest")
proto.RegisterType((*CreateDatabaseMetadata)(nil), "yandex.cloud.mdb.mongodb.v1.CreateDatabaseMetadata")
proto.RegisterType((*DeleteDatabaseRequest)(nil), "yandex.cloud.mdb.mongodb.v1.DeleteDatabaseRequest")
proto.RegisterType((*DeleteDatabaseMetadata)(nil), "yandex.cloud.mdb.mongodb.v1.DeleteDatabaseMetadata")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// DatabaseServiceClient is the client API for DatabaseService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DatabaseServiceClient interface {
// Returns the specified MongoDB Database resource.
//
// To get the list of available MongoDB Database resources, make a [List] request.
Get(ctx context.Context, in *GetDatabaseRequest, opts ...grpc.CallOption) (*Database, error)
// Retrieves the list of MongoDB Database resources in the specified cluster.
List(ctx context.Context, in *ListDatabasesRequest, opts ...grpc.CallOption) (*ListDatabasesResponse, error)
// Creates a new MongoDB database in the specified cluster.
Create(ctx context.Context, in *CreateDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error)
// Deletes the specified MongoDB database.
Delete(ctx context.Context, in *DeleteDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error)
}
type databaseServiceClient struct {
cc *grpc.ClientConn
}
func NewDatabaseServiceClient(cc *grpc.ClientConn) DatabaseServiceClient {
return &databaseServiceClient{cc}
}
func (c *databaseServiceClient) Get(ctx context.Context, in *GetDatabaseRequest, opts ...grpc.CallOption) (*Database, error) {
out := new(Database)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.mongodb.v1.DatabaseService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *databaseServiceClient) List(ctx context.Context, in *ListDatabasesRequest, opts ...grpc.CallOption) (*ListDatabasesResponse, error) {
out := new(ListDatabasesResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.mongodb.v1.DatabaseService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *databaseServiceClient) Create(ctx context.Context, in *CreateDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.mongodb.v1.DatabaseService/Create", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *databaseServiceClient) Delete(ctx context.Context, in *DeleteDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.mongodb.v1.DatabaseService/Delete", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// DatabaseServiceServer is the server API for DatabaseService service.
type DatabaseServiceServer interface {
// Returns the specified MongoDB Database resource.
//
// To get the list of available MongoDB Database resources, make a [List] request.
Get(context.Context, *GetDatabaseRequest) (*Database, error)
// Retrieves the list of MongoDB Database resources in the specified cluster.
List(context.Context, *ListDatabasesRequest) (*ListDatabasesResponse, error)
// Creates a new MongoDB database in the specified cluster.
Create(context.Context, *CreateDatabaseRequest) (*operation.Operation, error)
// Deletes the specified MongoDB database.
Delete(context.Context, *DeleteDatabaseRequest) (*operation.Operation, error)
}
func RegisterDatabaseServiceServer(s *grpc.Server, srv DatabaseServiceServer) {
s.RegisterService(&_DatabaseService_serviceDesc, srv)
}
func _DatabaseService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetDatabaseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.mongodb.v1.DatabaseService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).Get(ctx, req.(*GetDatabaseRequest))
}
return interceptor(ctx, in, info, handler)
}
func _DatabaseService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListDatabasesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.mongodb.v1.DatabaseService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).List(ctx, req.(*ListDatabasesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _DatabaseService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateDatabaseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.mongodb.v1.DatabaseService/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).Create(ctx, req.(*CreateDatabaseRequest))
}
return interceptor(ctx, in, info, handler)
}
func _DatabaseService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteDatabaseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).Delete(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.mongodb.v1.DatabaseService/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).Delete(ctx, req.(*DeleteDatabaseRequest))
}
return interceptor(ctx, in, info, handler)
}
var _DatabaseService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.mdb.mongodb.v1.DatabaseService",
HandlerType: (*DatabaseServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _DatabaseService_Get_Handler,
},
{
MethodName: "List",
Handler: _DatabaseService_List_Handler,
},
{
MethodName: "Create",
Handler: _DatabaseService_Create_Handler,
},
{
MethodName: "Delete",
Handler: _DatabaseService_Delete_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/mdb/mongodb/v1/database_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/mongodb/v1/database_service.proto", fileDescriptor_database_service_9ac08729ed097c0a)
}
var fileDescriptor_database_service_9ac08729ed097c0a = []byte{
// 697 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcf, 0x4f, 0x13, 0x4d,
0x18, 0xce, 0x52, 0xbe, 0x86, 0x0e, 0xf0, 0x91, 0x4c, 0xbe, 0x92, 0xa6, 0xdf, 0xc7, 0x17, 0x5c,
0x23, 0x62, 0x4d, 0x77, 0xba, 0x25, 0x18, 0x15, 0x38, 0xd8, 0x42, 0x08, 0xf1, 0x67, 0x0a, 0x27,
0xc4, 0x34, 0xb3, 0xdd, 0xd7, 0x75, 0x63, 0x77, 0x67, 0xed, 0x4c, 0x1b, 0x7e, 0x04, 0x0f, 0xc6,
0x98, 0xc8, 0xd5, 0xe8, 0xc1, 0x3f, 0xc1, 0x23, 0xff, 0x83, 0x81, 0x33, 0xfe, 0x01, 0x5e, 0x3c,
0x78, 0xf6, 0xe8, 0xc9, 0xec, 0xce, 0x76, 0xdb, 0x42, 0xa9, 0x15, 0xb8, 0x4d, 0xe6, 0x7d, 0xde,
0x79, 0x9f, 0x67, 0xe6, 0x79, 0xe7, 0x45, 0xf9, 0x2d, 0xea, 0x9a, 0xb0, 0x49, 0x2a, 0x55, 0x56,
0x37, 0x89, 0x63, 0x1a, 0xc4, 0x61, 0xae, 0xc5, 0x4c, 0x83, 0x34, 0x74, 0x62, 0x52, 0x41, 0x0d,
0xca, 0xa1, 0xcc, 0xa1, 0xd6, 0xb0, 0x2b, 0xa0, 0x79, 0x35, 0x26, 0x18, 0xfe, 0x57, 0xe6, 0x68,
0x41, 0x8e, 0xe6, 0x98, 0x86, 0x16, 0xe6, 0x68, 0x0d, 0x3d, 0xfd, 0x9f, 0xc5, 0x98, 0x55, 0x05,
0x42, 0x3d, 0x9b, 0x50, 0xd7, 0x65, 0x82, 0x0a, 0x9b, 0xb9, 0x5c, 0xa6, 0xa6, 0xd3, 0x61, 0x39,
0x3f, 0xca, 0x3c, 0xa8, 0x05, 0xc1, 0x30, 0x36, 0xd5, 0x41, 0x25, 0x8a, 0x9e, 0xc0, 0x4d, 0x74,
0xe0, 0x1a, 0xb4, 0x6a, 0x9b, 0xed, 0xe1, 0x4c, 0x3f, 0x8a, 0x24, 0x56, 0x7d, 0xa3, 0x20, 0xbc,
0x0c, 0x62, 0x31, 0xdc, 0x2d, 0xc1, 0x8b, 0x3a, 0x70, 0x81, 0xaf, 0x23, 0x54, 0xa9, 0xd6, 0xb9,
0x80, 0x5a, 0xd9, 0x36, 0x53, 0xca, 0xa4, 0x32, 0x9d, 0x28, 0x8c, 0x7c, 0x3f, 0xd0, 0x95, 0xbd,
0x43, 0x7d, 0x70, 0x7e, 0x61, 0x36, 0x57, 0x4a, 0x84, 0xf1, 0x15, 0x13, 0x17, 0xd1, 0x68, 0x74,
0x4f, 0x2e, 0x75, 0x20, 0x35, 0x10, 0xe0, 0xff, 0xf7, 0xf1, 0x3f, 0x0e, 0xf4, 0xbf, 0x1f, 0xd3,
0xec, 0xf6, 0x9d, 0xec, 0x7a, 0x2e, 0x7b, 0xab, 0x9c, 0x7d, 0x92, 0x91, 0x27, 0xdc, 0x98, 0x29,
0x8d, 0x34, 0x93, 0x1e, 0x50, 0x07, 0xd4, 0x0f, 0x0a, 0xfa, 0xe7, 0x9e, 0xcd, 0x23, 0x26, 0xfc,
0x4c, 0x54, 0xae, 0xa2, 0x84, 0x47, 0x2d, 0x28, 0x73, 0x7b, 0x5b, 0xd2, 0x88, 0x15, 0xd0, 0xcf,
0x03, 0x3d, 0x3e, 0xbf, 0xa0, 0xe7, 0x72, 0xb9, 0xd2, 0x90, 0x1f, 0x5c, 0xb5, 0xb7, 0x01, 0x4f,
0x23, 0x14, 0x00, 0x05, 0x7b, 0x0e, 0x6e, 0x2a, 0x16, 0x9c, 0x9a, 0xd8, 0x3b, 0xd4, 0xff, 0x0a,
0x90, 0xa5, 0xe0, 0x94, 0x35, 0x3f, 0xa6, 0xbe, 0x56, 0x50, 0xf2, 0x18, 0x31, 0xee, 0x31, 0x97,
0x03, 0x2e, 0xa2, 0x44, 0x53, 0x02, 0x4f, 0x29, 0x93, 0xb1, 0xe9, 0xe1, 0xfc, 0x15, 0xad, 0x87,
0x33, 0xb4, 0xe8, 0x96, 0x5b, 0x79, 0x78, 0x0a, 0x8d, 0xb9, 0xb0, 0x29, 0xca, 0x6d, 0x6c, 0x82,
0xeb, 0x2b, 0x8d, 0xfa, 0xdb, 0x8f, 0x22, 0x1a, 0x1f, 0x15, 0x94, 0x2c, 0xd6, 0x80, 0x0a, 0x38,
0xd7, 0x5b, 0xad, 0xb5, 0xbd, 0x15, 0xf7, 0xa0, 0x12, 0x14, 0x1b, 0xce, 0x5f, 0xeb, 0x8b, 0xf7,
0xaa, 0x07, 0x95, 0xc2, 0xa0, 0x7f, 0x74, 0xeb, 0xf1, 0xfc, 0x3d, 0x75, 0x03, 0x8d, 0x77, 0x72,
0xbb, 0x0f, 0x82, 0xfa, 0x08, 0x3c, 0x71, 0x92, 0x5c, 0x3b, 0x9d, 0xcb, 0x5d, 0xad, 0x73, 0xcc,
0x1a, 0x6f, 0x15, 0x94, 0x5c, 0x84, 0x2a, 0x9c, 0x53, 0xfa, 0x85, 0xd8, 0x74, 0x03, 0x8d, 0x77,
0x52, 0xb9, 0x48, 0xa5, 0xf9, 0xf7, 0x71, 0x34, 0x16, 0x5d, 0xb6, 0xfc, 0x71, 0xf0, 0x27, 0x05,
0xc5, 0x96, 0x41, 0x60, 0xd2, 0xf3, 0x89, 0x4e, 0xf6, 0x70, 0xba, 0x3f, 0x2f, 0xaa, 0x77, 0x5f,
0x7d, 0xf9, 0xf6, 0x6e, 0x60, 0x09, 0x17, 0x89, 0x43, 0x5d, 0x6a, 0x81, 0x99, 0x6d, 0xfb, 0x2d,
0x42, 0xfe, 0x9c, 0xec, 0xb4, 0xb4, 0xed, 0x46, 0x7f, 0x08, 0x27, 0x3b, 0x1d, 0x9a, 0x76, 0x7d,
0xb2, 0x83, 0x7e, 0xb3, 0x60, 0xbd, 0x67, 0xf1, 0x6e, 0x8d, 0x9e, 0xce, 0xff, 0x49, 0x8a, 0x6c,
0x41, 0x75, 0x2e, 0x20, 0x3f, 0x8b, 0x67, 0xce, 0x40, 0x1e, 0x7f, 0x56, 0x50, 0x5c, 0xda, 0x16,
0xf7, 0xae, 0xdd, 0xb5, 0xef, 0xd2, 0x97, 0x3a, 0x73, 0x5a, 0x9f, 0xf4, 0xc3, 0xe6, 0x4a, 0x35,
0xf7, 0x8f, 0x32, 0xea, 0xa9, 0xbd, 0x31, 0xd4, 0xdc, 0x09, 0x44, 0xdc, 0x54, 0xcf, 0x22, 0xe2,
0xb6, 0x92, 0xc1, 0x5f, 0x15, 0x14, 0x97, 0xa6, 0xfc, 0x8d, 0x8e, 0xae, 0x4d, 0xd4, 0x8f, 0x8e,
0x97, 0xfb, 0x47, 0x19, 0x72, 0xaa, 0xf3, 0x93, 0x72, 0xe0, 0xc9, 0x89, 0x62, 0xd4, 0x9f, 0x6a,
0x4b, 0x8e, 0x27, 0xb6, 0xa4, 0xad, 0x32, 0x17, 0x61, 0xab, 0xc2, 0xca, 0xfa, 0xb2, 0x65, 0x8b,
0x67, 0x75, 0x43, 0xab, 0x30, 0x87, 0x48, 0xba, 0x59, 0x39, 0xde, 0x2c, 0x96, 0xb5, 0xc0, 0x0d,
0x4a, 0x93, 0x1e, 0x73, 0x6f, 0x2e, 0x5c, 0x1a, 0xf1, 0x00, 0x3a, 0xf3, 0x2b, 0x00, 0x00, 0xff,
0xff, 0x96, 0x76, 0x94, 0xd2, 0xf7, 0x07, 0x00, 0x00,
}

112
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/resource_preset.pb.go generated vendored Normal file
View File

@ -0,0 +1,112 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/mongodb/v1/resource_preset.proto
package mongodb // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// A ResourcePreset resource for describing hardware configuration presets.
type ResourcePreset struct {
// ID of the ResourcePreset resource.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// IDs of availability zones where the resource preset is available.
ZoneIds []string `protobuf:"bytes,2,rep,name=zone_ids,json=zoneIds,proto3" json:"zone_ids,omitempty"`
// Number of CPU cores for a MongoDB host created with the preset.
Cores int64 `protobuf:"varint,3,opt,name=cores,proto3" json:"cores,omitempty"`
// RAM volume for a MongoDB host created with the preset, in bytes.
Memory int64 `protobuf:"varint,4,opt,name=memory,proto3" json:"memory,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ResourcePreset) Reset() { *m = ResourcePreset{} }
func (m *ResourcePreset) String() string { return proto.CompactTextString(m) }
func (*ResourcePreset) ProtoMessage() {}
func (*ResourcePreset) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_e8f81c1a07027864, []int{0}
}
func (m *ResourcePreset) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ResourcePreset.Unmarshal(m, b)
}
func (m *ResourcePreset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ResourcePreset.Marshal(b, m, deterministic)
}
func (dst *ResourcePreset) XXX_Merge(src proto.Message) {
xxx_messageInfo_ResourcePreset.Merge(dst, src)
}
func (m *ResourcePreset) XXX_Size() int {
return xxx_messageInfo_ResourcePreset.Size(m)
}
func (m *ResourcePreset) XXX_DiscardUnknown() {
xxx_messageInfo_ResourcePreset.DiscardUnknown(m)
}
var xxx_messageInfo_ResourcePreset proto.InternalMessageInfo
func (m *ResourcePreset) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *ResourcePreset) GetZoneIds() []string {
if m != nil {
return m.ZoneIds
}
return nil
}
func (m *ResourcePreset) GetCores() int64 {
if m != nil {
return m.Cores
}
return 0
}
func (m *ResourcePreset) GetMemory() int64 {
if m != nil {
return m.Memory
}
return 0
}
func init() {
proto.RegisterType((*ResourcePreset)(nil), "yandex.cloud.mdb.mongodb.v1.ResourcePreset")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/mongodb/v1/resource_preset.proto", fileDescriptor_resource_preset_e8f81c1a07027864)
}
var fileDescriptor_resource_preset_e8f81c1a07027864 = []byte{
// 211 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x8f, 0x31, 0x4b, 0x04, 0x31,
0x10, 0x85, 0xd9, 0x5d, 0x3d, 0xbd, 0x14, 0x57, 0x04, 0x91, 0x15, 0x9b, 0xc5, 0x6a, 0x9b, 0x4b,
0x58, 0x2c, 0xed, 0x6c, 0xe4, 0x3a, 0x49, 0x69, 0x73, 0x98, 0xcc, 0x10, 0x03, 0x26, 0x73, 0x24,
0xbb, 0x87, 0xeb, 0xaf, 0x17, 0x93, 0xd4, 0xd7, 0xcd, 0x37, 0xbc, 0x0f, 0xde, 0x63, 0xd3, 0xfa,
0x19, 0x00, 0x7f, 0xa4, 0xf9, 0xa6, 0x05, 0xa4, 0x07, 0x2d, 0x3d, 0x05, 0x4b, 0xa0, 0xe5, 0x79,
0x92, 0x11, 0x13, 0x2d, 0xd1, 0xe0, 0xf1, 0x14, 0x31, 0xe1, 0x2c, 0x4e, 0x91, 0x66, 0xe2, 0x8f,
0x45, 0x11, 0x59, 0x11, 0x1e, 0xb4, 0xa8, 0x8a, 0x38, 0x4f, 0x4f, 0x8e, 0xed, 0x54, 0xb5, 0xde,
0xb3, 0xc4, 0x77, 0xac, 0x75, 0xd0, 0x37, 0x43, 0x33, 0x6e, 0x55, 0xeb, 0x80, 0x3f, 0xb0, 0xdb,
0x5f, 0x0a, 0x78, 0x74, 0x90, 0xfa, 0x76, 0xe8, 0xc6, 0xad, 0xba, 0xf9, 0xe7, 0x03, 0x24, 0x7e,
0xc7, 0xae, 0x0d, 0x45, 0x4c, 0x7d, 0x37, 0x34, 0x63, 0xa7, 0x0a, 0xf0, 0x7b, 0xb6, 0xf1, 0xe8,
0x29, 0xae, 0xfd, 0x55, 0x7e, 0x57, 0x7a, 0x3d, 0x7c, 0xbc, 0x59, 0x37, 0x7f, 0x2d, 0x5a, 0x18,
0xf2, 0xb2, 0x94, 0xda, 0x97, 0x1d, 0x96, 0xf6, 0x16, 0x43, 0xae, 0x2b, 0x2f, 0x0c, 0x7c, 0xa9,
0xa7, 0xde, 0xe4, 0xe8, 0xf3, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x03, 0xbd, 0x87, 0x16, 0x0e,
0x01, 0x00, 0x00,
}

324
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/resource_preset_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,324 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/mongodb/v1/resource_preset_service.proto
package mongodb // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetResourcePresetRequest struct {
// ID of the resource preset to return.
// To get the resource preset ID, use a [ResourcePresetService.List] request.
ResourcePresetId string `protobuf:"bytes,1,opt,name=resource_preset_id,json=resourcePresetId,proto3" json:"resource_preset_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetResourcePresetRequest) Reset() { *m = GetResourcePresetRequest{} }
func (m *GetResourcePresetRequest) String() string { return proto.CompactTextString(m) }
func (*GetResourcePresetRequest) ProtoMessage() {}
func (*GetResourcePresetRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_service_0453cd5d31029933, []int{0}
}
func (m *GetResourcePresetRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetResourcePresetRequest.Unmarshal(m, b)
}
func (m *GetResourcePresetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetResourcePresetRequest.Marshal(b, m, deterministic)
}
func (dst *GetResourcePresetRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetResourcePresetRequest.Merge(dst, src)
}
func (m *GetResourcePresetRequest) XXX_Size() int {
return xxx_messageInfo_GetResourcePresetRequest.Size(m)
}
func (m *GetResourcePresetRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetResourcePresetRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetResourcePresetRequest proto.InternalMessageInfo
func (m *GetResourcePresetRequest) GetResourcePresetId() string {
if m != nil {
return m.ResourcePresetId
}
return ""
}
type ListResourcePresetsRequest struct {
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size], the service returns a [ListResourcePresetsResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the
// [ListResourcePresetsResponse.next_page_token] returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListResourcePresetsRequest) Reset() { *m = ListResourcePresetsRequest{} }
func (m *ListResourcePresetsRequest) String() string { return proto.CompactTextString(m) }
func (*ListResourcePresetsRequest) ProtoMessage() {}
func (*ListResourcePresetsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_service_0453cd5d31029933, []int{1}
}
func (m *ListResourcePresetsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListResourcePresetsRequest.Unmarshal(m, b)
}
func (m *ListResourcePresetsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListResourcePresetsRequest.Marshal(b, m, deterministic)
}
func (dst *ListResourcePresetsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListResourcePresetsRequest.Merge(dst, src)
}
func (m *ListResourcePresetsRequest) XXX_Size() int {
return xxx_messageInfo_ListResourcePresetsRequest.Size(m)
}
func (m *ListResourcePresetsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListResourcePresetsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListResourcePresetsRequest proto.InternalMessageInfo
func (m *ListResourcePresetsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListResourcePresetsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListResourcePresetsResponse struct {
// List of ResourcePreset resources.
ResourcePresets []*ResourcePreset `protobuf:"bytes,1,rep,name=resource_presets,json=resourcePresets,proto3" json:"resource_presets,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListResourcePresetsRequest.page_size], use the [next_page_token] as the value
// for the [ListResourcePresetsRequest.page_token] parameter in the next list request. Each subsequent
// list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListResourcePresetsResponse) Reset() { *m = ListResourcePresetsResponse{} }
func (m *ListResourcePresetsResponse) String() string { return proto.CompactTextString(m) }
func (*ListResourcePresetsResponse) ProtoMessage() {}
func (*ListResourcePresetsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_service_0453cd5d31029933, []int{2}
}
func (m *ListResourcePresetsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListResourcePresetsResponse.Unmarshal(m, b)
}
func (m *ListResourcePresetsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListResourcePresetsResponse.Marshal(b, m, deterministic)
}
func (dst *ListResourcePresetsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListResourcePresetsResponse.Merge(dst, src)
}
func (m *ListResourcePresetsResponse) XXX_Size() int {
return xxx_messageInfo_ListResourcePresetsResponse.Size(m)
}
func (m *ListResourcePresetsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListResourcePresetsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListResourcePresetsResponse proto.InternalMessageInfo
func (m *ListResourcePresetsResponse) GetResourcePresets() []*ResourcePreset {
if m != nil {
return m.ResourcePresets
}
return nil
}
func (m *ListResourcePresetsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetResourcePresetRequest)(nil), "yandex.cloud.mdb.mongodb.v1.GetResourcePresetRequest")
proto.RegisterType((*ListResourcePresetsRequest)(nil), "yandex.cloud.mdb.mongodb.v1.ListResourcePresetsRequest")
proto.RegisterType((*ListResourcePresetsResponse)(nil), "yandex.cloud.mdb.mongodb.v1.ListResourcePresetsResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// ResourcePresetServiceClient is the client API for ResourcePresetService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ResourcePresetServiceClient interface {
// Returns the specified ResourcePreset resource.
//
// To get the list of available ResourcePreset resources, make a [List] request.
Get(ctx context.Context, in *GetResourcePresetRequest, opts ...grpc.CallOption) (*ResourcePreset, error)
// Retrieves the list of available ResourcePreset resources.
List(ctx context.Context, in *ListResourcePresetsRequest, opts ...grpc.CallOption) (*ListResourcePresetsResponse, error)
}
type resourcePresetServiceClient struct {
cc *grpc.ClientConn
}
func NewResourcePresetServiceClient(cc *grpc.ClientConn) ResourcePresetServiceClient {
return &resourcePresetServiceClient{cc}
}
func (c *resourcePresetServiceClient) Get(ctx context.Context, in *GetResourcePresetRequest, opts ...grpc.CallOption) (*ResourcePreset, error) {
out := new(ResourcePreset)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.mongodb.v1.ResourcePresetService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *resourcePresetServiceClient) List(ctx context.Context, in *ListResourcePresetsRequest, opts ...grpc.CallOption) (*ListResourcePresetsResponse, error) {
out := new(ListResourcePresetsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.mongodb.v1.ResourcePresetService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// ResourcePresetServiceServer is the server API for ResourcePresetService service.
type ResourcePresetServiceServer interface {
// Returns the specified ResourcePreset resource.
//
// To get the list of available ResourcePreset resources, make a [List] request.
Get(context.Context, *GetResourcePresetRequest) (*ResourcePreset, error)
// Retrieves the list of available ResourcePreset resources.
List(context.Context, *ListResourcePresetsRequest) (*ListResourcePresetsResponse, error)
}
func RegisterResourcePresetServiceServer(s *grpc.Server, srv ResourcePresetServiceServer) {
s.RegisterService(&_ResourcePresetService_serviceDesc, srv)
}
func _ResourcePresetService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetResourcePresetRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ResourcePresetServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.mongodb.v1.ResourcePresetService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ResourcePresetServiceServer).Get(ctx, req.(*GetResourcePresetRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ResourcePresetService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListResourcePresetsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ResourcePresetServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.mongodb.v1.ResourcePresetService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ResourcePresetServiceServer).List(ctx, req.(*ListResourcePresetsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ResourcePresetService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.mdb.mongodb.v1.ResourcePresetService",
HandlerType: (*ResourcePresetServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _ResourcePresetService_Get_Handler,
},
{
MethodName: "List",
Handler: _ResourcePresetService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/mdb/mongodb/v1/resource_preset_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/mongodb/v1/resource_preset_service.proto", fileDescriptor_resource_preset_service_0453cd5d31029933)
}
var fileDescriptor_resource_preset_service_0453cd5d31029933 = []byte{
// 457 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0x4f, 0x6b, 0x13, 0x41,
0x1c, 0x65, 0x92, 0x5a, 0xcc, 0x88, 0xb4, 0x0c, 0x08, 0xcb, 0x56, 0x21, 0xac, 0xa8, 0x81, 0x92,
0x99, 0x6c, 0x44, 0xac, 0xff, 0x40, 0x72, 0x09, 0x05, 0x91, 0xb2, 0x15, 0x0f, 0x5e, 0xc2, 0x6c,
0xe6, 0xc7, 0x38, 0x98, 0x9d, 0x59, 0x77, 0x26, 0xa1, 0x56, 0xbc, 0x78, 0xf4, 0xea, 0xd9, 0xab,
0x17, 0x3f, 0x48, 0xbd, 0xfb, 0x15, 0x3c, 0x78, 0xf2, 0x03, 0x78, 0x92, 0x9d, 0xdd, 0x82, 0x89,
0xed, 0xd2, 0xdc, 0x96, 0x7d, 0xf3, 0x7e, 0xef, 0xbd, 0x79, 0xbf, 0xc1, 0x0f, 0xde, 0x71, 0x2d,
0xe0, 0x88, 0x4d, 0x67, 0x66, 0x2e, 0x58, 0x26, 0x52, 0x96, 0x19, 0x2d, 0x8d, 0x48, 0xd9, 0x22,
0x66, 0x05, 0x58, 0x33, 0x2f, 0xa6, 0x30, 0xc9, 0x0b, 0xb0, 0xe0, 0x26, 0x16, 0x8a, 0x85, 0x9a,
0x02, 0xcd, 0x0b, 0xe3, 0x0c, 0xd9, 0xa9, 0xa8, 0xd4, 0x53, 0x69, 0x26, 0x52, 0x5a, 0x53, 0xe9,
0x22, 0x0e, 0xaf, 0x4b, 0x63, 0xe4, 0x0c, 0x18, 0xcf, 0x15, 0xe3, 0x5a, 0x1b, 0xc7, 0x9d, 0x32,
0xda, 0x56, 0xd4, 0xf0, 0xc6, 0x92, 0xea, 0x82, 0xcf, 0x94, 0xf0, 0x78, 0x0d, 0xc7, 0x6b, 0x98,
0xaa, 0x28, 0xd1, 0x73, 0x1c, 0x8c, 0xc1, 0x25, 0x35, 0x76, 0xe0, 0xa1, 0x04, 0xde, 0xce, 0xc1,
0x3a, 0x32, 0xc4, 0x64, 0x35, 0x89, 0x12, 0x01, 0xea, 0xa2, 0x5e, 0x67, 0xb4, 0xf1, 0xeb, 0x24,
0x46, 0xc9, 0x76, 0xb1, 0x44, 0xdc, 0x17, 0x91, 0xc1, 0xe1, 0x33, 0x65, 0x57, 0x06, 0xda, 0xd3,
0x89, 0x77, 0x70, 0x27, 0xe7, 0x12, 0x26, 0x56, 0x1d, 0x43, 0xd0, 0xea, 0xa2, 0x5e, 0x7b, 0x84,
0xff, 0x9c, 0xc4, 0x9b, 0x8f, 0x9f, 0xc4, 0x83, 0xc1, 0x20, 0xb9, 0x5c, 0x82, 0x87, 0xea, 0x18,
0x48, 0x0f, 0x63, 0x7f, 0xd0, 0x99, 0x37, 0xa0, 0x83, 0xb6, 0x97, 0xec, 0x7c, 0xfa, 0x1e, 0x5f,
0xf2, 0x27, 0x13, 0x3f, 0xe5, 0x45, 0x89, 0x45, 0x5f, 0x10, 0xde, 0x39, 0x53, 0xd1, 0xe6, 0x46,
0x5b, 0x20, 0x2f, 0xf1, 0xf6, 0x4a, 0x08, 0x1b, 0xa0, 0x6e, 0xbb, 0x77, 0x65, 0xb8, 0x4b, 0x1b,
0x8a, 0xa0, 0x2b, 0x57, 0xb2, 0xb5, 0x9c, 0xd4, 0x92, 0xdb, 0x78, 0x4b, 0xc3, 0x91, 0x9b, 0xfc,
0x63, 0xb3, 0x0c, 0xd4, 0x49, 0xae, 0x96, 0xbf, 0x0f, 0x4e, 0xfd, 0x0d, 0x7f, 0xb7, 0xf0, 0xb5,
0xe5, 0x59, 0x87, 0xd5, 0x36, 0x90, 0x6f, 0x08, 0xb7, 0xc7, 0xe0, 0xc8, 0xbd, 0x46, 0x1f, 0xe7,
0xb5, 0x13, 0xae, 0x63, 0x3f, 0x7a, 0xfa, 0xf1, 0xc7, 0xcf, 0xcf, 0xad, 0x87, 0x64, 0x8f, 0x65,
0x5c, 0x73, 0x09, 0xa2, 0x7f, 0xc6, 0x66, 0xd4, 0xd1, 0xd8, 0xfb, 0xff, 0x5b, 0xff, 0x40, 0xbe,
0x22, 0xbc, 0x51, 0xde, 0x33, 0xb9, 0xdf, 0xa8, 0x7b, 0x7e, 0xf9, 0xe1, 0xde, 0xfa, 0xc4, 0xaa,
0xc3, 0x68, 0xd7, 0xbb, 0xbf, 0x45, 0x6e, 0x5e, 0xc0, 0xfd, 0x68, 0xff, 0xd5, 0x58, 0x2a, 0xf7,
0x7a, 0x9e, 0xd2, 0xa9, 0xc9, 0x58, 0x25, 0xd9, 0xaf, 0x5e, 0x84, 0x34, 0x7d, 0x09, 0xda, 0x2f,
0x3e, 0x6b, 0x78, 0x2a, 0x8f, 0xea, 0xcf, 0x74, 0xd3, 0x1f, 0xbd, 0xfb, 0x37, 0x00, 0x00, 0xff,
0xff, 0xcf, 0x5c, 0x51, 0x57, 0xed, 0x03, 0x00, 0x00,
}

220
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/user.pb.go generated vendored Normal file
View File

@ -0,0 +1,220 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/mongodb/v1/user.proto
package mongodb // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// A MongoDB User resource. For more information, see the
// [Developer's Guide](/docs/managed-mongodb/concepts).
type User struct {
// Name of the MongoDB user.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// ID of the MongoDB cluster the user belongs to.
ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Set of permissions granted to the user.
Permissions []*Permission `protobuf:"bytes,3,rep,name=permissions,proto3" json:"permissions,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *User) Reset() { *m = User{} }
func (m *User) String() string { return proto.CompactTextString(m) }
func (*User) ProtoMessage() {}
func (*User) Descriptor() ([]byte, []int) {
return fileDescriptor_user_ce6db2103014c466, []int{0}
}
func (m *User) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_User.Unmarshal(m, b)
}
func (m *User) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_User.Marshal(b, m, deterministic)
}
func (dst *User) XXX_Merge(src proto.Message) {
xxx_messageInfo_User.Merge(dst, src)
}
func (m *User) XXX_Size() int {
return xxx_messageInfo_User.Size(m)
}
func (m *User) XXX_DiscardUnknown() {
xxx_messageInfo_User.DiscardUnknown(m)
}
var xxx_messageInfo_User proto.InternalMessageInfo
func (m *User) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *User) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *User) GetPermissions() []*Permission {
if m != nil {
return m.Permissions
}
return nil
}
type Permission struct {
// Name of the database that the permission grants access to.
DatabaseName string `protobuf:"bytes,1,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
// MongoDB roles for the [database_name] database that the permission grants.
Roles []string `protobuf:"bytes,2,rep,name=roles,proto3" json:"roles,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Permission) Reset() { *m = Permission{} }
func (m *Permission) String() string { return proto.CompactTextString(m) }
func (*Permission) ProtoMessage() {}
func (*Permission) Descriptor() ([]byte, []int) {
return fileDescriptor_user_ce6db2103014c466, []int{1}
}
func (m *Permission) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Permission.Unmarshal(m, b)
}
func (m *Permission) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Permission.Marshal(b, m, deterministic)
}
func (dst *Permission) XXX_Merge(src proto.Message) {
xxx_messageInfo_Permission.Merge(dst, src)
}
func (m *Permission) XXX_Size() int {
return xxx_messageInfo_Permission.Size(m)
}
func (m *Permission) XXX_DiscardUnknown() {
xxx_messageInfo_Permission.DiscardUnknown(m)
}
var xxx_messageInfo_Permission proto.InternalMessageInfo
func (m *Permission) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
func (m *Permission) GetRoles() []string {
if m != nil {
return m.Roles
}
return nil
}
type UserSpec struct {
// Name of the MongoDB user.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Password of the MongoDB user.
Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
// Set of permissions to grant to the user.
Permissions []*Permission `protobuf:"bytes,3,rep,name=permissions,proto3" json:"permissions,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UserSpec) Reset() { *m = UserSpec{} }
func (m *UserSpec) String() string { return proto.CompactTextString(m) }
func (*UserSpec) ProtoMessage() {}
func (*UserSpec) Descriptor() ([]byte, []int) {
return fileDescriptor_user_ce6db2103014c466, []int{2}
}
func (m *UserSpec) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UserSpec.Unmarshal(m, b)
}
func (m *UserSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UserSpec.Marshal(b, m, deterministic)
}
func (dst *UserSpec) XXX_Merge(src proto.Message) {
xxx_messageInfo_UserSpec.Merge(dst, src)
}
func (m *UserSpec) XXX_Size() int {
return xxx_messageInfo_UserSpec.Size(m)
}
func (m *UserSpec) XXX_DiscardUnknown() {
xxx_messageInfo_UserSpec.DiscardUnknown(m)
}
var xxx_messageInfo_UserSpec proto.InternalMessageInfo
func (m *UserSpec) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *UserSpec) GetPassword() string {
if m != nil {
return m.Password
}
return ""
}
func (m *UserSpec) GetPermissions() []*Permission {
if m != nil {
return m.Permissions
}
return nil
}
func init() {
proto.RegisterType((*User)(nil), "yandex.cloud.mdb.mongodb.v1.User")
proto.RegisterType((*Permission)(nil), "yandex.cloud.mdb.mongodb.v1.Permission")
proto.RegisterType((*UserSpec)(nil), "yandex.cloud.mdb.mongodb.v1.UserSpec")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/mongodb/v1/user.proto", fileDescriptor_user_ce6db2103014c466)
}
var fileDescriptor_user_ce6db2103014c466 = []byte{
// 345 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0xab, 0x4c, 0xcc, 0x4b,
0x49, 0xad, 0xd0, 0x4f, 0xce, 0xc9, 0x2f, 0x4d, 0xd1, 0xcf, 0x4d, 0x49, 0xd2, 0xcf, 0xcd, 0xcf,
0x4b, 0xcf, 0x4f, 0x49, 0xd2, 0x2f, 0x33, 0xd4, 0x2f, 0x2d, 0x4e, 0x2d, 0xd2, 0x2b, 0x28, 0xca,
0x2f, 0xc9, 0x17, 0x92, 0x86, 0xa8, 0xd3, 0x03, 0xab, 0xd3, 0xcb, 0x4d, 0x49, 0xd2, 0x83, 0xaa,
0xd3, 0x2b, 0x33, 0x94, 0x92, 0x45, 0x31, 0xa4, 0x2c, 0x31, 0x27, 0x33, 0x25, 0xb1, 0x24, 0x33,
0x3f, 0x0f, 0xa2, 0x57, 0xa9, 0x85, 0x91, 0x8b, 0x25, 0xb4, 0x38, 0xb5, 0x48, 0x48, 0x88, 0x8b,
0x25, 0x2f, 0x31, 0x37, 0x55, 0x82, 0x51, 0x81, 0x51, 0x83, 0x33, 0x08, 0xcc, 0x16, 0x92, 0xe5,
0xe2, 0x4a, 0xce, 0x29, 0x2d, 0x2e, 0x49, 0x2d, 0x8a, 0xcf, 0x4c, 0x91, 0x60, 0x02, 0xcb, 0x70,
0x42, 0x45, 0x3c, 0x53, 0x84, 0x3c, 0xb9, 0xb8, 0x0b, 0x52, 0x8b, 0x72, 0x33, 0x8b, 0x8b, 0x33,
0xf3, 0xf3, 0x8a, 0x25, 0x98, 0x15, 0x98, 0x35, 0xb8, 0x8d, 0xd4, 0xf5, 0xf0, 0xb8, 0x46, 0x2f,
0x00, 0xae, 0x3e, 0x08, 0x59, 0xaf, 0x92, 0x3b, 0x17, 0x17, 0x42, 0x4a, 0x48, 0x99, 0x8b, 0x37,
0x25, 0xb1, 0x24, 0x31, 0x29, 0xb1, 0x38, 0x35, 0x1e, 0xc9, 0x51, 0x3c, 0x30, 0x41, 0x3f, 0x90,
0xe3, 0x44, 0xb8, 0x58, 0x8b, 0xf2, 0x73, 0x52, 0x8b, 0x25, 0x98, 0x14, 0x98, 0x35, 0x38, 0x83,
0x20, 0x1c, 0xa5, 0xcd, 0x8c, 0x5c, 0x1c, 0x20, 0xff, 0x04, 0x17, 0xa4, 0x26, 0x0b, 0x19, 0x22,
0xfb, 0xc9, 0x49, 0xf6, 0xc5, 0x71, 0x43, 0xc6, 0x4f, 0xc7, 0x0d, 0x79, 0xa3, 0x13, 0x75, 0xab,
0x1c, 0x75, 0xa3, 0x0c, 0x74, 0x2d, 0xe3, 0x63, 0xb5, 0xba, 0x4e, 0x18, 0xb2, 0xd8, 0xd8, 0x9a,
0x19, 0x43, 0xbd, 0xac, 0xc9, 0xc5, 0x51, 0x90, 0x58, 0x5c, 0x5c, 0x9e, 0x5f, 0x04, 0xf5, 0xb0,
0x13, 0x2f, 0x48, 0x5b, 0xd7, 0x09, 0x43, 0x56, 0x0b, 0x5d, 0x43, 0x23, 0x8b, 0x20, 0xb8, 0x34,
0x15, 0xbd, 0xef, 0xe4, 0x19, 0xe5, 0x9e, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f,
0xab, 0x0f, 0x31, 0x41, 0x17, 0x12, 0x63, 0xe9, 0xf9, 0xba, 0xe9, 0xa9, 0x79, 0xe0, 0xc8, 0xd2,
0xc7, 0x93, 0x1e, 0xac, 0xa1, 0xcc, 0x24, 0x36, 0xb0, 0x52, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff,
0xff, 0xb7, 0x04, 0x46, 0xbf, 0x3d, 0x02, 0x00, 0x00,
}

1097
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/mongodb/v1/user_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

127
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/backup.pb.go generated vendored Normal file
View File

@ -0,0 +1,127 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/postgresql/v1/backup.proto
package postgresql // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// A PostgreSQL Backup resource. For more information, see
// the [Developer's Guide](/docs/managed-postgresql/concepts/backup).
type Backup struct {
// ID of the backup.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the backup belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format
// (i.e. when the backup operation was completed).
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// ID of the PostgreSQL cluster that the backup was created for.
SourceClusterId string `protobuf:"bytes,4,opt,name=source_cluster_id,json=sourceClusterId,proto3" json:"source_cluster_id,omitempty"`
// Time when the backup operation was started.
StartedAt *timestamp.Timestamp `protobuf:"bytes,5,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Backup) Reset() { *m = Backup{} }
func (m *Backup) String() string { return proto.CompactTextString(m) }
func (*Backup) ProtoMessage() {}
func (*Backup) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_201d65cfeeef8a8a, []int{0}
}
func (m *Backup) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Backup.Unmarshal(m, b)
}
func (m *Backup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Backup.Marshal(b, m, deterministic)
}
func (dst *Backup) XXX_Merge(src proto.Message) {
xxx_messageInfo_Backup.Merge(dst, src)
}
func (m *Backup) XXX_Size() int {
return xxx_messageInfo_Backup.Size(m)
}
func (m *Backup) XXX_DiscardUnknown() {
xxx_messageInfo_Backup.DiscardUnknown(m)
}
var xxx_messageInfo_Backup proto.InternalMessageInfo
func (m *Backup) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Backup) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Backup) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Backup) GetSourceClusterId() string {
if m != nil {
return m.SourceClusterId
}
return ""
}
func (m *Backup) GetStartedAt() *timestamp.Timestamp {
if m != nil {
return m.StartedAt
}
return nil
}
func init() {
proto.RegisterType((*Backup)(nil), "yandex.cloud.mdb.postgresql.v1.Backup")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/postgresql/v1/backup.proto", fileDescriptor_backup_201d65cfeeef8a8a)
}
var fileDescriptor_backup_201d65cfeeef8a8a = []byte{
// 268 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x90, 0xc1, 0x4a, 0x33, 0x31,
0x14, 0x85, 0x99, 0xf9, 0x7f, 0x8b, 0x13, 0x41, 0x71, 0x56, 0x43, 0x05, 0x2d, 0xae, 0x8a, 0xd2,
0x84, 0xea, 0x4a, 0x5c, 0xb5, 0xae, 0x5c, 0x88, 0x50, 0x5c, 0xb9, 0x19, 0x92, 0xdc, 0x34, 0x0e,
0xce, 0xf4, 0x8e, 0xc9, 0x4d, 0xd1, 0x27, 0xf5, 0x75, 0x84, 0x64, 0x4a, 0x77, 0xba, 0xcc, 0xc9,
0x77, 0xcf, 0x07, 0x87, 0x5d, 0x7f, 0xc9, 0x0d, 0x98, 0x4f, 0xa1, 0x5b, 0x0c, 0x20, 0x3a, 0x50,
0xa2, 0x47, 0x4f, 0xd6, 0x19, 0xff, 0xd1, 0x8a, 0xed, 0x5c, 0x28, 0xa9, 0xdf, 0x43, 0xcf, 0x7b,
0x87, 0x84, 0xe5, 0x79, 0x82, 0x79, 0x84, 0x79, 0x07, 0x8a, 0xef, 0x61, 0xbe, 0x9d, 0x8f, 0x2f,
0x2c, 0xa2, 0x6d, 0x8d, 0x88, 0xb4, 0x0a, 0x6b, 0x41, 0x4d, 0x67, 0x3c, 0xc9, 0x6e, 0x28, 0xb8,
0xfc, 0xce, 0xd8, 0x68, 0x19, 0x1b, 0xcb, 0x63, 0x96, 0x37, 0x50, 0x65, 0x93, 0x6c, 0x5a, 0xac,
0xf2, 0x06, 0xca, 0x33, 0x56, 0xac, 0xb1, 0x05, 0xe3, 0xea, 0x06, 0xaa, 0x3c, 0xc6, 0x87, 0x29,
0x78, 0x84, 0xf2, 0x8e, 0x31, 0xed, 0x8c, 0x24, 0x03, 0xb5, 0xa4, 0xea, 0xdf, 0x24, 0x9b, 0x1e,
0xdd, 0x8c, 0x79, 0xb2, 0xf1, 0x9d, 0x8d, 0xbf, 0xec, 0x6c, 0xab, 0x62, 0xa0, 0x17, 0x54, 0x5e,
0xb1, 0x53, 0x8f, 0xc1, 0x69, 0x53, 0xeb, 0x36, 0x78, 0x4a, 0xfd, 0xff, 0x63, 0xff, 0x49, 0xfa,
0x78, 0x48, 0x79, 0xd2, 0x78, 0x92, 0x6e, 0xd0, 0x1c, 0xfc, 0xad, 0x19, 0xe8, 0x05, 0x2d, 0x9f,
0x5f, 0x9f, 0x6c, 0x43, 0x6f, 0x41, 0x71, 0x8d, 0x9d, 0x48, 0x3b, 0xcd, 0xd2, 0xa8, 0x16, 0x67,
0xd6, 0x6c, 0xe2, 0xb9, 0xf8, 0x7d, 0xed, 0xfb, 0xfd, 0x4b, 0x8d, 0xe2, 0xc1, 0xed, 0x4f, 0x00,
0x00, 0x00, 0xff, 0xff, 0xed, 0x24, 0x15, 0xfb, 0xa1, 0x01, 0x00, 0x00,
}

335
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/backup_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,335 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/postgresql/v1/backup_service.proto
package postgresql // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetBackupRequest struct {
// ID of the backup to return information about.
// To get the backup ID, use a [ClusterService.ListBackups] request.
BackupId string `protobuf:"bytes,1,opt,name=backup_id,json=backupId,proto3" json:"backup_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetBackupRequest) Reset() { *m = GetBackupRequest{} }
func (m *GetBackupRequest) String() string { return proto.CompactTextString(m) }
func (*GetBackupRequest) ProtoMessage() {}
func (*GetBackupRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_76dfe2452a94567c, []int{0}
}
func (m *GetBackupRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetBackupRequest.Unmarshal(m, b)
}
func (m *GetBackupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetBackupRequest.Marshal(b, m, deterministic)
}
func (dst *GetBackupRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetBackupRequest.Merge(dst, src)
}
func (m *GetBackupRequest) XXX_Size() int {
return xxx_messageInfo_GetBackupRequest.Size(m)
}
func (m *GetBackupRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetBackupRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetBackupRequest proto.InternalMessageInfo
func (m *GetBackupRequest) GetBackupId() string {
if m != nil {
return m.BackupId
}
return ""
}
type ListBackupsRequest struct {
// ID of the folder to list backups in.
// To get the folder ID, use a [yandex.cloud.resourcemanager.v1.FolderService.List] request.
FolderId string `protobuf:"bytes,1,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size], the service returns a [ListBackupsResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, Set [page_token] to the [ListBackupsResponse.next_page_token]
// returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListBackupsRequest) Reset() { *m = ListBackupsRequest{} }
func (m *ListBackupsRequest) String() string { return proto.CompactTextString(m) }
func (*ListBackupsRequest) ProtoMessage() {}
func (*ListBackupsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_76dfe2452a94567c, []int{1}
}
func (m *ListBackupsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListBackupsRequest.Unmarshal(m, b)
}
func (m *ListBackupsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListBackupsRequest.Marshal(b, m, deterministic)
}
func (dst *ListBackupsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListBackupsRequest.Merge(dst, src)
}
func (m *ListBackupsRequest) XXX_Size() int {
return xxx_messageInfo_ListBackupsRequest.Size(m)
}
func (m *ListBackupsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListBackupsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListBackupsRequest proto.InternalMessageInfo
func (m *ListBackupsRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *ListBackupsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListBackupsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListBackupsResponse struct {
// List of PostgreSQL Backup resources.
Backups []*Backup `protobuf:"bytes,1,rep,name=backups,proto3" json:"backups,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListBackupsRequest.page_size], use the [next_page_token] as the value
// for the [ListBackupsRequest.page_token] parameter in the next list request. Each subsequent
// list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListBackupsResponse) Reset() { *m = ListBackupsResponse{} }
func (m *ListBackupsResponse) String() string { return proto.CompactTextString(m) }
func (*ListBackupsResponse) ProtoMessage() {}
func (*ListBackupsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_76dfe2452a94567c, []int{2}
}
func (m *ListBackupsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListBackupsResponse.Unmarshal(m, b)
}
func (m *ListBackupsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListBackupsResponse.Marshal(b, m, deterministic)
}
func (dst *ListBackupsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListBackupsResponse.Merge(dst, src)
}
func (m *ListBackupsResponse) XXX_Size() int {
return xxx_messageInfo_ListBackupsResponse.Size(m)
}
func (m *ListBackupsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListBackupsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListBackupsResponse proto.InternalMessageInfo
func (m *ListBackupsResponse) GetBackups() []*Backup {
if m != nil {
return m.Backups
}
return nil
}
func (m *ListBackupsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetBackupRequest)(nil), "yandex.cloud.mdb.postgresql.v1.GetBackupRequest")
proto.RegisterType((*ListBackupsRequest)(nil), "yandex.cloud.mdb.postgresql.v1.ListBackupsRequest")
proto.RegisterType((*ListBackupsResponse)(nil), "yandex.cloud.mdb.postgresql.v1.ListBackupsResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// BackupServiceClient is the client API for BackupService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type BackupServiceClient interface {
// Returns the specified PostgreSQL Backup resource.
//
// To get the list of available PostgreSQL Backup resources, make a [List] request.
Get(ctx context.Context, in *GetBackupRequest, opts ...grpc.CallOption) (*Backup, error)
// Retrieves the list of Backup resources available for the specified folder.
List(ctx context.Context, in *ListBackupsRequest, opts ...grpc.CallOption) (*ListBackupsResponse, error)
}
type backupServiceClient struct {
cc *grpc.ClientConn
}
func NewBackupServiceClient(cc *grpc.ClientConn) BackupServiceClient {
return &backupServiceClient{cc}
}
func (c *backupServiceClient) Get(ctx context.Context, in *GetBackupRequest, opts ...grpc.CallOption) (*Backup, error) {
out := new(Backup)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.postgresql.v1.BackupService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *backupServiceClient) List(ctx context.Context, in *ListBackupsRequest, opts ...grpc.CallOption) (*ListBackupsResponse, error) {
out := new(ListBackupsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.postgresql.v1.BackupService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// BackupServiceServer is the server API for BackupService service.
type BackupServiceServer interface {
// Returns the specified PostgreSQL Backup resource.
//
// To get the list of available PostgreSQL Backup resources, make a [List] request.
Get(context.Context, *GetBackupRequest) (*Backup, error)
// Retrieves the list of Backup resources available for the specified folder.
List(context.Context, *ListBackupsRequest) (*ListBackupsResponse, error)
}
func RegisterBackupServiceServer(s *grpc.Server, srv BackupServiceServer) {
s.RegisterService(&_BackupService_serviceDesc, srv)
}
func _BackupService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetBackupRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BackupServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.postgresql.v1.BackupService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BackupServiceServer).Get(ctx, req.(*GetBackupRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BackupService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListBackupsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BackupServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.postgresql.v1.BackupService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BackupServiceServer).List(ctx, req.(*ListBackupsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _BackupService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.mdb.postgresql.v1.BackupService",
HandlerType: (*BackupServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _BackupService_Get_Handler,
},
{
MethodName: "List",
Handler: _BackupService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/mdb/postgresql/v1/backup_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/postgresql/v1/backup_service.proto", fileDescriptor_backup_service_76dfe2452a94567c)
}
var fileDescriptor_backup_service_76dfe2452a94567c = []byte{
// 466 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0xbf, 0x6f, 0x13, 0x31,
0x14, 0xc7, 0xe5, 0x24, 0x94, 0x9c, 0xa1, 0x02, 0x99, 0x25, 0x8a, 0xa0, 0x0a, 0x37, 0x94, 0xf0,
0x23, 0xe7, 0xbb, 0x44, 0x9d, 0x68, 0x25, 0x94, 0xa5, 0xaa, 0x04, 0x02, 0x5d, 0x99, 0x58, 0x22,
0x5f, 0xfc, 0x30, 0x56, 0x2f, 0xf6, 0x35, 0x76, 0xa2, 0x52, 0xc4, 0xc2, 0x98, 0x91, 0x0e, 0xfc,
0x39, 0x8c, 0xed, 0xce, 0xbf, 0xc0, 0xc0, 0xdf, 0xc0, 0x84, 0xce, 0x4e, 0x08, 0x2d, 0x28, 0x2d,
0xa3, 0xfd, 0x7d, 0x9f, 0xf7, 0xbe, 0x7a, 0xdf, 0x87, 0x7b, 0xef, 0x99, 0xe2, 0x70, 0x44, 0x87,
0xb9, 0x9e, 0x70, 0x3a, 0xe2, 0x19, 0x2d, 0xb4, 0xb1, 0x62, 0x0c, 0xe6, 0x30, 0xa7, 0xd3, 0x84,
0x66, 0x6c, 0x78, 0x30, 0x29, 0x06, 0x06, 0xc6, 0x53, 0x39, 0x84, 0xa8, 0x18, 0x6b, 0xab, 0xc9,
0x86, 0x87, 0x22, 0x07, 0x45, 0x23, 0x9e, 0x45, 0x4b, 0x28, 0x9a, 0x26, 0xcd, 0xbb, 0x42, 0x6b,
0x91, 0x03, 0x65, 0x85, 0xa4, 0x4c, 0x29, 0x6d, 0x99, 0x95, 0x5a, 0x19, 0x4f, 0x37, 0xef, 0x9d,
0x1b, 0x39, 0x65, 0xb9, 0xe4, 0x4e, 0x9f, 0xcb, 0x8f, 0xaf, 0xe4, 0xc8, 0x17, 0x87, 0x5b, 0xf8,
0xf6, 0x2e, 0xd8, 0xbe, 0xfb, 0x4a, 0xe1, 0x70, 0x02, 0xc6, 0x92, 0xfb, 0x38, 0x98, 0xbb, 0x96,
0xbc, 0x81, 0x5a, 0xa8, 0x1d, 0xf4, 0x6b, 0x3f, 0x4e, 0x13, 0x94, 0xd6, 0xfd, 0xf7, 0x1e, 0x0f,
0x3f, 0x23, 0x4c, 0x9e, 0x4b, 0x33, 0x07, 0xcd, 0x82, 0x7c, 0x88, 0x83, 0xb7, 0x3a, 0xe7, 0x30,
0x5e, 0x92, 0x37, 0x4b, 0x72, 0x76, 0x96, 0xd4, 0xb6, 0x77, 0xb6, 0xe2, 0xb4, 0xee, 0xe5, 0x3d,
0x4e, 0x1e, 0xe0, 0xa0, 0x60, 0x02, 0x06, 0x46, 0x1e, 0x43, 0xa3, 0xd2, 0x42, 0xed, 0x6a, 0x1f,
0xff, 0x3c, 0x4d, 0xd6, 0xb6, 0x77, 0x92, 0x38, 0x8e, 0xd3, 0x7a, 0x29, 0xee, 0xcb, 0x63, 0x20,
0x6d, 0x8c, 0x5d, 0xa1, 0xd5, 0x07, 0xa0, 0x1a, 0x55, 0xd7, 0x34, 0x98, 0x9d, 0x25, 0xd7, 0x5c,
0x65, 0xea, 0xba, 0xbc, 0x2e, 0xb5, 0x70, 0x86, 0xf0, 0x9d, 0x73, 0xa6, 0x4c, 0xa1, 0x95, 0x01,
0xf2, 0x0c, 0x5f, 0xf7, 0xc6, 0x4d, 0x03, 0xb5, 0xaa, 0xed, 0x1b, 0xdd, 0xcd, 0x68, 0xf5, 0xfe,
0xa3, 0xf9, 0x3e, 0x16, 0x18, 0x49, 0xf0, 0x2d, 0x05, 0x47, 0x76, 0xf0, 0x87, 0x91, 0xca, 0x45,
0x23, 0xeb, 0x65, 0xc5, 0xab, 0x85, 0x99, 0xee, 0xd7, 0x0a, 0x5e, 0xf7, 0x6d, 0xf6, 0x7d, 0xf4,
0xe4, 0x04, 0xe1, 0xea, 0x2e, 0x58, 0x12, 0x5f, 0x36, 0xfd, 0x62, 0x20, 0xcd, 0x2b, 0xfa, 0x0d,
0xbb, 0x9f, 0xbe, 0x7d, 0x3f, 0xa9, 0x3c, 0x21, 0x8f, 0xe8, 0x88, 0x29, 0x26, 0x80, 0x77, 0xfe,
0x95, 0xbc, 0xa1, 0x1f, 0x7e, 0xc7, 0xfb, 0x91, 0x7c, 0x41, 0xb8, 0x56, 0x2e, 0x8d, 0x74, 0x2f,
0x1b, 0xf2, 0x77, 0xde, 0xcd, 0xde, 0x7f, 0x31, 0x3e, 0x8e, 0x70, 0xd3, 0xb9, 0x6c, 0x91, 0x8d,
0xd5, 0x2e, 0xfb, 0x2f, 0xdf, 0xbc, 0x10, 0xd2, 0xbe, 0x9b, 0x64, 0xd1, 0x50, 0x8f, 0xa8, 0x1f,
0xd4, 0xf1, 0x47, 0x2d, 0x74, 0x47, 0x80, 0x72, 0x17, 0x4c, 0x57, 0x5f, 0xfb, 0xd3, 0xe5, 0x2b,
0x5b, 0x73, 0x40, 0xef, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0x59, 0xd4, 0x32, 0xc6, 0xb3, 0x03,
0x00, 0x00,
}

1331
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/cluster.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

3216
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/cluster_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

945
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/config/host10.pb.go generated vendored Normal file
View File

@ -0,0 +1,945 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/postgresql/v1/config/host10.proto
package postgresql // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/config"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import wrappers "github.com/golang/protobuf/ptypes/wrappers"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type PostgresqlHostConfig10_ConstraintExclusion int32
const (
PostgresqlHostConfig10_CONSTRAINT_EXCLUSION_UNSPECIFIED PostgresqlHostConfig10_ConstraintExclusion = 0
PostgresqlHostConfig10_CONSTRAINT_EXCLUSION_ON PostgresqlHostConfig10_ConstraintExclusion = 1
PostgresqlHostConfig10_CONSTRAINT_EXCLUSION_OFF PostgresqlHostConfig10_ConstraintExclusion = 2
PostgresqlHostConfig10_CONSTRAINT_EXCLUSION_PARTITION PostgresqlHostConfig10_ConstraintExclusion = 3
)
var PostgresqlHostConfig10_ConstraintExclusion_name = map[int32]string{
0: "CONSTRAINT_EXCLUSION_UNSPECIFIED",
1: "CONSTRAINT_EXCLUSION_ON",
2: "CONSTRAINT_EXCLUSION_OFF",
3: "CONSTRAINT_EXCLUSION_PARTITION",
}
var PostgresqlHostConfig10_ConstraintExclusion_value = map[string]int32{
"CONSTRAINT_EXCLUSION_UNSPECIFIED": 0,
"CONSTRAINT_EXCLUSION_ON": 1,
"CONSTRAINT_EXCLUSION_OFF": 2,
"CONSTRAINT_EXCLUSION_PARTITION": 3,
}
func (x PostgresqlHostConfig10_ConstraintExclusion) String() string {
return proto.EnumName(PostgresqlHostConfig10_ConstraintExclusion_name, int32(x))
}
func (PostgresqlHostConfig10_ConstraintExclusion) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host10_c67a1089e8774ac3, []int{0, 0}
}
type PostgresqlHostConfig10_ForceParallelMode int32
const (
PostgresqlHostConfig10_FORCE_PARALLEL_MODE_UNSPECIFIED PostgresqlHostConfig10_ForceParallelMode = 0
PostgresqlHostConfig10_FORCE_PARALLEL_MODE_ON PostgresqlHostConfig10_ForceParallelMode = 1
PostgresqlHostConfig10_FORCE_PARALLEL_MODE_OFF PostgresqlHostConfig10_ForceParallelMode = 2
PostgresqlHostConfig10_FORCE_PARALLEL_MODE_REGRESS PostgresqlHostConfig10_ForceParallelMode = 3
)
var PostgresqlHostConfig10_ForceParallelMode_name = map[int32]string{
0: "FORCE_PARALLEL_MODE_UNSPECIFIED",
1: "FORCE_PARALLEL_MODE_ON",
2: "FORCE_PARALLEL_MODE_OFF",
3: "FORCE_PARALLEL_MODE_REGRESS",
}
var PostgresqlHostConfig10_ForceParallelMode_value = map[string]int32{
"FORCE_PARALLEL_MODE_UNSPECIFIED": 0,
"FORCE_PARALLEL_MODE_ON": 1,
"FORCE_PARALLEL_MODE_OFF": 2,
"FORCE_PARALLEL_MODE_REGRESS": 3,
}
func (x PostgresqlHostConfig10_ForceParallelMode) String() string {
return proto.EnumName(PostgresqlHostConfig10_ForceParallelMode_name, int32(x))
}
func (PostgresqlHostConfig10_ForceParallelMode) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host10_c67a1089e8774ac3, []int{0, 1}
}
type PostgresqlHostConfig10_LogLevel int32
const (
PostgresqlHostConfig10_LOG_LEVEL_UNSPECIFIED PostgresqlHostConfig10_LogLevel = 0
PostgresqlHostConfig10_LOG_LEVEL_DEBUG5 PostgresqlHostConfig10_LogLevel = 1
PostgresqlHostConfig10_LOG_LEVEL_DEBUG4 PostgresqlHostConfig10_LogLevel = 2
PostgresqlHostConfig10_LOG_LEVEL_DEBUG3 PostgresqlHostConfig10_LogLevel = 3
PostgresqlHostConfig10_LOG_LEVEL_DEBUG2 PostgresqlHostConfig10_LogLevel = 4
PostgresqlHostConfig10_LOG_LEVEL_DEBUG1 PostgresqlHostConfig10_LogLevel = 5
PostgresqlHostConfig10_LOG_LEVEL_LOG PostgresqlHostConfig10_LogLevel = 6
PostgresqlHostConfig10_LOG_LEVEL_NOTICE PostgresqlHostConfig10_LogLevel = 7
PostgresqlHostConfig10_LOG_LEVEL_WARNING PostgresqlHostConfig10_LogLevel = 8
PostgresqlHostConfig10_LOG_LEVEL_ERROR PostgresqlHostConfig10_LogLevel = 9
PostgresqlHostConfig10_LOG_LEVEL_FATAL PostgresqlHostConfig10_LogLevel = 10
PostgresqlHostConfig10_LOG_LEVEL_PANIC PostgresqlHostConfig10_LogLevel = 11
)
var PostgresqlHostConfig10_LogLevel_name = map[int32]string{
0: "LOG_LEVEL_UNSPECIFIED",
1: "LOG_LEVEL_DEBUG5",
2: "LOG_LEVEL_DEBUG4",
3: "LOG_LEVEL_DEBUG3",
4: "LOG_LEVEL_DEBUG2",
5: "LOG_LEVEL_DEBUG1",
6: "LOG_LEVEL_LOG",
7: "LOG_LEVEL_NOTICE",
8: "LOG_LEVEL_WARNING",
9: "LOG_LEVEL_ERROR",
10: "LOG_LEVEL_FATAL",
11: "LOG_LEVEL_PANIC",
}
var PostgresqlHostConfig10_LogLevel_value = map[string]int32{
"LOG_LEVEL_UNSPECIFIED": 0,
"LOG_LEVEL_DEBUG5": 1,
"LOG_LEVEL_DEBUG4": 2,
"LOG_LEVEL_DEBUG3": 3,
"LOG_LEVEL_DEBUG2": 4,
"LOG_LEVEL_DEBUG1": 5,
"LOG_LEVEL_LOG": 6,
"LOG_LEVEL_NOTICE": 7,
"LOG_LEVEL_WARNING": 8,
"LOG_LEVEL_ERROR": 9,
"LOG_LEVEL_FATAL": 10,
"LOG_LEVEL_PANIC": 11,
}
func (x PostgresqlHostConfig10_LogLevel) String() string {
return proto.EnumName(PostgresqlHostConfig10_LogLevel_name, int32(x))
}
func (PostgresqlHostConfig10_LogLevel) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host10_c67a1089e8774ac3, []int{0, 2}
}
type PostgresqlHostConfig10_LogErrorVerbosity int32
const (
PostgresqlHostConfig10_LOG_ERROR_VERBOSITY_UNSPECIFIED PostgresqlHostConfig10_LogErrorVerbosity = 0
PostgresqlHostConfig10_LOG_ERROR_VERBOSITY_TERSE PostgresqlHostConfig10_LogErrorVerbosity = 1
PostgresqlHostConfig10_LOG_ERROR_VERBOSITY_DEFAULT PostgresqlHostConfig10_LogErrorVerbosity = 2
PostgresqlHostConfig10_LOG_ERROR_VERBOSITY_VERBOSE PostgresqlHostConfig10_LogErrorVerbosity = 3
)
var PostgresqlHostConfig10_LogErrorVerbosity_name = map[int32]string{
0: "LOG_ERROR_VERBOSITY_UNSPECIFIED",
1: "LOG_ERROR_VERBOSITY_TERSE",
2: "LOG_ERROR_VERBOSITY_DEFAULT",
3: "LOG_ERROR_VERBOSITY_VERBOSE",
}
var PostgresqlHostConfig10_LogErrorVerbosity_value = map[string]int32{
"LOG_ERROR_VERBOSITY_UNSPECIFIED": 0,
"LOG_ERROR_VERBOSITY_TERSE": 1,
"LOG_ERROR_VERBOSITY_DEFAULT": 2,
"LOG_ERROR_VERBOSITY_VERBOSE": 3,
}
func (x PostgresqlHostConfig10_LogErrorVerbosity) String() string {
return proto.EnumName(PostgresqlHostConfig10_LogErrorVerbosity_name, int32(x))
}
func (PostgresqlHostConfig10_LogErrorVerbosity) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host10_c67a1089e8774ac3, []int{0, 3}
}
type PostgresqlHostConfig10_LogStatement int32
const (
PostgresqlHostConfig10_LOG_STATEMENT_UNSPECIFIED PostgresqlHostConfig10_LogStatement = 0
PostgresqlHostConfig10_LOG_STATEMENT_NONE PostgresqlHostConfig10_LogStatement = 1
PostgresqlHostConfig10_LOG_STATEMENT_DDL PostgresqlHostConfig10_LogStatement = 2
PostgresqlHostConfig10_LOG_STATEMENT_MOD PostgresqlHostConfig10_LogStatement = 3
PostgresqlHostConfig10_LOG_STATEMENT_ALL PostgresqlHostConfig10_LogStatement = 4
)
var PostgresqlHostConfig10_LogStatement_name = map[int32]string{
0: "LOG_STATEMENT_UNSPECIFIED",
1: "LOG_STATEMENT_NONE",
2: "LOG_STATEMENT_DDL",
3: "LOG_STATEMENT_MOD",
4: "LOG_STATEMENT_ALL",
}
var PostgresqlHostConfig10_LogStatement_value = map[string]int32{
"LOG_STATEMENT_UNSPECIFIED": 0,
"LOG_STATEMENT_NONE": 1,
"LOG_STATEMENT_DDL": 2,
"LOG_STATEMENT_MOD": 3,
"LOG_STATEMENT_ALL": 4,
}
func (x PostgresqlHostConfig10_LogStatement) String() string {
return proto.EnumName(PostgresqlHostConfig10_LogStatement_name, int32(x))
}
func (PostgresqlHostConfig10_LogStatement) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host10_c67a1089e8774ac3, []int{0, 4}
}
type PostgresqlHostConfig10_TransactionIsolation int32
const (
PostgresqlHostConfig10_TRANSACTION_ISOLATION_UNSPECIFIED PostgresqlHostConfig10_TransactionIsolation = 0
PostgresqlHostConfig10_TRANSACTION_ISOLATION_READ_UNCOMMITTED PostgresqlHostConfig10_TransactionIsolation = 1
PostgresqlHostConfig10_TRANSACTION_ISOLATION_READ_COMMITTED PostgresqlHostConfig10_TransactionIsolation = 2
PostgresqlHostConfig10_TRANSACTION_ISOLATION_REPEATABLE_READ PostgresqlHostConfig10_TransactionIsolation = 3
PostgresqlHostConfig10_TRANSACTION_ISOLATION_SERIALIZABLE PostgresqlHostConfig10_TransactionIsolation = 4
)
var PostgresqlHostConfig10_TransactionIsolation_name = map[int32]string{
0: "TRANSACTION_ISOLATION_UNSPECIFIED",
1: "TRANSACTION_ISOLATION_READ_UNCOMMITTED",
2: "TRANSACTION_ISOLATION_READ_COMMITTED",
3: "TRANSACTION_ISOLATION_REPEATABLE_READ",
4: "TRANSACTION_ISOLATION_SERIALIZABLE",
}
var PostgresqlHostConfig10_TransactionIsolation_value = map[string]int32{
"TRANSACTION_ISOLATION_UNSPECIFIED": 0,
"TRANSACTION_ISOLATION_READ_UNCOMMITTED": 1,
"TRANSACTION_ISOLATION_READ_COMMITTED": 2,
"TRANSACTION_ISOLATION_REPEATABLE_READ": 3,
"TRANSACTION_ISOLATION_SERIALIZABLE": 4,
}
func (x PostgresqlHostConfig10_TransactionIsolation) String() string {
return proto.EnumName(PostgresqlHostConfig10_TransactionIsolation_name, int32(x))
}
func (PostgresqlHostConfig10_TransactionIsolation) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host10_c67a1089e8774ac3, []int{0, 5}
}
type PostgresqlHostConfig10_ByteaOutput int32
const (
PostgresqlHostConfig10_BYTEA_OUTPUT_UNSPECIFIED PostgresqlHostConfig10_ByteaOutput = 0
PostgresqlHostConfig10_BYTEA_OUTPUT_HEX PostgresqlHostConfig10_ByteaOutput = 1
PostgresqlHostConfig10_BYTEA_OUTPUT_ESCAPED PostgresqlHostConfig10_ByteaOutput = 2
)
var PostgresqlHostConfig10_ByteaOutput_name = map[int32]string{
0: "BYTEA_OUTPUT_UNSPECIFIED",
1: "BYTEA_OUTPUT_HEX",
2: "BYTEA_OUTPUT_ESCAPED",
}
var PostgresqlHostConfig10_ByteaOutput_value = map[string]int32{
"BYTEA_OUTPUT_UNSPECIFIED": 0,
"BYTEA_OUTPUT_HEX": 1,
"BYTEA_OUTPUT_ESCAPED": 2,
}
func (x PostgresqlHostConfig10_ByteaOutput) String() string {
return proto.EnumName(PostgresqlHostConfig10_ByteaOutput_name, int32(x))
}
func (PostgresqlHostConfig10_ByteaOutput) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host10_c67a1089e8774ac3, []int{0, 6}
}
type PostgresqlHostConfig10_XmlBinary int32
const (
PostgresqlHostConfig10_XML_BINARY_UNSPECIFIED PostgresqlHostConfig10_XmlBinary = 0
PostgresqlHostConfig10_XML_BINARY_BASE64 PostgresqlHostConfig10_XmlBinary = 1
PostgresqlHostConfig10_XML_BINARY_HEX PostgresqlHostConfig10_XmlBinary = 2
)
var PostgresqlHostConfig10_XmlBinary_name = map[int32]string{
0: "XML_BINARY_UNSPECIFIED",
1: "XML_BINARY_BASE64",
2: "XML_BINARY_HEX",
}
var PostgresqlHostConfig10_XmlBinary_value = map[string]int32{
"XML_BINARY_UNSPECIFIED": 0,
"XML_BINARY_BASE64": 1,
"XML_BINARY_HEX": 2,
}
func (x PostgresqlHostConfig10_XmlBinary) String() string {
return proto.EnumName(PostgresqlHostConfig10_XmlBinary_name, int32(x))
}
func (PostgresqlHostConfig10_XmlBinary) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host10_c67a1089e8774ac3, []int{0, 7}
}
type PostgresqlHostConfig10_XmlOption int32
const (
PostgresqlHostConfig10_XML_OPTION_UNSPECIFIED PostgresqlHostConfig10_XmlOption = 0
PostgresqlHostConfig10_XML_OPTION_DOCUMENT PostgresqlHostConfig10_XmlOption = 1
PostgresqlHostConfig10_XML_OPTION_CONTENT PostgresqlHostConfig10_XmlOption = 2
)
var PostgresqlHostConfig10_XmlOption_name = map[int32]string{
0: "XML_OPTION_UNSPECIFIED",
1: "XML_OPTION_DOCUMENT",
2: "XML_OPTION_CONTENT",
}
var PostgresqlHostConfig10_XmlOption_value = map[string]int32{
"XML_OPTION_UNSPECIFIED": 0,
"XML_OPTION_DOCUMENT": 1,
"XML_OPTION_CONTENT": 2,
}
func (x PostgresqlHostConfig10_XmlOption) String() string {
return proto.EnumName(PostgresqlHostConfig10_XmlOption_name, int32(x))
}
func (PostgresqlHostConfig10_XmlOption) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host10_c67a1089e8774ac3, []int{0, 8}
}
type PostgresqlHostConfig10_BackslashQuote int32
const (
PostgresqlHostConfig10_BACKSLASH_QUOTE_UNSPECIFIED PostgresqlHostConfig10_BackslashQuote = 0
PostgresqlHostConfig10_BACKSLASH_QUOTE PostgresqlHostConfig10_BackslashQuote = 1
PostgresqlHostConfig10_BACKSLASH_QUOTE_ON PostgresqlHostConfig10_BackslashQuote = 2
PostgresqlHostConfig10_BACKSLASH_QUOTE_OFF PostgresqlHostConfig10_BackslashQuote = 3
PostgresqlHostConfig10_BACKSLASH_QUOTE_SAFE_ENCODING PostgresqlHostConfig10_BackslashQuote = 4
)
var PostgresqlHostConfig10_BackslashQuote_name = map[int32]string{
0: "BACKSLASH_QUOTE_UNSPECIFIED",
1: "BACKSLASH_QUOTE",
2: "BACKSLASH_QUOTE_ON",
3: "BACKSLASH_QUOTE_OFF",
4: "BACKSLASH_QUOTE_SAFE_ENCODING",
}
var PostgresqlHostConfig10_BackslashQuote_value = map[string]int32{
"BACKSLASH_QUOTE_UNSPECIFIED": 0,
"BACKSLASH_QUOTE": 1,
"BACKSLASH_QUOTE_ON": 2,
"BACKSLASH_QUOTE_OFF": 3,
"BACKSLASH_QUOTE_SAFE_ENCODING": 4,
}
func (x PostgresqlHostConfig10_BackslashQuote) String() string {
return proto.EnumName(PostgresqlHostConfig10_BackslashQuote_name, int32(x))
}
func (PostgresqlHostConfig10_BackslashQuote) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host10_c67a1089e8774ac3, []int{0, 9}
}
// Options and structure of `PostgresqlHostConfig` reflects PostgreSQL configuration file
// parameters whose detailed description is available in
// [PostgreSQL documentation](https://www.postgresql.org/docs/10/runtime-config.html).
type PostgresqlHostConfig10 struct {
RecoveryMinApplyDelay *wrappers.Int64Value `protobuf:"bytes,1,opt,name=recovery_min_apply_delay,json=recoveryMinApplyDelay,proto3" json:"recovery_min_apply_delay,omitempty"`
SharedBuffers *wrappers.Int64Value `protobuf:"bytes,2,opt,name=shared_buffers,json=sharedBuffers,proto3" json:"shared_buffers,omitempty"`
TempBuffers *wrappers.Int64Value `protobuf:"bytes,3,opt,name=temp_buffers,json=tempBuffers,proto3" json:"temp_buffers,omitempty"`
WorkMem *wrappers.Int64Value `protobuf:"bytes,4,opt,name=work_mem,json=workMem,proto3" json:"work_mem,omitempty"`
ReplacementSortTuples *wrappers.Int64Value `protobuf:"bytes,5,opt,name=replacement_sort_tuples,json=replacementSortTuples,proto3" json:"replacement_sort_tuples,omitempty"`
TempFileLimit *wrappers.Int64Value `protobuf:"bytes,6,opt,name=temp_file_limit,json=tempFileLimit,proto3" json:"temp_file_limit,omitempty"`
BackendFlushAfter *wrappers.Int64Value `protobuf:"bytes,7,opt,name=backend_flush_after,json=backendFlushAfter,proto3" json:"backend_flush_after,omitempty"`
OldSnapshotThreshold *wrappers.Int64Value `protobuf:"bytes,8,opt,name=old_snapshot_threshold,json=oldSnapshotThreshold,proto3" json:"old_snapshot_threshold,omitempty"`
MaxStandbyStreamingDelay *wrappers.Int64Value `protobuf:"bytes,9,opt,name=max_standby_streaming_delay,json=maxStandbyStreamingDelay,proto3" json:"max_standby_streaming_delay,omitempty"`
ConstraintExclusion PostgresqlHostConfig10_ConstraintExclusion `protobuf:"varint,10,opt,name=constraint_exclusion,json=constraintExclusion,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_ConstraintExclusion" json:"constraint_exclusion,omitempty"`
CursorTupleFraction *wrappers.DoubleValue `protobuf:"bytes,11,opt,name=cursor_tuple_fraction,json=cursorTupleFraction,proto3" json:"cursor_tuple_fraction,omitempty"`
FromCollapseLimit *wrappers.Int64Value `protobuf:"bytes,12,opt,name=from_collapse_limit,json=fromCollapseLimit,proto3" json:"from_collapse_limit,omitempty"`
JoinCollapseLimit *wrappers.Int64Value `protobuf:"bytes,13,opt,name=join_collapse_limit,json=joinCollapseLimit,proto3" json:"join_collapse_limit,omitempty"`
ForceParallelMode PostgresqlHostConfig10_ForceParallelMode `protobuf:"varint,14,opt,name=force_parallel_mode,json=forceParallelMode,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_ForceParallelMode" json:"force_parallel_mode,omitempty"`
ClientMinMessages PostgresqlHostConfig10_LogLevel `protobuf:"varint,15,opt,name=client_min_messages,json=clientMinMessages,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_LogLevel" json:"client_min_messages,omitempty"`
LogMinMessages PostgresqlHostConfig10_LogLevel `protobuf:"varint,16,opt,name=log_min_messages,json=logMinMessages,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_LogLevel" json:"log_min_messages,omitempty"`
LogMinErrorStatement PostgresqlHostConfig10_LogLevel `protobuf:"varint,17,opt,name=log_min_error_statement,json=logMinErrorStatement,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_LogLevel" json:"log_min_error_statement,omitempty"`
LogMinDurationStatement *wrappers.Int64Value `protobuf:"bytes,18,opt,name=log_min_duration_statement,json=logMinDurationStatement,proto3" json:"log_min_duration_statement,omitempty"`
LogCheckpoints *wrappers.BoolValue `protobuf:"bytes,19,opt,name=log_checkpoints,json=logCheckpoints,proto3" json:"log_checkpoints,omitempty"`
LogConnections *wrappers.BoolValue `protobuf:"bytes,20,opt,name=log_connections,json=logConnections,proto3" json:"log_connections,omitempty"`
LogDisconnections *wrappers.BoolValue `protobuf:"bytes,21,opt,name=log_disconnections,json=logDisconnections,proto3" json:"log_disconnections,omitempty"`
LogDuration *wrappers.BoolValue `protobuf:"bytes,22,opt,name=log_duration,json=logDuration,proto3" json:"log_duration,omitempty"`
LogErrorVerbosity PostgresqlHostConfig10_LogErrorVerbosity `protobuf:"varint,23,opt,name=log_error_verbosity,json=logErrorVerbosity,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_LogErrorVerbosity" json:"log_error_verbosity,omitempty"`
LogLockWaits *wrappers.BoolValue `protobuf:"bytes,24,opt,name=log_lock_waits,json=logLockWaits,proto3" json:"log_lock_waits,omitempty"`
LogStatement PostgresqlHostConfig10_LogStatement `protobuf:"varint,25,opt,name=log_statement,json=logStatement,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_LogStatement" json:"log_statement,omitempty"`
LogTempFiles *wrappers.Int64Value `protobuf:"bytes,26,opt,name=log_temp_files,json=logTempFiles,proto3" json:"log_temp_files,omitempty"`
SearchPath string `protobuf:"bytes,27,opt,name=search_path,json=searchPath,proto3" json:"search_path,omitempty"`
RowSecurity *wrappers.BoolValue `protobuf:"bytes,28,opt,name=row_security,json=rowSecurity,proto3" json:"row_security,omitempty"`
DefaultTransactionIsolation PostgresqlHostConfig10_TransactionIsolation `protobuf:"varint,29,opt,name=default_transaction_isolation,json=defaultTransactionIsolation,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_TransactionIsolation" json:"default_transaction_isolation,omitempty"`
StatementTimeout *wrappers.Int64Value `protobuf:"bytes,30,opt,name=statement_timeout,json=statementTimeout,proto3" json:"statement_timeout,omitempty"`
LockTimeout *wrappers.Int64Value `protobuf:"bytes,31,opt,name=lock_timeout,json=lockTimeout,proto3" json:"lock_timeout,omitempty"`
IdleInTransactionSessionTimeout *wrappers.Int64Value `protobuf:"bytes,32,opt,name=idle_in_transaction_session_timeout,json=idleInTransactionSessionTimeout,proto3" json:"idle_in_transaction_session_timeout,omitempty"`
ByteaOutput PostgresqlHostConfig10_ByteaOutput `protobuf:"varint,33,opt,name=bytea_output,json=byteaOutput,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_ByteaOutput" json:"bytea_output,omitempty"`
Xmlbinary PostgresqlHostConfig10_XmlBinary `protobuf:"varint,34,opt,name=xmlbinary,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_XmlBinary" json:"xmlbinary,omitempty"`
Xmloption PostgresqlHostConfig10_XmlOption `protobuf:"varint,35,opt,name=xmloption,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_XmlOption" json:"xmloption,omitempty"`
GinPendingListLimit *wrappers.Int64Value `protobuf:"bytes,36,opt,name=gin_pending_list_limit,json=ginPendingListLimit,proto3" json:"gin_pending_list_limit,omitempty"`
DeadlockTimeout *wrappers.Int64Value `protobuf:"bytes,37,opt,name=deadlock_timeout,json=deadlockTimeout,proto3" json:"deadlock_timeout,omitempty"`
MaxLocksPerTransaction *wrappers.Int64Value `protobuf:"bytes,38,opt,name=max_locks_per_transaction,json=maxLocksPerTransaction,proto3" json:"max_locks_per_transaction,omitempty"`
MaxPredLocksPerTransaction *wrappers.Int64Value `protobuf:"bytes,39,opt,name=max_pred_locks_per_transaction,json=maxPredLocksPerTransaction,proto3" json:"max_pred_locks_per_transaction,omitempty"`
ArrayNulls *wrappers.BoolValue `protobuf:"bytes,40,opt,name=array_nulls,json=arrayNulls,proto3" json:"array_nulls,omitempty"`
BackslashQuote PostgresqlHostConfig10_BackslashQuote `protobuf:"varint,41,opt,name=backslash_quote,json=backslashQuote,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_BackslashQuote" json:"backslash_quote,omitempty"`
DefaultWithOids *wrappers.BoolValue `protobuf:"bytes,42,opt,name=default_with_oids,json=defaultWithOids,proto3" json:"default_with_oids,omitempty"`
EscapeStringWarning *wrappers.BoolValue `protobuf:"bytes,43,opt,name=escape_string_warning,json=escapeStringWarning,proto3" json:"escape_string_warning,omitempty"`
LoCompatPrivileges *wrappers.BoolValue `protobuf:"bytes,44,opt,name=lo_compat_privileges,json=loCompatPrivileges,proto3" json:"lo_compat_privileges,omitempty"`
OperatorPrecedenceWarning *wrappers.BoolValue `protobuf:"bytes,45,opt,name=operator_precedence_warning,json=operatorPrecedenceWarning,proto3" json:"operator_precedence_warning,omitempty"`
QuoteAllIdentifiers *wrappers.BoolValue `protobuf:"bytes,46,opt,name=quote_all_identifiers,json=quoteAllIdentifiers,proto3" json:"quote_all_identifiers,omitempty"`
StandardConformingStrings *wrappers.BoolValue `protobuf:"bytes,47,opt,name=standard_conforming_strings,json=standardConformingStrings,proto3" json:"standard_conforming_strings,omitempty"`
SynchronizeSeqscans *wrappers.BoolValue `protobuf:"bytes,48,opt,name=synchronize_seqscans,json=synchronizeSeqscans,proto3" json:"synchronize_seqscans,omitempty"`
TransformNullEquals *wrappers.BoolValue `protobuf:"bytes,49,opt,name=transform_null_equals,json=transformNullEquals,proto3" json:"transform_null_equals,omitempty"`
ExitOnError *wrappers.BoolValue `protobuf:"bytes,50,opt,name=exit_on_error,json=exitOnError,proto3" json:"exit_on_error,omitempty"`
SeqPageCost *wrappers.DoubleValue `protobuf:"bytes,51,opt,name=seq_page_cost,json=seqPageCost,proto3" json:"seq_page_cost,omitempty"`
RandomPageCost *wrappers.DoubleValue `protobuf:"bytes,52,opt,name=random_page_cost,json=randomPageCost,proto3" json:"random_page_cost,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PostgresqlHostConfig10) Reset() { *m = PostgresqlHostConfig10{} }
func (m *PostgresqlHostConfig10) String() string { return proto.CompactTextString(m) }
func (*PostgresqlHostConfig10) ProtoMessage() {}
func (*PostgresqlHostConfig10) Descriptor() ([]byte, []int) {
return fileDescriptor_host10_c67a1089e8774ac3, []int{0}
}
func (m *PostgresqlHostConfig10) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PostgresqlHostConfig10.Unmarshal(m, b)
}
func (m *PostgresqlHostConfig10) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PostgresqlHostConfig10.Marshal(b, m, deterministic)
}
func (dst *PostgresqlHostConfig10) XXX_Merge(src proto.Message) {
xxx_messageInfo_PostgresqlHostConfig10.Merge(dst, src)
}
func (m *PostgresqlHostConfig10) XXX_Size() int {
return xxx_messageInfo_PostgresqlHostConfig10.Size(m)
}
func (m *PostgresqlHostConfig10) XXX_DiscardUnknown() {
xxx_messageInfo_PostgresqlHostConfig10.DiscardUnknown(m)
}
var xxx_messageInfo_PostgresqlHostConfig10 proto.InternalMessageInfo
func (m *PostgresqlHostConfig10) GetRecoveryMinApplyDelay() *wrappers.Int64Value {
if m != nil {
return m.RecoveryMinApplyDelay
}
return nil
}
func (m *PostgresqlHostConfig10) GetSharedBuffers() *wrappers.Int64Value {
if m != nil {
return m.SharedBuffers
}
return nil
}
func (m *PostgresqlHostConfig10) GetTempBuffers() *wrappers.Int64Value {
if m != nil {
return m.TempBuffers
}
return nil
}
func (m *PostgresqlHostConfig10) GetWorkMem() *wrappers.Int64Value {
if m != nil {
return m.WorkMem
}
return nil
}
func (m *PostgresqlHostConfig10) GetReplacementSortTuples() *wrappers.Int64Value {
if m != nil {
return m.ReplacementSortTuples
}
return nil
}
func (m *PostgresqlHostConfig10) GetTempFileLimit() *wrappers.Int64Value {
if m != nil {
return m.TempFileLimit
}
return nil
}
func (m *PostgresqlHostConfig10) GetBackendFlushAfter() *wrappers.Int64Value {
if m != nil {
return m.BackendFlushAfter
}
return nil
}
func (m *PostgresqlHostConfig10) GetOldSnapshotThreshold() *wrappers.Int64Value {
if m != nil {
return m.OldSnapshotThreshold
}
return nil
}
func (m *PostgresqlHostConfig10) GetMaxStandbyStreamingDelay() *wrappers.Int64Value {
if m != nil {
return m.MaxStandbyStreamingDelay
}
return nil
}
func (m *PostgresqlHostConfig10) GetConstraintExclusion() PostgresqlHostConfig10_ConstraintExclusion {
if m != nil {
return m.ConstraintExclusion
}
return PostgresqlHostConfig10_CONSTRAINT_EXCLUSION_UNSPECIFIED
}
func (m *PostgresqlHostConfig10) GetCursorTupleFraction() *wrappers.DoubleValue {
if m != nil {
return m.CursorTupleFraction
}
return nil
}
func (m *PostgresqlHostConfig10) GetFromCollapseLimit() *wrappers.Int64Value {
if m != nil {
return m.FromCollapseLimit
}
return nil
}
func (m *PostgresqlHostConfig10) GetJoinCollapseLimit() *wrappers.Int64Value {
if m != nil {
return m.JoinCollapseLimit
}
return nil
}
func (m *PostgresqlHostConfig10) GetForceParallelMode() PostgresqlHostConfig10_ForceParallelMode {
if m != nil {
return m.ForceParallelMode
}
return PostgresqlHostConfig10_FORCE_PARALLEL_MODE_UNSPECIFIED
}
func (m *PostgresqlHostConfig10) GetClientMinMessages() PostgresqlHostConfig10_LogLevel {
if m != nil {
return m.ClientMinMessages
}
return PostgresqlHostConfig10_LOG_LEVEL_UNSPECIFIED
}
func (m *PostgresqlHostConfig10) GetLogMinMessages() PostgresqlHostConfig10_LogLevel {
if m != nil {
return m.LogMinMessages
}
return PostgresqlHostConfig10_LOG_LEVEL_UNSPECIFIED
}
func (m *PostgresqlHostConfig10) GetLogMinErrorStatement() PostgresqlHostConfig10_LogLevel {
if m != nil {
return m.LogMinErrorStatement
}
return PostgresqlHostConfig10_LOG_LEVEL_UNSPECIFIED
}
func (m *PostgresqlHostConfig10) GetLogMinDurationStatement() *wrappers.Int64Value {
if m != nil {
return m.LogMinDurationStatement
}
return nil
}
func (m *PostgresqlHostConfig10) GetLogCheckpoints() *wrappers.BoolValue {
if m != nil {
return m.LogCheckpoints
}
return nil
}
func (m *PostgresqlHostConfig10) GetLogConnections() *wrappers.BoolValue {
if m != nil {
return m.LogConnections
}
return nil
}
func (m *PostgresqlHostConfig10) GetLogDisconnections() *wrappers.BoolValue {
if m != nil {
return m.LogDisconnections
}
return nil
}
func (m *PostgresqlHostConfig10) GetLogDuration() *wrappers.BoolValue {
if m != nil {
return m.LogDuration
}
return nil
}
func (m *PostgresqlHostConfig10) GetLogErrorVerbosity() PostgresqlHostConfig10_LogErrorVerbosity {
if m != nil {
return m.LogErrorVerbosity
}
return PostgresqlHostConfig10_LOG_ERROR_VERBOSITY_UNSPECIFIED
}
func (m *PostgresqlHostConfig10) GetLogLockWaits() *wrappers.BoolValue {
if m != nil {
return m.LogLockWaits
}
return nil
}
func (m *PostgresqlHostConfig10) GetLogStatement() PostgresqlHostConfig10_LogStatement {
if m != nil {
return m.LogStatement
}
return PostgresqlHostConfig10_LOG_STATEMENT_UNSPECIFIED
}
func (m *PostgresqlHostConfig10) GetLogTempFiles() *wrappers.Int64Value {
if m != nil {
return m.LogTempFiles
}
return nil
}
func (m *PostgresqlHostConfig10) GetSearchPath() string {
if m != nil {
return m.SearchPath
}
return ""
}
func (m *PostgresqlHostConfig10) GetRowSecurity() *wrappers.BoolValue {
if m != nil {
return m.RowSecurity
}
return nil
}
func (m *PostgresqlHostConfig10) GetDefaultTransactionIsolation() PostgresqlHostConfig10_TransactionIsolation {
if m != nil {
return m.DefaultTransactionIsolation
}
return PostgresqlHostConfig10_TRANSACTION_ISOLATION_UNSPECIFIED
}
func (m *PostgresqlHostConfig10) GetStatementTimeout() *wrappers.Int64Value {
if m != nil {
return m.StatementTimeout
}
return nil
}
func (m *PostgresqlHostConfig10) GetLockTimeout() *wrappers.Int64Value {
if m != nil {
return m.LockTimeout
}
return nil
}
func (m *PostgresqlHostConfig10) GetIdleInTransactionSessionTimeout() *wrappers.Int64Value {
if m != nil {
return m.IdleInTransactionSessionTimeout
}
return nil
}
func (m *PostgresqlHostConfig10) GetByteaOutput() PostgresqlHostConfig10_ByteaOutput {
if m != nil {
return m.ByteaOutput
}
return PostgresqlHostConfig10_BYTEA_OUTPUT_UNSPECIFIED
}
func (m *PostgresqlHostConfig10) GetXmlbinary() PostgresqlHostConfig10_XmlBinary {
if m != nil {
return m.Xmlbinary
}
return PostgresqlHostConfig10_XML_BINARY_UNSPECIFIED
}
func (m *PostgresqlHostConfig10) GetXmloption() PostgresqlHostConfig10_XmlOption {
if m != nil {
return m.Xmloption
}
return PostgresqlHostConfig10_XML_OPTION_UNSPECIFIED
}
func (m *PostgresqlHostConfig10) GetGinPendingListLimit() *wrappers.Int64Value {
if m != nil {
return m.GinPendingListLimit
}
return nil
}
func (m *PostgresqlHostConfig10) GetDeadlockTimeout() *wrappers.Int64Value {
if m != nil {
return m.DeadlockTimeout
}
return nil
}
func (m *PostgresqlHostConfig10) GetMaxLocksPerTransaction() *wrappers.Int64Value {
if m != nil {
return m.MaxLocksPerTransaction
}
return nil
}
func (m *PostgresqlHostConfig10) GetMaxPredLocksPerTransaction() *wrappers.Int64Value {
if m != nil {
return m.MaxPredLocksPerTransaction
}
return nil
}
func (m *PostgresqlHostConfig10) GetArrayNulls() *wrappers.BoolValue {
if m != nil {
return m.ArrayNulls
}
return nil
}
func (m *PostgresqlHostConfig10) GetBackslashQuote() PostgresqlHostConfig10_BackslashQuote {
if m != nil {
return m.BackslashQuote
}
return PostgresqlHostConfig10_BACKSLASH_QUOTE_UNSPECIFIED
}
func (m *PostgresqlHostConfig10) GetDefaultWithOids() *wrappers.BoolValue {
if m != nil {
return m.DefaultWithOids
}
return nil
}
func (m *PostgresqlHostConfig10) GetEscapeStringWarning() *wrappers.BoolValue {
if m != nil {
return m.EscapeStringWarning
}
return nil
}
func (m *PostgresqlHostConfig10) GetLoCompatPrivileges() *wrappers.BoolValue {
if m != nil {
return m.LoCompatPrivileges
}
return nil
}
func (m *PostgresqlHostConfig10) GetOperatorPrecedenceWarning() *wrappers.BoolValue {
if m != nil {
return m.OperatorPrecedenceWarning
}
return nil
}
func (m *PostgresqlHostConfig10) GetQuoteAllIdentifiers() *wrappers.BoolValue {
if m != nil {
return m.QuoteAllIdentifiers
}
return nil
}
func (m *PostgresqlHostConfig10) GetStandardConformingStrings() *wrappers.BoolValue {
if m != nil {
return m.StandardConformingStrings
}
return nil
}
func (m *PostgresqlHostConfig10) GetSynchronizeSeqscans() *wrappers.BoolValue {
if m != nil {
return m.SynchronizeSeqscans
}
return nil
}
func (m *PostgresqlHostConfig10) GetTransformNullEquals() *wrappers.BoolValue {
if m != nil {
return m.TransformNullEquals
}
return nil
}
func (m *PostgresqlHostConfig10) GetExitOnError() *wrappers.BoolValue {
if m != nil {
return m.ExitOnError
}
return nil
}
func (m *PostgresqlHostConfig10) GetSeqPageCost() *wrappers.DoubleValue {
if m != nil {
return m.SeqPageCost
}
return nil
}
func (m *PostgresqlHostConfig10) GetRandomPageCost() *wrappers.DoubleValue {
if m != nil {
return m.RandomPageCost
}
return nil
}
func init() {
proto.RegisterType((*PostgresqlHostConfig10)(nil), "yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10")
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_ConstraintExclusion", PostgresqlHostConfig10_ConstraintExclusion_name, PostgresqlHostConfig10_ConstraintExclusion_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_ForceParallelMode", PostgresqlHostConfig10_ForceParallelMode_name, PostgresqlHostConfig10_ForceParallelMode_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_LogLevel", PostgresqlHostConfig10_LogLevel_name, PostgresqlHostConfig10_LogLevel_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_LogErrorVerbosity", PostgresqlHostConfig10_LogErrorVerbosity_name, PostgresqlHostConfig10_LogErrorVerbosity_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_LogStatement", PostgresqlHostConfig10_LogStatement_name, PostgresqlHostConfig10_LogStatement_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_TransactionIsolation", PostgresqlHostConfig10_TransactionIsolation_name, PostgresqlHostConfig10_TransactionIsolation_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_ByteaOutput", PostgresqlHostConfig10_ByteaOutput_name, PostgresqlHostConfig10_ByteaOutput_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_XmlBinary", PostgresqlHostConfig10_XmlBinary_name, PostgresqlHostConfig10_XmlBinary_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_XmlOption", PostgresqlHostConfig10_XmlOption_name, PostgresqlHostConfig10_XmlOption_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig10_BackslashQuote", PostgresqlHostConfig10_BackslashQuote_name, PostgresqlHostConfig10_BackslashQuote_value)
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/postgresql/v1/config/host10.proto", fileDescriptor_host10_c67a1089e8774ac3)
}
var fileDescriptor_host10_c67a1089e8774ac3 = []byte{
// 2210 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x99, 0xdb, 0x6f, 0xdb, 0xc8,
0xf5, 0xc7, 0x7f, 0xb2, 0xb3, 0xd9, 0x64, 0x7c, 0xa3, 0x46, 0xbe, 0x30, 0xf6, 0xe6, 0xb2, 0xda,
0x4d, 0x7e, 0xd9, 0x6d, 0x2d, 0x59, 0x8e, 0x9b, 0x0d, 0xb0, 0xe8, 0x62, 0x29, 0x89, 0x72, 0xd4,
0x52, 0xa2, 0x42, 0xd2, 0x8e, 0x37, 0xc5, 0x62, 0x30, 0x22, 0x47, 0x12, 0x9b, 0x21, 0x87, 0xe6,
0x50, 0xbe, 0x14, 0x28, 0xfa, 0xd2, 0xa7, 0x3e, 0xf6, 0xa1, 0x40, 0xfb, 0x0f, 0x05, 0xfd, 0x47,
0xfa, 0x47, 0xe4, 0xa9, 0x18, 0x52, 0xd4, 0xc5, 0x56, 0x4b, 0xa3, 0xce, 0x5b, 0x74, 0xe6, 0x7c,
0x3f, 0xe7, 0x70, 0xce, 0x19, 0xf2, 0x4c, 0x0c, 0xf6, 0x2f, 0xb1, 0xef, 0x90, 0x8b, 0xb2, 0x4d,
0xd9, 0xd0, 0x29, 0x7b, 0x4e, 0xb7, 0x1c, 0x30, 0x1e, 0xf5, 0x43, 0xc2, 0x4f, 0x69, 0xf9, 0xac,
0x52, 0xb6, 0x99, 0xdf, 0x73, 0xfb, 0xe5, 0x01, 0xe3, 0x51, 0x65, 0xaf, 0x14, 0x84, 0x2c, 0x62,
0xf0, 0x69, 0xa2, 0x29, 0xc5, 0x9a, 0x92, 0xe7, 0x74, 0x4b, 0x13, 0x4d, 0xe9, 0xac, 0x52, 0x4a,
0x34, 0xdb, 0x8f, 0xfa, 0x8c, 0xf5, 0x29, 0x29, 0xc7, 0xa2, 0xee, 0xb0, 0x57, 0x3e, 0x0f, 0x71,
0x10, 0x90, 0x90, 0x27, 0x98, 0xed, 0x87, 0x33, 0xa1, 0xcf, 0x30, 0x75, 0x1d, 0x1c, 0xb9, 0xcc,
0x4f, 0x96, 0x8b, 0xff, 0x2c, 0x83, 0xcd, 0xce, 0x98, 0xfb, 0x9a, 0xf1, 0xa8, 0x16, 0x73, 0x2b,
0x7b, 0xd0, 0x02, 0x72, 0x48, 0x6c, 0x76, 0x46, 0xc2, 0x4b, 0xe4, 0xb9, 0x3e, 0xc2, 0x41, 0x40,
0x2f, 0x91, 0x43, 0x28, 0xbe, 0x94, 0x73, 0x4f, 0x72, 0xcf, 0x97, 0xf6, 0x77, 0x4a, 0x49, 0xf0,
0x52, 0x1a, 0xbc, 0xd4, 0xf4, 0xa3, 0x97, 0x07, 0xc7, 0x98, 0x0e, 0x89, 0xb1, 0x91, 0x8a, 0x5b,
0xae, 0xaf, 0x08, 0x69, 0x5d, 0x28, 0x61, 0x15, 0xac, 0xf2, 0x01, 0x0e, 0x89, 0x83, 0xba, 0xc3,
0x5e, 0x8f, 0x84, 0x5c, 0x5e, 0xc8, 0x66, 0xad, 0x24, 0x92, 0x6a, 0xa2, 0x80, 0x3f, 0x80, 0xe5,
0x88, 0x78, 0xc1, 0x98, 0xb0, 0x98, 0x4d, 0x58, 0x12, 0x82, 0x54, 0xff, 0x12, 0xdc, 0x3b, 0x67,
0xe1, 0x7b, 0xe4, 0x11, 0x4f, 0xbe, 0x93, 0xad, 0xfd, 0x5c, 0x38, 0xb7, 0x88, 0x07, 0x4d, 0xb0,
0x15, 0x92, 0x80, 0x62, 0x9b, 0x78, 0xc4, 0x8f, 0x10, 0x67, 0x61, 0x84, 0xa2, 0x61, 0x40, 0x09,
0x97, 0x3f, 0xbb, 0xd1, 0x86, 0x8c, 0xb5, 0x26, 0x0b, 0x23, 0x2b, 0x56, 0xc2, 0x1a, 0x58, 0x8b,
0x1f, 0xa6, 0xe7, 0x52, 0x82, 0xa8, 0xeb, 0xb9, 0x91, 0x7c, 0xf7, 0x06, 0x3b, 0x22, 0x34, 0x0d,
0x97, 0x12, 0x4d, 0x28, 0xe0, 0x5b, 0x50, 0xe8, 0x62, 0xfb, 0x3d, 0xf1, 0x1d, 0xd4, 0xa3, 0x43,
0x3e, 0x40, 0xb8, 0x17, 0x91, 0x50, 0xfe, 0x3c, 0x13, 0x54, 0x05, 0x1f, 0x3f, 0x54, 0xee, 0xee,
0xed, 0xee, 0xef, 0x1d, 0xbc, 0x32, 0xf2, 0x23, 0x46, 0x43, 0x20, 0x14, 0x41, 0x80, 0x08, 0x6c,
0x32, 0xea, 0x20, 0xee, 0xe3, 0x80, 0x0f, 0x58, 0x84, 0xa2, 0x41, 0x48, 0xf8, 0x80, 0x51, 0x47,
0xbe, 0x97, 0xcd, 0x5e, 0xfe, 0xf8, 0xa1, 0x72, 0x6f, 0xb7, 0xb2, 0xfb, 0xea, 0xe5, 0xc1, 0xde,
0x9e, 0xb1, 0xce, 0xa8, 0x63, 0x8e, 0x38, 0x56, 0x8a, 0x81, 0xef, 0xc0, 0x8e, 0x87, 0x2f, 0x10,
0x8f, 0xb0, 0xef, 0x74, 0x2f, 0x11, 0x8f, 0x42, 0x82, 0x3d, 0xd7, 0xef, 0x8f, 0x1a, 0xed, 0x7e,
0xf6, 0x56, 0xc8, 0x1e, 0xbe, 0x30, 0x13, 0xb9, 0x99, 0xaa, 0x93, 0x5e, 0xfb, 0x73, 0x0e, 0xac,
0xdb, 0xcc, 0xe7, 0x51, 0x88, 0x5d, 0x3f, 0x42, 0xe4, 0xc2, 0xa6, 0x43, 0xee, 0x32, 0x5f, 0x06,
0x4f, 0x72, 0xcf, 0x57, 0xf7, 0xdf, 0x94, 0x6e, 0x74, 0xc4, 0x4a, 0xf3, 0xcf, 0x47, 0xa9, 0x36,
0x26, 0xab, 0x29, 0xd8, 0x28, 0xd8, 0xd7, 0x8d, 0xb0, 0x03, 0x36, 0xec, 0x61, 0xc8, 0x59, 0x98,
0x34, 0x0b, 0xea, 0x85, 0xd8, 0x16, 0x47, 0x50, 0x5e, 0x8a, 0x1f, 0xee, 0x8b, 0x6b, 0x0f, 0x57,
0x67, 0xc3, 0x2e, 0x25, 0xc9, 0xd3, 0x15, 0x12, 0x69, 0xdc, 0x2c, 0x8d, 0x91, 0x10, 0xfe, 0x0c,
0x0a, 0xbd, 0x90, 0x79, 0xc8, 0x66, 0x94, 0xe2, 0x80, 0xa7, 0x7d, 0xb3, 0x9c, 0x5d, 0x12, 0xe9,
0xe3, 0x87, 0xca, 0x72, 0x65, 0x77, 0xbf, 0x72, 0xf0, 0xdd, 0xc1, 0xab, 0x17, 0x2f, 0x0f, 0xbe,
0x33, 0xf2, 0x82, 0x54, 0x1b, 0x81, 0x92, 0x6e, 0xfa, 0x19, 0x14, 0x7e, 0xcf, 0x5c, 0xff, 0x2a,
0x7e, 0xe5, 0x7f, 0xc2, 0x0b, 0xd2, 0x2c, 0xfe, 0x4f, 0xa0, 0xd0, 0x63, 0xa1, 0x4d, 0x50, 0x80,
0x43, 0x4c, 0x29, 0xa1, 0xc8, 0x63, 0x0e, 0x91, 0x57, 0xe3, 0xa2, 0xe8, 0xb7, 0x2b, 0x4a, 0x43,
0x80, 0x3b, 0x23, 0x6e, 0x8b, 0x39, 0xc4, 0xc8, 0xf7, 0xae, 0x9a, 0xe0, 0x19, 0x28, 0xd8, 0xd4,
0x15, 0x47, 0x58, 0xbc, 0xd7, 0x3c, 0xc2, 0x39, 0xee, 0x13, 0x2e, 0xaf, 0xc5, 0x09, 0x34, 0x6e,
0x97, 0x80, 0xc6, 0xfa, 0x1a, 0x39, 0x23, 0xd4, 0xc8, 0x27, 0x21, 0x5a, 0xae, 0xdf, 0x1a, 0x05,
0x80, 0x01, 0x90, 0x28, 0xeb, 0xcf, 0x06, 0x95, 0x3e, 0x69, 0xd0, 0x55, 0xca, 0xfa, 0xd3, 0x11,
0xff, 0x08, 0xb6, 0xd2, 0x88, 0x24, 0x0c, 0x59, 0x28, 0xce, 0x59, 0x14, 0xbf, 0x81, 0xe4, 0xfc,
0x27, 0x0d, 0xbc, 0x9e, 0x04, 0x56, 0x45, 0x10, 0x33, 0x8d, 0x01, 0x4f, 0xc0, 0x76, 0x1a, 0xde,
0x19, 0x86, 0xf1, 0x77, 0x67, 0x2a, 0x03, 0x98, 0x7d, 0xb6, 0xb7, 0x12, 0x6c, 0x7d, 0x24, 0x9e,
0x90, 0x6b, 0x60, 0x4d, 0x90, 0xed, 0x01, 0xb1, 0xdf, 0x07, 0xcc, 0xf5, 0x23, 0x2e, 0x17, 0x62,
0xdc, 0xf6, 0x35, 0x5c, 0x95, 0x31, 0x9a, 0xd0, 0xc4, 0xee, 0xd4, 0x26, 0x8a, 0x31, 0x84, 0xf9,
0x3e, 0x89, 0x0f, 0x16, 0x97, 0xd7, 0x6f, 0x06, 0x99, 0x28, 0x60, 0x13, 0x40, 0x01, 0x71, 0x5c,
0x3e, 0xcd, 0xd9, 0xc8, 0xe4, 0xe4, 0x29, 0xeb, 0xd7, 0x67, 0x44, 0xf0, 0xd7, 0x60, 0x39, 0x46,
0x8d, 0x9e, 0x56, 0xde, 0xcc, 0x84, 0x2c, 0x09, 0xc8, 0xc8, 0x5d, 0x9c, 0x2b, 0x21, 0x4f, 0x0a,
0x7d, 0x46, 0xc2, 0x2e, 0xe3, 0x6e, 0x74, 0x29, 0x6f, 0x7d, 0x8a, 0x73, 0xa5, 0xb1, 0x7e, 0x5c,
0xdb, 0xe3, 0x14, 0x1b, 0xe7, 0x3f, 0x6b, 0x82, 0x3f, 0x02, 0xb1, 0x39, 0x88, 0x32, 0xfb, 0x3d,
0x3a, 0xc7, 0x6e, 0xc4, 0x65, 0x39, 0xf3, 0x09, 0xc4, 0x13, 0x6b, 0xcc, 0x7e, 0xff, 0x56, 0xf8,
0x43, 0x06, 0x56, 0x04, 0x61, 0xd2, 0x23, 0x0f, 0xe2, 0xe4, 0x7f, 0x73, 0xeb, 0xe4, 0xc7, 0x9d,
0x13, 0x07, 0x9c, 0xf4, 0x91, 0x92, 0xa4, 0x3c, 0xfe, 0x02, 0x73, 0x79, 0x3b, 0xbb, 0x2b, 0x05,
0xc2, 0x1a, 0x7d, 0x7f, 0x39, 0x7c, 0x0c, 0x96, 0x38, 0xc1, 0xa1, 0x3d, 0x40, 0x01, 0x8e, 0x06,
0xf2, 0xce, 0x93, 0xdc, 0xf3, 0xfb, 0x06, 0x48, 0x4c, 0x1d, 0x1c, 0x0d, 0x44, 0x59, 0x43, 0x76,
0x8e, 0x38, 0xb1, 0x87, 0xa1, 0x28, 0xc8, 0x17, 0xd9, 0x65, 0x0d, 0xd9, 0xb9, 0x39, 0x72, 0x87,
0x7f, 0xcb, 0x81, 0x87, 0x0e, 0xe9, 0xe1, 0x21, 0x8d, 0x50, 0x14, 0x62, 0x9f, 0x27, 0x1f, 0x01,
0xe4, 0x72, 0x46, 0x93, 0x3e, 0x79, 0x18, 0x6f, 0x92, 0x71, 0xbb, 0x4d, 0xb2, 0x26, 0xe8, 0x66,
0x4a, 0x36, 0x76, 0x46, 0x81, 0xe7, 0x2d, 0xc2, 0xd7, 0x20, 0x3f, 0x2e, 0x14, 0x8a, 0x5c, 0x8f,
0xb0, 0x61, 0x24, 0x3f, 0xca, 0xde, 0x3e, 0x69, 0xac, 0xb2, 0x12, 0x91, 0x18, 0xe8, 0xe2, 0xa6,
0x49, 0x21, 0x8f, 0x6f, 0x30, 0xd0, 0x09, 0x41, 0xaa, 0x77, 0xc1, 0x57, 0xae, 0x43, 0x09, 0x72,
0xfd, 0x99, 0x1d, 0xe2, 0x84, 0x8b, 0x0f, 0xf0, 0x18, 0xfb, 0x24, 0x1b, 0xfb, 0x58, 0x70, 0x9a,
0xfe, 0xd4, 0xf3, 0x9a, 0x09, 0x24, 0x0d, 0x45, 0xc1, 0x72, 0xf7, 0x32, 0x22, 0x18, 0xb1, 0x61,
0x14, 0x0c, 0x23, 0xf9, 0xcb, 0x78, 0xef, 0x9b, 0xb7, 0xdb, 0xfb, 0xaa, 0x20, 0xea, 0x31, 0xd0,
0x58, 0xea, 0x4e, 0x7e, 0x40, 0x02, 0xee, 0x5f, 0x78, 0xb4, 0xeb, 0xfa, 0x38, 0xbc, 0x94, 0x8b,
0x71, 0xa8, 0xc3, 0xdb, 0x85, 0x3a, 0xf1, 0x68, 0x35, 0xc6, 0x19, 0x13, 0xf2, 0x28, 0x0c, 0x0b,
0xe2, 0x6e, 0xfa, 0xea, 0x13, 0x85, 0xd1, 0x63, 0x9c, 0x31, 0x21, 0xc3, 0x0e, 0xd8, 0xec, 0xbb,
0x3e, 0x0a, 0x88, 0xef, 0x88, 0x09, 0x8f, 0xba, 0x3c, 0x1a, 0x8d, 0x16, 0x5f, 0x67, 0x57, 0xa6,
0xd0, 0x77, 0xfd, 0x4e, 0xa2, 0xd4, 0x5c, 0x1e, 0x25, 0xa3, 0x44, 0x03, 0x48, 0x0e, 0xc1, 0xce,
0x4c, 0xf3, 0x3c, 0xcd, 0x66, 0xad, 0xa5, 0xa2, 0xb4, 0xaa, 0xc7, 0xe0, 0x81, 0x98, 0x42, 0x85,
0x89, 0xa3, 0x80, 0x84, 0xd3, 0x6d, 0x24, 0x3f, 0xcb, 0x06, 0x6e, 0x7a, 0xf8, 0x42, 0xbc, 0xc5,
0x78, 0x87, 0x84, 0x53, 0xbd, 0x03, 0x11, 0x78, 0x24, 0xb8, 0x81, 0xb8, 0xef, 0xcc, 0x87, 0xff,
0x7f, 0x36, 0x7c, 0xdb, 0xc3, 0x17, 0x9d, 0x90, 0x38, 0xf3, 0x02, 0x7c, 0x0f, 0x96, 0x70, 0x18,
0xe2, 0x4b, 0xe4, 0x0f, 0x29, 0xe5, 0xf2, 0xf3, 0xcc, 0x57, 0x0b, 0x88, 0xdd, 0xdb, 0xc2, 0x1b,
0x0e, 0xc1, 0x9a, 0x98, 0xf8, 0x39, 0xc5, 0x7c, 0x80, 0x4e, 0x87, 0x2c, 0x22, 0xf2, 0x37, 0x71,
0xf1, 0xb5, 0x5b, 0xb6, 0x73, 0x0a, 0x7d, 0x23, 0x98, 0xc6, 0x6a, 0x77, 0xe6, 0x37, 0x6c, 0x80,
0x7c, 0xfa, 0x3e, 0x3b, 0x77, 0xa3, 0x01, 0x62, 0xae, 0xc3, 0xe5, 0x6f, 0x33, 0x33, 0x5f, 0x1b,
0x89, 0xde, 0xba, 0xd1, 0x40, 0x77, 0x1d, 0x0e, 0xdb, 0x60, 0x83, 0x70, 0x1b, 0x07, 0x44, 0xdc,
0x1a, 0x44, 0x43, 0x9d, 0xe3, 0xd0, 0x77, 0xfd, 0xbe, 0xfc, 0x8b, 0x4c, 0x56, 0x21, 0x11, 0x9a,
0xb1, 0xee, 0x6d, 0x22, 0x83, 0x1a, 0x58, 0xa7, 0x0c, 0xd9, 0xcc, 0x0b, 0x70, 0x84, 0x82, 0xd0,
0x3d, 0x73, 0x29, 0x11, 0x23, 0xda, 0x2f, 0x33, 0x71, 0x90, 0xb2, 0x5a, 0x2c, 0xeb, 0x8c, 0x55,
0xe2, 0x62, 0xc3, 0x02, 0x12, 0xe2, 0x88, 0x85, 0xa2, 0xfe, 0x36, 0x71, 0x88, 0x6f, 0x93, 0x71,
0x8e, 0xbb, 0x99, 0xd0, 0x07, 0xa9, 0xbc, 0x33, 0x56, 0xa7, 0x99, 0xb6, 0xc1, 0x46, 0x5c, 0x2e,
0x84, 0x29, 0x45, 0xae, 0x43, 0xfc, 0xc8, 0xed, 0xb9, 0xe2, 0x26, 0x5c, 0xca, 0x7e, 0xf2, 0x58,
0xa8, 0x50, 0xda, 0x9c, 0xc8, 0x44, 0xae, 0xf1, 0x05, 0x0c, 0x87, 0x8e, 0x98, 0x86, 0x7a, 0x2c,
0x8c, 0xaf, 0x60, 0xc9, 0xb6, 0x72, 0xb9, 0x9c, 0x9d, 0x6b, 0x2a, 0xaf, 0x8d, 0xd5, 0xc9, 0xde,
0x72, 0xd8, 0x02, 0xeb, 0xfc, 0xd2, 0xb7, 0x07, 0x21, 0xf3, 0xdd, 0x3f, 0x10, 0xc4, 0xc9, 0x29,
0xb7, 0xb1, 0xcf, 0xe5, 0xbd, 0xec, 0x54, 0xa7, 0x74, 0xe6, 0x48, 0x26, 0x1e, 0x3d, 0x3e, 0x3e,
0x22, 0x4a, 0xdc, 0xf4, 0x88, 0x9c, 0x0e, 0x31, 0xe5, 0x72, 0x25, 0x9b, 0x37, 0x16, 0x8a, 0xf6,
0x57, 0x63, 0x19, 0xfc, 0x01, 0xac, 0x90, 0x0b, 0x37, 0x42, 0x6c, 0x34, 0x21, 0xcb, 0xfb, 0xd9,
0x5f, 0x67, 0x21, 0xd0, 0x93, 0x59, 0x17, 0xfe, 0x08, 0x56, 0x38, 0x39, 0x45, 0x01, 0xee, 0x13,
0x64, 0x33, 0x1e, 0xc9, 0x2f, 0x6e, 0x70, 0xa9, 0x5b, 0xe2, 0xe4, 0xb4, 0x83, 0xfb, 0xa4, 0xc6,
0x78, 0xfc, 0x0e, 0x0b, 0xb1, 0xef, 0x30, 0x6f, 0x0a, 0x72, 0x70, 0x03, 0xc8, 0x6a, 0xa2, 0x4a,
0x39, 0xc5, 0x7f, 0xe4, 0x40, 0x61, 0xce, 0x9d, 0x14, 0x7e, 0x0d, 0x9e, 0xd4, 0xf4, 0xb6, 0x69,
0x19, 0x4a, 0xb3, 0x6d, 0x21, 0xf5, 0xa4, 0xa6, 0x1d, 0x99, 0x4d, 0xbd, 0x8d, 0x8e, 0xda, 0x66,
0x47, 0xad, 0x35, 0x1b, 0x4d, 0xb5, 0x2e, 0xfd, 0x1f, 0xdc, 0x01, 0x5b, 0x73, 0xbd, 0xf4, 0xb6,
0x94, 0x83, 0x5f, 0x00, 0x79, 0xfe, 0x62, 0xa3, 0x21, 0x2d, 0xc0, 0x22, 0x78, 0x34, 0x77, 0xb5,
0xa3, 0x18, 0x56, 0xd3, 0x6a, 0xea, 0x6d, 0x69, 0xb1, 0xf8, 0xd7, 0x1c, 0xc8, 0x5f, 0xbb, 0x9b,
0xc1, 0xaf, 0xc0, 0xe3, 0x86, 0x6e, 0xd4, 0x54, 0xe1, 0xaa, 0x68, 0x9a, 0xaa, 0xa1, 0x96, 0x5e,
0x57, 0xaf, 0x64, 0xb6, 0x0d, 0x36, 0xe7, 0x39, 0xc5, 0x89, 0xed, 0x80, 0xad, 0xb9, 0x6b, 0x71,
0x5e, 0x8f, 0xc1, 0xce, 0xbc, 0x45, 0x43, 0x3d, 0x34, 0x54, 0xd3, 0x14, 0x49, 0x2d, 0x80, 0x7b,
0xe9, 0x0d, 0x06, 0x3e, 0x00, 0x1b, 0x9a, 0x7e, 0x88, 0x34, 0xf5, 0x58, 0xd5, 0xae, 0x64, 0xb0,
0x0e, 0xa4, 0xc9, 0x52, 0x5d, 0xad, 0x1e, 0x1d, 0xfe, 0x4a, 0xca, 0xcd, 0xb1, 0x1e, 0x48, 0x0b,
0x73, 0xac, 0x2f, 0xa4, 0xc5, 0x39, 0xd6, 0x7d, 0xe9, 0xce, 0x1c, 0x6b, 0x45, 0xfa, 0x0c, 0xe6,
0xc1, 0xca, 0xc4, 0xaa, 0xe9, 0x87, 0xd2, 0xdd, 0x59, 0xc7, 0xb6, 0x6e, 0x35, 0x6b, 0xaa, 0xf4,
0x39, 0xdc, 0x00, 0xf9, 0x89, 0xf5, 0xad, 0x62, 0xb4, 0x9b, 0xed, 0x43, 0xe9, 0x1e, 0x2c, 0x80,
0xb5, 0x89, 0x59, 0x35, 0x0c, 0xdd, 0x90, 0xee, 0xcf, 0x1a, 0x1b, 0x8a, 0xa5, 0x68, 0x12, 0x98,
0x35, 0x76, 0x94, 0x76, 0xb3, 0x26, 0x2d, 0x15, 0xff, 0x9e, 0x03, 0xf9, 0x6b, 0xd3, 0xbe, 0xa8,
0x94, 0x70, 0x8d, 0x71, 0xe8, 0x58, 0x35, 0xaa, 0xba, 0xd9, 0xb4, 0x7e, 0xba, 0xb2, 0x4f, 0x0f,
0xc1, 0x83, 0x79, 0x4e, 0x96, 0x6a, 0x98, 0xaa, 0x94, 0x13, 0xf5, 0x98, 0xb7, 0x5c, 0x57, 0x1b,
0xca, 0x91, 0x66, 0x25, 0x05, 0x9b, 0xe7, 0x90, 0xfc, 0x4b, 0x95, 0x16, 0x8b, 0x7f, 0xc9, 0x81,
0xe5, 0xe9, 0x61, 0x3e, 0x8d, 0x68, 0x5a, 0x8a, 0xa5, 0xb6, 0xd4, 0xb6, 0x75, 0x25, 0xa1, 0x4d,
0x00, 0x67, 0x97, 0xdb, 0x7a, 0x5b, 0x64, 0x32, 0xda, 0xb9, 0x89, 0xbd, 0x5e, 0xd7, 0xa4, 0x85,
0xeb, 0xe6, 0x96, 0x5e, 0x97, 0x16, 0xaf, 0x9b, 0x15, 0x4d, 0x93, 0xee, 0x14, 0xff, 0x95, 0x03,
0xeb, 0x73, 0xe7, 0xe2, 0xa7, 0xe0, 0x4b, 0xcb, 0x50, 0xda, 0xa6, 0x52, 0x13, 0xcd, 0x8f, 0x9a,
0xa6, 0xae, 0x29, 0xd6, 0xf5, 0x13, 0xf7, 0x2d, 0x78, 0x36, 0xdf, 0xcd, 0x50, 0x95, 0x3a, 0x3a,
0x6a, 0xd7, 0xf4, 0x56, 0xab, 0x69, 0x59, 0x6a, 0x5d, 0xca, 0xc1, 0xe7, 0xe0, 0xeb, 0xff, 0xe2,
0x3b, 0xf1, 0x5c, 0x80, 0xdf, 0x80, 0xa7, 0xff, 0xc9, 0xb3, 0xa3, 0x2a, 0x96, 0x52, 0xd5, 0xd4,
0x58, 0x24, 0x2d, 0xc2, 0x67, 0xa0, 0x38, 0xdf, 0xd5, 0x54, 0x8d, 0xa6, 0xa2, 0x35, 0xdf, 0x09,
0x67, 0xe9, 0x4e, 0xf1, 0x77, 0x60, 0x69, 0x6a, 0x40, 0x15, 0x2f, 0x83, 0xea, 0x4f, 0x96, 0xaa,
0x20, 0xfd, 0xc8, 0xea, 0x1c, 0x59, 0xd7, 0xcf, 0xca, 0xcc, 0xea, 0x6b, 0xf5, 0x44, 0xca, 0x41,
0x19, 0xac, 0xcf, 0x58, 0x55, 0xb3, 0xa6, 0x74, 0x44, 0xbe, 0x45, 0x03, 0xdc, 0x1f, 0x8f, 0xa4,
0xe2, 0xa8, 0x9f, 0xb4, 0x34, 0x54, 0x6d, 0xb6, 0x15, 0xe3, 0x6a, 0x73, 0x6d, 0x80, 0xfc, 0xd4,
0x5a, 0x55, 0x31, 0xd5, 0x97, 0x07, 0x52, 0x0e, 0x42, 0xb0, 0x3a, 0x65, 0x16, 0xd1, 0x16, 0x8a,
0x27, 0x31, 0x33, 0x99, 0x3f, 0x53, 0xa6, 0xde, 0x99, 0x53, 0x82, 0x2d, 0x50, 0x98, 0x5a, 0xab,
0xeb, 0xb5, 0x23, 0x51, 0x5f, 0x29, 0x27, 0x1a, 0x67, 0x6a, 0xa1, 0xa6, 0xb7, 0x2d, 0x61, 0x5f,
0x10, 0xef, 0xd8, 0xd5, 0xd9, 0xe9, 0x46, 0x34, 0x6d, 0x55, 0xa9, 0xfd, 0xd6, 0xd4, 0x14, 0xf3,
0x35, 0x7a, 0x73, 0xa4, 0x5b, 0x57, 0xdf, 0x5f, 0x05, 0xb0, 0x76, 0xc5, 0x21, 0x09, 0x70, 0x55,
0xa5, 0xb7, 0xa5, 0x05, 0x91, 0xd1, 0x35, 0x7b, 0xa3, 0x21, 0x2d, 0xc2, 0x2f, 0xc1, 0xc3, 0xab,
0x0b, 0xa6, 0xd2, 0x50, 0x91, 0xda, 0xae, 0xe9, 0x75, 0x71, 0xf0, 0xef, 0x54, 0x8f, 0xdf, 0x59,
0x7d, 0x37, 0x1a, 0x0c, 0xbb, 0x25, 0x9b, 0x79, 0xe5, 0x64, 0x82, 0xdb, 0x4d, 0xfe, 0xdf, 0xbf,
0xcf, 0x76, 0xfb, 0xc4, 0x8f, 0x3f, 0x23, 0xe5, 0x1b, 0xfd, 0x2d, 0xe2, 0xfb, 0x89, 0xb1, 0x7b,
0x37, 0xd6, 0xbd, 0xf8, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x77, 0xeb, 0xa2, 0x8a, 0xc6, 0x18,
0x00, 0x00,
}

935
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/config/host11.pb.go generated vendored Normal file
View File

@ -0,0 +1,935 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/postgresql/v1/config/host11.proto
package postgresql // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/config"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import wrappers "github.com/golang/protobuf/ptypes/wrappers"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type PostgresqlHostConfig11_ConstraintExclusion int32
const (
PostgresqlHostConfig11_CONSTRAINT_EXCLUSION_UNSPECIFIED PostgresqlHostConfig11_ConstraintExclusion = 0
PostgresqlHostConfig11_CONSTRAINT_EXCLUSION_ON PostgresqlHostConfig11_ConstraintExclusion = 1
PostgresqlHostConfig11_CONSTRAINT_EXCLUSION_OFF PostgresqlHostConfig11_ConstraintExclusion = 2
PostgresqlHostConfig11_CONSTRAINT_EXCLUSION_PARTITION PostgresqlHostConfig11_ConstraintExclusion = 3
)
var PostgresqlHostConfig11_ConstraintExclusion_name = map[int32]string{
0: "CONSTRAINT_EXCLUSION_UNSPECIFIED",
1: "CONSTRAINT_EXCLUSION_ON",
2: "CONSTRAINT_EXCLUSION_OFF",
3: "CONSTRAINT_EXCLUSION_PARTITION",
}
var PostgresqlHostConfig11_ConstraintExclusion_value = map[string]int32{
"CONSTRAINT_EXCLUSION_UNSPECIFIED": 0,
"CONSTRAINT_EXCLUSION_ON": 1,
"CONSTRAINT_EXCLUSION_OFF": 2,
"CONSTRAINT_EXCLUSION_PARTITION": 3,
}
func (x PostgresqlHostConfig11_ConstraintExclusion) String() string {
return proto.EnumName(PostgresqlHostConfig11_ConstraintExclusion_name, int32(x))
}
func (PostgresqlHostConfig11_ConstraintExclusion) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host11_bb5f848b388f9f62, []int{0, 0}
}
type PostgresqlHostConfig11_ForceParallelMode int32
const (
PostgresqlHostConfig11_FORCE_PARALLEL_MODE_UNSPECIFIED PostgresqlHostConfig11_ForceParallelMode = 0
PostgresqlHostConfig11_FORCE_PARALLEL_MODE_ON PostgresqlHostConfig11_ForceParallelMode = 1
PostgresqlHostConfig11_FORCE_PARALLEL_MODE_OFF PostgresqlHostConfig11_ForceParallelMode = 2
PostgresqlHostConfig11_FORCE_PARALLEL_MODE_REGRESS PostgresqlHostConfig11_ForceParallelMode = 3
)
var PostgresqlHostConfig11_ForceParallelMode_name = map[int32]string{
0: "FORCE_PARALLEL_MODE_UNSPECIFIED",
1: "FORCE_PARALLEL_MODE_ON",
2: "FORCE_PARALLEL_MODE_OFF",
3: "FORCE_PARALLEL_MODE_REGRESS",
}
var PostgresqlHostConfig11_ForceParallelMode_value = map[string]int32{
"FORCE_PARALLEL_MODE_UNSPECIFIED": 0,
"FORCE_PARALLEL_MODE_ON": 1,
"FORCE_PARALLEL_MODE_OFF": 2,
"FORCE_PARALLEL_MODE_REGRESS": 3,
}
func (x PostgresqlHostConfig11_ForceParallelMode) String() string {
return proto.EnumName(PostgresqlHostConfig11_ForceParallelMode_name, int32(x))
}
func (PostgresqlHostConfig11_ForceParallelMode) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host11_bb5f848b388f9f62, []int{0, 1}
}
type PostgresqlHostConfig11_LogLevel int32
const (
PostgresqlHostConfig11_LOG_LEVEL_UNSPECIFIED PostgresqlHostConfig11_LogLevel = 0
PostgresqlHostConfig11_LOG_LEVEL_DEBUG5 PostgresqlHostConfig11_LogLevel = 1
PostgresqlHostConfig11_LOG_LEVEL_DEBUG4 PostgresqlHostConfig11_LogLevel = 2
PostgresqlHostConfig11_LOG_LEVEL_DEBUG3 PostgresqlHostConfig11_LogLevel = 3
PostgresqlHostConfig11_LOG_LEVEL_DEBUG2 PostgresqlHostConfig11_LogLevel = 4
PostgresqlHostConfig11_LOG_LEVEL_DEBUG1 PostgresqlHostConfig11_LogLevel = 5
PostgresqlHostConfig11_LOG_LEVEL_LOG PostgresqlHostConfig11_LogLevel = 6
PostgresqlHostConfig11_LOG_LEVEL_NOTICE PostgresqlHostConfig11_LogLevel = 7
PostgresqlHostConfig11_LOG_LEVEL_WARNING PostgresqlHostConfig11_LogLevel = 8
PostgresqlHostConfig11_LOG_LEVEL_ERROR PostgresqlHostConfig11_LogLevel = 9
PostgresqlHostConfig11_LOG_LEVEL_FATAL PostgresqlHostConfig11_LogLevel = 10
PostgresqlHostConfig11_LOG_LEVEL_PANIC PostgresqlHostConfig11_LogLevel = 11
)
var PostgresqlHostConfig11_LogLevel_name = map[int32]string{
0: "LOG_LEVEL_UNSPECIFIED",
1: "LOG_LEVEL_DEBUG5",
2: "LOG_LEVEL_DEBUG4",
3: "LOG_LEVEL_DEBUG3",
4: "LOG_LEVEL_DEBUG2",
5: "LOG_LEVEL_DEBUG1",
6: "LOG_LEVEL_LOG",
7: "LOG_LEVEL_NOTICE",
8: "LOG_LEVEL_WARNING",
9: "LOG_LEVEL_ERROR",
10: "LOG_LEVEL_FATAL",
11: "LOG_LEVEL_PANIC",
}
var PostgresqlHostConfig11_LogLevel_value = map[string]int32{
"LOG_LEVEL_UNSPECIFIED": 0,
"LOG_LEVEL_DEBUG5": 1,
"LOG_LEVEL_DEBUG4": 2,
"LOG_LEVEL_DEBUG3": 3,
"LOG_LEVEL_DEBUG2": 4,
"LOG_LEVEL_DEBUG1": 5,
"LOG_LEVEL_LOG": 6,
"LOG_LEVEL_NOTICE": 7,
"LOG_LEVEL_WARNING": 8,
"LOG_LEVEL_ERROR": 9,
"LOG_LEVEL_FATAL": 10,
"LOG_LEVEL_PANIC": 11,
}
func (x PostgresqlHostConfig11_LogLevel) String() string {
return proto.EnumName(PostgresqlHostConfig11_LogLevel_name, int32(x))
}
func (PostgresqlHostConfig11_LogLevel) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host11_bb5f848b388f9f62, []int{0, 2}
}
type PostgresqlHostConfig11_LogErrorVerbosity int32
const (
PostgresqlHostConfig11_LOG_ERROR_VERBOSITY_UNSPECIFIED PostgresqlHostConfig11_LogErrorVerbosity = 0
PostgresqlHostConfig11_LOG_ERROR_VERBOSITY_TERSE PostgresqlHostConfig11_LogErrorVerbosity = 1
PostgresqlHostConfig11_LOG_ERROR_VERBOSITY_DEFAULT PostgresqlHostConfig11_LogErrorVerbosity = 2
PostgresqlHostConfig11_LOG_ERROR_VERBOSITY_VERBOSE PostgresqlHostConfig11_LogErrorVerbosity = 3
)
var PostgresqlHostConfig11_LogErrorVerbosity_name = map[int32]string{
0: "LOG_ERROR_VERBOSITY_UNSPECIFIED",
1: "LOG_ERROR_VERBOSITY_TERSE",
2: "LOG_ERROR_VERBOSITY_DEFAULT",
3: "LOG_ERROR_VERBOSITY_VERBOSE",
}
var PostgresqlHostConfig11_LogErrorVerbosity_value = map[string]int32{
"LOG_ERROR_VERBOSITY_UNSPECIFIED": 0,
"LOG_ERROR_VERBOSITY_TERSE": 1,
"LOG_ERROR_VERBOSITY_DEFAULT": 2,
"LOG_ERROR_VERBOSITY_VERBOSE": 3,
}
func (x PostgresqlHostConfig11_LogErrorVerbosity) String() string {
return proto.EnumName(PostgresqlHostConfig11_LogErrorVerbosity_name, int32(x))
}
func (PostgresqlHostConfig11_LogErrorVerbosity) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host11_bb5f848b388f9f62, []int{0, 3}
}
type PostgresqlHostConfig11_LogStatement int32
const (
PostgresqlHostConfig11_LOG_STATEMENT_UNSPECIFIED PostgresqlHostConfig11_LogStatement = 0
PostgresqlHostConfig11_LOG_STATEMENT_NONE PostgresqlHostConfig11_LogStatement = 1
PostgresqlHostConfig11_LOG_STATEMENT_DDL PostgresqlHostConfig11_LogStatement = 2
PostgresqlHostConfig11_LOG_STATEMENT_MOD PostgresqlHostConfig11_LogStatement = 3
PostgresqlHostConfig11_LOG_STATEMENT_ALL PostgresqlHostConfig11_LogStatement = 4
)
var PostgresqlHostConfig11_LogStatement_name = map[int32]string{
0: "LOG_STATEMENT_UNSPECIFIED",
1: "LOG_STATEMENT_NONE",
2: "LOG_STATEMENT_DDL",
3: "LOG_STATEMENT_MOD",
4: "LOG_STATEMENT_ALL",
}
var PostgresqlHostConfig11_LogStatement_value = map[string]int32{
"LOG_STATEMENT_UNSPECIFIED": 0,
"LOG_STATEMENT_NONE": 1,
"LOG_STATEMENT_DDL": 2,
"LOG_STATEMENT_MOD": 3,
"LOG_STATEMENT_ALL": 4,
}
func (x PostgresqlHostConfig11_LogStatement) String() string {
return proto.EnumName(PostgresqlHostConfig11_LogStatement_name, int32(x))
}
func (PostgresqlHostConfig11_LogStatement) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host11_bb5f848b388f9f62, []int{0, 4}
}
type PostgresqlHostConfig11_TransactionIsolation int32
const (
PostgresqlHostConfig11_TRANSACTION_ISOLATION_UNSPECIFIED PostgresqlHostConfig11_TransactionIsolation = 0
PostgresqlHostConfig11_TRANSACTION_ISOLATION_READ_UNCOMMITTED PostgresqlHostConfig11_TransactionIsolation = 1
PostgresqlHostConfig11_TRANSACTION_ISOLATION_READ_COMMITTED PostgresqlHostConfig11_TransactionIsolation = 2
PostgresqlHostConfig11_TRANSACTION_ISOLATION_REPEATABLE_READ PostgresqlHostConfig11_TransactionIsolation = 3
PostgresqlHostConfig11_TRANSACTION_ISOLATION_SERIALIZABLE PostgresqlHostConfig11_TransactionIsolation = 4
)
var PostgresqlHostConfig11_TransactionIsolation_name = map[int32]string{
0: "TRANSACTION_ISOLATION_UNSPECIFIED",
1: "TRANSACTION_ISOLATION_READ_UNCOMMITTED",
2: "TRANSACTION_ISOLATION_READ_COMMITTED",
3: "TRANSACTION_ISOLATION_REPEATABLE_READ",
4: "TRANSACTION_ISOLATION_SERIALIZABLE",
}
var PostgresqlHostConfig11_TransactionIsolation_value = map[string]int32{
"TRANSACTION_ISOLATION_UNSPECIFIED": 0,
"TRANSACTION_ISOLATION_READ_UNCOMMITTED": 1,
"TRANSACTION_ISOLATION_READ_COMMITTED": 2,
"TRANSACTION_ISOLATION_REPEATABLE_READ": 3,
"TRANSACTION_ISOLATION_SERIALIZABLE": 4,
}
func (x PostgresqlHostConfig11_TransactionIsolation) String() string {
return proto.EnumName(PostgresqlHostConfig11_TransactionIsolation_name, int32(x))
}
func (PostgresqlHostConfig11_TransactionIsolation) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host11_bb5f848b388f9f62, []int{0, 5}
}
type PostgresqlHostConfig11_ByteaOutput int32
const (
PostgresqlHostConfig11_BYTEA_OUTPUT_UNSPECIFIED PostgresqlHostConfig11_ByteaOutput = 0
PostgresqlHostConfig11_BYTEA_OUTPUT_HEX PostgresqlHostConfig11_ByteaOutput = 1
PostgresqlHostConfig11_BYTEA_OUTPUT_ESCAPED PostgresqlHostConfig11_ByteaOutput = 2
)
var PostgresqlHostConfig11_ByteaOutput_name = map[int32]string{
0: "BYTEA_OUTPUT_UNSPECIFIED",
1: "BYTEA_OUTPUT_HEX",
2: "BYTEA_OUTPUT_ESCAPED",
}
var PostgresqlHostConfig11_ByteaOutput_value = map[string]int32{
"BYTEA_OUTPUT_UNSPECIFIED": 0,
"BYTEA_OUTPUT_HEX": 1,
"BYTEA_OUTPUT_ESCAPED": 2,
}
func (x PostgresqlHostConfig11_ByteaOutput) String() string {
return proto.EnumName(PostgresqlHostConfig11_ByteaOutput_name, int32(x))
}
func (PostgresqlHostConfig11_ByteaOutput) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host11_bb5f848b388f9f62, []int{0, 6}
}
type PostgresqlHostConfig11_XmlBinary int32
const (
PostgresqlHostConfig11_XML_BINARY_UNSPECIFIED PostgresqlHostConfig11_XmlBinary = 0
PostgresqlHostConfig11_XML_BINARY_BASE64 PostgresqlHostConfig11_XmlBinary = 1
PostgresqlHostConfig11_XML_BINARY_HEX PostgresqlHostConfig11_XmlBinary = 2
)
var PostgresqlHostConfig11_XmlBinary_name = map[int32]string{
0: "XML_BINARY_UNSPECIFIED",
1: "XML_BINARY_BASE64",
2: "XML_BINARY_HEX",
}
var PostgresqlHostConfig11_XmlBinary_value = map[string]int32{
"XML_BINARY_UNSPECIFIED": 0,
"XML_BINARY_BASE64": 1,
"XML_BINARY_HEX": 2,
}
func (x PostgresqlHostConfig11_XmlBinary) String() string {
return proto.EnumName(PostgresqlHostConfig11_XmlBinary_name, int32(x))
}
func (PostgresqlHostConfig11_XmlBinary) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host11_bb5f848b388f9f62, []int{0, 7}
}
type PostgresqlHostConfig11_XmlOption int32
const (
PostgresqlHostConfig11_XML_OPTION_UNSPECIFIED PostgresqlHostConfig11_XmlOption = 0
PostgresqlHostConfig11_XML_OPTION_DOCUMENT PostgresqlHostConfig11_XmlOption = 1
PostgresqlHostConfig11_XML_OPTION_CONTENT PostgresqlHostConfig11_XmlOption = 2
)
var PostgresqlHostConfig11_XmlOption_name = map[int32]string{
0: "XML_OPTION_UNSPECIFIED",
1: "XML_OPTION_DOCUMENT",
2: "XML_OPTION_CONTENT",
}
var PostgresqlHostConfig11_XmlOption_value = map[string]int32{
"XML_OPTION_UNSPECIFIED": 0,
"XML_OPTION_DOCUMENT": 1,
"XML_OPTION_CONTENT": 2,
}
func (x PostgresqlHostConfig11_XmlOption) String() string {
return proto.EnumName(PostgresqlHostConfig11_XmlOption_name, int32(x))
}
func (PostgresqlHostConfig11_XmlOption) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host11_bb5f848b388f9f62, []int{0, 8}
}
type PostgresqlHostConfig11_BackslashQuote int32
const (
PostgresqlHostConfig11_BACKSLASH_QUOTE_UNSPECIFIED PostgresqlHostConfig11_BackslashQuote = 0
PostgresqlHostConfig11_BACKSLASH_QUOTE PostgresqlHostConfig11_BackslashQuote = 1
PostgresqlHostConfig11_BACKSLASH_QUOTE_ON PostgresqlHostConfig11_BackslashQuote = 2
PostgresqlHostConfig11_BACKSLASH_QUOTE_OFF PostgresqlHostConfig11_BackslashQuote = 3
PostgresqlHostConfig11_BACKSLASH_QUOTE_SAFE_ENCODING PostgresqlHostConfig11_BackslashQuote = 4
)
var PostgresqlHostConfig11_BackslashQuote_name = map[int32]string{
0: "BACKSLASH_QUOTE_UNSPECIFIED",
1: "BACKSLASH_QUOTE",
2: "BACKSLASH_QUOTE_ON",
3: "BACKSLASH_QUOTE_OFF",
4: "BACKSLASH_QUOTE_SAFE_ENCODING",
}
var PostgresqlHostConfig11_BackslashQuote_value = map[string]int32{
"BACKSLASH_QUOTE_UNSPECIFIED": 0,
"BACKSLASH_QUOTE": 1,
"BACKSLASH_QUOTE_ON": 2,
"BACKSLASH_QUOTE_OFF": 3,
"BACKSLASH_QUOTE_SAFE_ENCODING": 4,
}
func (x PostgresqlHostConfig11_BackslashQuote) String() string {
return proto.EnumName(PostgresqlHostConfig11_BackslashQuote_name, int32(x))
}
func (PostgresqlHostConfig11_BackslashQuote) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host11_bb5f848b388f9f62, []int{0, 9}
}
// Options and structure of `PostgresqlConfig` reflects PostgreSQL configuration file
// parameters which detailed description is available in
// [PostgreSQL documentation](https://www.postgresql.org/docs/11/runtime-config.html).
type PostgresqlHostConfig11 struct {
RecoveryMinApplyDelay *wrappers.Int64Value `protobuf:"bytes,1,opt,name=recovery_min_apply_delay,json=recoveryMinApplyDelay,proto3" json:"recovery_min_apply_delay,omitempty"`
SharedBuffers *wrappers.Int64Value `protobuf:"bytes,2,opt,name=shared_buffers,json=sharedBuffers,proto3" json:"shared_buffers,omitempty"`
TempBuffers *wrappers.Int64Value `protobuf:"bytes,3,opt,name=temp_buffers,json=tempBuffers,proto3" json:"temp_buffers,omitempty"`
WorkMem *wrappers.Int64Value `protobuf:"bytes,4,opt,name=work_mem,json=workMem,proto3" json:"work_mem,omitempty"`
TempFileLimit *wrappers.Int64Value `protobuf:"bytes,5,opt,name=temp_file_limit,json=tempFileLimit,proto3" json:"temp_file_limit,omitempty"`
BackendFlushAfter *wrappers.Int64Value `protobuf:"bytes,6,opt,name=backend_flush_after,json=backendFlushAfter,proto3" json:"backend_flush_after,omitempty"`
OldSnapshotThreshold *wrappers.Int64Value `protobuf:"bytes,7,opt,name=old_snapshot_threshold,json=oldSnapshotThreshold,proto3" json:"old_snapshot_threshold,omitempty"`
MaxStandbyStreamingDelay *wrappers.Int64Value `protobuf:"bytes,8,opt,name=max_standby_streaming_delay,json=maxStandbyStreamingDelay,proto3" json:"max_standby_streaming_delay,omitempty"`
ConstraintExclusion PostgresqlHostConfig11_ConstraintExclusion `protobuf:"varint,9,opt,name=constraint_exclusion,json=constraintExclusion,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_ConstraintExclusion" json:"constraint_exclusion,omitempty"`
CursorTupleFraction *wrappers.DoubleValue `protobuf:"bytes,10,opt,name=cursor_tuple_fraction,json=cursorTupleFraction,proto3" json:"cursor_tuple_fraction,omitempty"`
FromCollapseLimit *wrappers.Int64Value `protobuf:"bytes,11,opt,name=from_collapse_limit,json=fromCollapseLimit,proto3" json:"from_collapse_limit,omitempty"`
JoinCollapseLimit *wrappers.Int64Value `protobuf:"bytes,12,opt,name=join_collapse_limit,json=joinCollapseLimit,proto3" json:"join_collapse_limit,omitempty"`
ForceParallelMode PostgresqlHostConfig11_ForceParallelMode `protobuf:"varint,13,opt,name=force_parallel_mode,json=forceParallelMode,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_ForceParallelMode" json:"force_parallel_mode,omitempty"`
ClientMinMessages PostgresqlHostConfig11_LogLevel `protobuf:"varint,14,opt,name=client_min_messages,json=clientMinMessages,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_LogLevel" json:"client_min_messages,omitempty"`
LogMinMessages PostgresqlHostConfig11_LogLevel `protobuf:"varint,15,opt,name=log_min_messages,json=logMinMessages,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_LogLevel" json:"log_min_messages,omitempty"`
LogMinErrorStatement PostgresqlHostConfig11_LogLevel `protobuf:"varint,16,opt,name=log_min_error_statement,json=logMinErrorStatement,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_LogLevel" json:"log_min_error_statement,omitempty"`
LogMinDurationStatement *wrappers.Int64Value `protobuf:"bytes,17,opt,name=log_min_duration_statement,json=logMinDurationStatement,proto3" json:"log_min_duration_statement,omitempty"`
LogCheckpoints *wrappers.BoolValue `protobuf:"bytes,18,opt,name=log_checkpoints,json=logCheckpoints,proto3" json:"log_checkpoints,omitempty"`
LogConnections *wrappers.BoolValue `protobuf:"bytes,19,opt,name=log_connections,json=logConnections,proto3" json:"log_connections,omitempty"`
LogDisconnections *wrappers.BoolValue `protobuf:"bytes,20,opt,name=log_disconnections,json=logDisconnections,proto3" json:"log_disconnections,omitempty"`
LogDuration *wrappers.BoolValue `protobuf:"bytes,21,opt,name=log_duration,json=logDuration,proto3" json:"log_duration,omitempty"`
LogErrorVerbosity PostgresqlHostConfig11_LogErrorVerbosity `protobuf:"varint,22,opt,name=log_error_verbosity,json=logErrorVerbosity,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_LogErrorVerbosity" json:"log_error_verbosity,omitempty"`
LogLockWaits *wrappers.BoolValue `protobuf:"bytes,23,opt,name=log_lock_waits,json=logLockWaits,proto3" json:"log_lock_waits,omitempty"`
LogStatement PostgresqlHostConfig11_LogStatement `protobuf:"varint,24,opt,name=log_statement,json=logStatement,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_LogStatement" json:"log_statement,omitempty"`
LogTempFiles *wrappers.Int64Value `protobuf:"bytes,25,opt,name=log_temp_files,json=logTempFiles,proto3" json:"log_temp_files,omitempty"`
SearchPath string `protobuf:"bytes,26,opt,name=search_path,json=searchPath,proto3" json:"search_path,omitempty"`
RowSecurity *wrappers.BoolValue `protobuf:"bytes,27,opt,name=row_security,json=rowSecurity,proto3" json:"row_security,omitempty"`
DefaultTransactionIsolation PostgresqlHostConfig11_TransactionIsolation `protobuf:"varint,28,opt,name=default_transaction_isolation,json=defaultTransactionIsolation,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_TransactionIsolation" json:"default_transaction_isolation,omitempty"`
StatementTimeout *wrappers.Int64Value `protobuf:"bytes,29,opt,name=statement_timeout,json=statementTimeout,proto3" json:"statement_timeout,omitempty"`
LockTimeout *wrappers.Int64Value `protobuf:"bytes,30,opt,name=lock_timeout,json=lockTimeout,proto3" json:"lock_timeout,omitempty"`
IdleInTransactionSessionTimeout *wrappers.Int64Value `protobuf:"bytes,31,opt,name=idle_in_transaction_session_timeout,json=idleInTransactionSessionTimeout,proto3" json:"idle_in_transaction_session_timeout,omitempty"`
ByteaOutput PostgresqlHostConfig11_ByteaOutput `protobuf:"varint,32,opt,name=bytea_output,json=byteaOutput,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_ByteaOutput" json:"bytea_output,omitempty"`
Xmlbinary PostgresqlHostConfig11_XmlBinary `protobuf:"varint,33,opt,name=xmlbinary,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_XmlBinary" json:"xmlbinary,omitempty"`
Xmloption PostgresqlHostConfig11_XmlOption `protobuf:"varint,34,opt,name=xmloption,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_XmlOption" json:"xmloption,omitempty"`
GinPendingListLimit *wrappers.Int64Value `protobuf:"bytes,35,opt,name=gin_pending_list_limit,json=ginPendingListLimit,proto3" json:"gin_pending_list_limit,omitempty"`
DeadlockTimeout *wrappers.Int64Value `protobuf:"bytes,36,opt,name=deadlock_timeout,json=deadlockTimeout,proto3" json:"deadlock_timeout,omitempty"`
MaxLocksPerTransaction *wrappers.Int64Value `protobuf:"bytes,37,opt,name=max_locks_per_transaction,json=maxLocksPerTransaction,proto3" json:"max_locks_per_transaction,omitempty"`
MaxPredLocksPerTransaction *wrappers.Int64Value `protobuf:"bytes,38,opt,name=max_pred_locks_per_transaction,json=maxPredLocksPerTransaction,proto3" json:"max_pred_locks_per_transaction,omitempty"`
ArrayNulls *wrappers.BoolValue `protobuf:"bytes,39,opt,name=array_nulls,json=arrayNulls,proto3" json:"array_nulls,omitempty"`
BackslashQuote PostgresqlHostConfig11_BackslashQuote `protobuf:"varint,40,opt,name=backslash_quote,json=backslashQuote,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_BackslashQuote" json:"backslash_quote,omitempty"`
DefaultWithOids *wrappers.BoolValue `protobuf:"bytes,41,opt,name=default_with_oids,json=defaultWithOids,proto3" json:"default_with_oids,omitempty"`
EscapeStringWarning *wrappers.BoolValue `protobuf:"bytes,42,opt,name=escape_string_warning,json=escapeStringWarning,proto3" json:"escape_string_warning,omitempty"`
LoCompatPrivileges *wrappers.BoolValue `protobuf:"bytes,43,opt,name=lo_compat_privileges,json=loCompatPrivileges,proto3" json:"lo_compat_privileges,omitempty"`
OperatorPrecedenceWarning *wrappers.BoolValue `protobuf:"bytes,44,opt,name=operator_precedence_warning,json=operatorPrecedenceWarning,proto3" json:"operator_precedence_warning,omitempty"`
QuoteAllIdentifiers *wrappers.BoolValue `protobuf:"bytes,45,opt,name=quote_all_identifiers,json=quoteAllIdentifiers,proto3" json:"quote_all_identifiers,omitempty"`
StandardConformingStrings *wrappers.BoolValue `protobuf:"bytes,46,opt,name=standard_conforming_strings,json=standardConformingStrings,proto3" json:"standard_conforming_strings,omitempty"`
SynchronizeSeqscans *wrappers.BoolValue `protobuf:"bytes,47,opt,name=synchronize_seqscans,json=synchronizeSeqscans,proto3" json:"synchronize_seqscans,omitempty"`
TransformNullEquals *wrappers.BoolValue `protobuf:"bytes,48,opt,name=transform_null_equals,json=transformNullEquals,proto3" json:"transform_null_equals,omitempty"`
ExitOnError *wrappers.BoolValue `protobuf:"bytes,49,opt,name=exit_on_error,json=exitOnError,proto3" json:"exit_on_error,omitempty"`
SeqPageCost *wrappers.DoubleValue `protobuf:"bytes,50,opt,name=seq_page_cost,json=seqPageCost,proto3" json:"seq_page_cost,omitempty"`
RandomPageCost *wrappers.DoubleValue `protobuf:"bytes,51,opt,name=random_page_cost,json=randomPageCost,proto3" json:"random_page_cost,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PostgresqlHostConfig11) Reset() { *m = PostgresqlHostConfig11{} }
func (m *PostgresqlHostConfig11) String() string { return proto.CompactTextString(m) }
func (*PostgresqlHostConfig11) ProtoMessage() {}
func (*PostgresqlHostConfig11) Descriptor() ([]byte, []int) {
return fileDescriptor_host11_bb5f848b388f9f62, []int{0}
}
func (m *PostgresqlHostConfig11) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PostgresqlHostConfig11.Unmarshal(m, b)
}
func (m *PostgresqlHostConfig11) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PostgresqlHostConfig11.Marshal(b, m, deterministic)
}
func (dst *PostgresqlHostConfig11) XXX_Merge(src proto.Message) {
xxx_messageInfo_PostgresqlHostConfig11.Merge(dst, src)
}
func (m *PostgresqlHostConfig11) XXX_Size() int {
return xxx_messageInfo_PostgresqlHostConfig11.Size(m)
}
func (m *PostgresqlHostConfig11) XXX_DiscardUnknown() {
xxx_messageInfo_PostgresqlHostConfig11.DiscardUnknown(m)
}
var xxx_messageInfo_PostgresqlHostConfig11 proto.InternalMessageInfo
func (m *PostgresqlHostConfig11) GetRecoveryMinApplyDelay() *wrappers.Int64Value {
if m != nil {
return m.RecoveryMinApplyDelay
}
return nil
}
func (m *PostgresqlHostConfig11) GetSharedBuffers() *wrappers.Int64Value {
if m != nil {
return m.SharedBuffers
}
return nil
}
func (m *PostgresqlHostConfig11) GetTempBuffers() *wrappers.Int64Value {
if m != nil {
return m.TempBuffers
}
return nil
}
func (m *PostgresqlHostConfig11) GetWorkMem() *wrappers.Int64Value {
if m != nil {
return m.WorkMem
}
return nil
}
func (m *PostgresqlHostConfig11) GetTempFileLimit() *wrappers.Int64Value {
if m != nil {
return m.TempFileLimit
}
return nil
}
func (m *PostgresqlHostConfig11) GetBackendFlushAfter() *wrappers.Int64Value {
if m != nil {
return m.BackendFlushAfter
}
return nil
}
func (m *PostgresqlHostConfig11) GetOldSnapshotThreshold() *wrappers.Int64Value {
if m != nil {
return m.OldSnapshotThreshold
}
return nil
}
func (m *PostgresqlHostConfig11) GetMaxStandbyStreamingDelay() *wrappers.Int64Value {
if m != nil {
return m.MaxStandbyStreamingDelay
}
return nil
}
func (m *PostgresqlHostConfig11) GetConstraintExclusion() PostgresqlHostConfig11_ConstraintExclusion {
if m != nil {
return m.ConstraintExclusion
}
return PostgresqlHostConfig11_CONSTRAINT_EXCLUSION_UNSPECIFIED
}
func (m *PostgresqlHostConfig11) GetCursorTupleFraction() *wrappers.DoubleValue {
if m != nil {
return m.CursorTupleFraction
}
return nil
}
func (m *PostgresqlHostConfig11) GetFromCollapseLimit() *wrappers.Int64Value {
if m != nil {
return m.FromCollapseLimit
}
return nil
}
func (m *PostgresqlHostConfig11) GetJoinCollapseLimit() *wrappers.Int64Value {
if m != nil {
return m.JoinCollapseLimit
}
return nil
}
func (m *PostgresqlHostConfig11) GetForceParallelMode() PostgresqlHostConfig11_ForceParallelMode {
if m != nil {
return m.ForceParallelMode
}
return PostgresqlHostConfig11_FORCE_PARALLEL_MODE_UNSPECIFIED
}
func (m *PostgresqlHostConfig11) GetClientMinMessages() PostgresqlHostConfig11_LogLevel {
if m != nil {
return m.ClientMinMessages
}
return PostgresqlHostConfig11_LOG_LEVEL_UNSPECIFIED
}
func (m *PostgresqlHostConfig11) GetLogMinMessages() PostgresqlHostConfig11_LogLevel {
if m != nil {
return m.LogMinMessages
}
return PostgresqlHostConfig11_LOG_LEVEL_UNSPECIFIED
}
func (m *PostgresqlHostConfig11) GetLogMinErrorStatement() PostgresqlHostConfig11_LogLevel {
if m != nil {
return m.LogMinErrorStatement
}
return PostgresqlHostConfig11_LOG_LEVEL_UNSPECIFIED
}
func (m *PostgresqlHostConfig11) GetLogMinDurationStatement() *wrappers.Int64Value {
if m != nil {
return m.LogMinDurationStatement
}
return nil
}
func (m *PostgresqlHostConfig11) GetLogCheckpoints() *wrappers.BoolValue {
if m != nil {
return m.LogCheckpoints
}
return nil
}
func (m *PostgresqlHostConfig11) GetLogConnections() *wrappers.BoolValue {
if m != nil {
return m.LogConnections
}
return nil
}
func (m *PostgresqlHostConfig11) GetLogDisconnections() *wrappers.BoolValue {
if m != nil {
return m.LogDisconnections
}
return nil
}
func (m *PostgresqlHostConfig11) GetLogDuration() *wrappers.BoolValue {
if m != nil {
return m.LogDuration
}
return nil
}
func (m *PostgresqlHostConfig11) GetLogErrorVerbosity() PostgresqlHostConfig11_LogErrorVerbosity {
if m != nil {
return m.LogErrorVerbosity
}
return PostgresqlHostConfig11_LOG_ERROR_VERBOSITY_UNSPECIFIED
}
func (m *PostgresqlHostConfig11) GetLogLockWaits() *wrappers.BoolValue {
if m != nil {
return m.LogLockWaits
}
return nil
}
func (m *PostgresqlHostConfig11) GetLogStatement() PostgresqlHostConfig11_LogStatement {
if m != nil {
return m.LogStatement
}
return PostgresqlHostConfig11_LOG_STATEMENT_UNSPECIFIED
}
func (m *PostgresqlHostConfig11) GetLogTempFiles() *wrappers.Int64Value {
if m != nil {
return m.LogTempFiles
}
return nil
}
func (m *PostgresqlHostConfig11) GetSearchPath() string {
if m != nil {
return m.SearchPath
}
return ""
}
func (m *PostgresqlHostConfig11) GetRowSecurity() *wrappers.BoolValue {
if m != nil {
return m.RowSecurity
}
return nil
}
func (m *PostgresqlHostConfig11) GetDefaultTransactionIsolation() PostgresqlHostConfig11_TransactionIsolation {
if m != nil {
return m.DefaultTransactionIsolation
}
return PostgresqlHostConfig11_TRANSACTION_ISOLATION_UNSPECIFIED
}
func (m *PostgresqlHostConfig11) GetStatementTimeout() *wrappers.Int64Value {
if m != nil {
return m.StatementTimeout
}
return nil
}
func (m *PostgresqlHostConfig11) GetLockTimeout() *wrappers.Int64Value {
if m != nil {
return m.LockTimeout
}
return nil
}
func (m *PostgresqlHostConfig11) GetIdleInTransactionSessionTimeout() *wrappers.Int64Value {
if m != nil {
return m.IdleInTransactionSessionTimeout
}
return nil
}
func (m *PostgresqlHostConfig11) GetByteaOutput() PostgresqlHostConfig11_ByteaOutput {
if m != nil {
return m.ByteaOutput
}
return PostgresqlHostConfig11_BYTEA_OUTPUT_UNSPECIFIED
}
func (m *PostgresqlHostConfig11) GetXmlbinary() PostgresqlHostConfig11_XmlBinary {
if m != nil {
return m.Xmlbinary
}
return PostgresqlHostConfig11_XML_BINARY_UNSPECIFIED
}
func (m *PostgresqlHostConfig11) GetXmloption() PostgresqlHostConfig11_XmlOption {
if m != nil {
return m.Xmloption
}
return PostgresqlHostConfig11_XML_OPTION_UNSPECIFIED
}
func (m *PostgresqlHostConfig11) GetGinPendingListLimit() *wrappers.Int64Value {
if m != nil {
return m.GinPendingListLimit
}
return nil
}
func (m *PostgresqlHostConfig11) GetDeadlockTimeout() *wrappers.Int64Value {
if m != nil {
return m.DeadlockTimeout
}
return nil
}
func (m *PostgresqlHostConfig11) GetMaxLocksPerTransaction() *wrappers.Int64Value {
if m != nil {
return m.MaxLocksPerTransaction
}
return nil
}
func (m *PostgresqlHostConfig11) GetMaxPredLocksPerTransaction() *wrappers.Int64Value {
if m != nil {
return m.MaxPredLocksPerTransaction
}
return nil
}
func (m *PostgresqlHostConfig11) GetArrayNulls() *wrappers.BoolValue {
if m != nil {
return m.ArrayNulls
}
return nil
}
func (m *PostgresqlHostConfig11) GetBackslashQuote() PostgresqlHostConfig11_BackslashQuote {
if m != nil {
return m.BackslashQuote
}
return PostgresqlHostConfig11_BACKSLASH_QUOTE_UNSPECIFIED
}
func (m *PostgresqlHostConfig11) GetDefaultWithOids() *wrappers.BoolValue {
if m != nil {
return m.DefaultWithOids
}
return nil
}
func (m *PostgresqlHostConfig11) GetEscapeStringWarning() *wrappers.BoolValue {
if m != nil {
return m.EscapeStringWarning
}
return nil
}
func (m *PostgresqlHostConfig11) GetLoCompatPrivileges() *wrappers.BoolValue {
if m != nil {
return m.LoCompatPrivileges
}
return nil
}
func (m *PostgresqlHostConfig11) GetOperatorPrecedenceWarning() *wrappers.BoolValue {
if m != nil {
return m.OperatorPrecedenceWarning
}
return nil
}
func (m *PostgresqlHostConfig11) GetQuoteAllIdentifiers() *wrappers.BoolValue {
if m != nil {
return m.QuoteAllIdentifiers
}
return nil
}
func (m *PostgresqlHostConfig11) GetStandardConformingStrings() *wrappers.BoolValue {
if m != nil {
return m.StandardConformingStrings
}
return nil
}
func (m *PostgresqlHostConfig11) GetSynchronizeSeqscans() *wrappers.BoolValue {
if m != nil {
return m.SynchronizeSeqscans
}
return nil
}
func (m *PostgresqlHostConfig11) GetTransformNullEquals() *wrappers.BoolValue {
if m != nil {
return m.TransformNullEquals
}
return nil
}
func (m *PostgresqlHostConfig11) GetExitOnError() *wrappers.BoolValue {
if m != nil {
return m.ExitOnError
}
return nil
}
func (m *PostgresqlHostConfig11) GetSeqPageCost() *wrappers.DoubleValue {
if m != nil {
return m.SeqPageCost
}
return nil
}
func (m *PostgresqlHostConfig11) GetRandomPageCost() *wrappers.DoubleValue {
if m != nil {
return m.RandomPageCost
}
return nil
}
func init() {
proto.RegisterType((*PostgresqlHostConfig11)(nil), "yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11")
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_ConstraintExclusion", PostgresqlHostConfig11_ConstraintExclusion_name, PostgresqlHostConfig11_ConstraintExclusion_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_ForceParallelMode", PostgresqlHostConfig11_ForceParallelMode_name, PostgresqlHostConfig11_ForceParallelMode_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_LogLevel", PostgresqlHostConfig11_LogLevel_name, PostgresqlHostConfig11_LogLevel_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_LogErrorVerbosity", PostgresqlHostConfig11_LogErrorVerbosity_name, PostgresqlHostConfig11_LogErrorVerbosity_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_LogStatement", PostgresqlHostConfig11_LogStatement_name, PostgresqlHostConfig11_LogStatement_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_TransactionIsolation", PostgresqlHostConfig11_TransactionIsolation_name, PostgresqlHostConfig11_TransactionIsolation_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_ByteaOutput", PostgresqlHostConfig11_ByteaOutput_name, PostgresqlHostConfig11_ByteaOutput_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_XmlBinary", PostgresqlHostConfig11_XmlBinary_name, PostgresqlHostConfig11_XmlBinary_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_XmlOption", PostgresqlHostConfig11_XmlOption_name, PostgresqlHostConfig11_XmlOption_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig11_BackslashQuote", PostgresqlHostConfig11_BackslashQuote_name, PostgresqlHostConfig11_BackslashQuote_value)
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/postgresql/v1/config/host11.proto", fileDescriptor_host11_bb5f848b388f9f62)
}
var fileDescriptor_host11_bb5f848b388f9f62 = []byte{
// 2178 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x99, 0x5b, 0x6f, 0xdb, 0xc8,
0x15, 0xc7, 0x2b, 0x3b, 0x9b, 0xcb, 0xf8, 0x46, 0x8d, 0x7c, 0x61, 0xec, 0x5c, 0x95, 0x4b, 0xb3,
0xdb, 0x5a, 0x8e, 0x1c, 0x37, 0x1b, 0x60, 0xd1, 0xc5, 0x52, 0x12, 0xe5, 0xa8, 0xa5, 0x44, 0x85,
0xa4, 0x1d, 0x6f, 0x8a, 0xc5, 0x60, 0x44, 0x8e, 0x24, 0x36, 0x43, 0x0e, 0xcd, 0xa1, 0x7c, 0x29,
0x50, 0xf4, 0xa5, 0x4f, 0x7d, 0xec, 0x43, 0x81, 0xf6, 0x0b, 0xe5, 0x9b, 0xf4, 0x13, 0xf4, 0x29,
0x4f, 0xc5, 0x90, 0xa2, 0x2e, 0xb6, 0x5a, 0x1a, 0xeb, 0xbc, 0x45, 0x67, 0xce, 0xff, 0x77, 0x0e,
0xe7, 0x9c, 0x21, 0xcf, 0xc4, 0x60, 0xf7, 0x1c, 0xfb, 0x0e, 0x39, 0xdb, 0xb1, 0x29, 0x1b, 0x38,
0x3b, 0x9e, 0xd3, 0xd9, 0x09, 0x18, 0x8f, 0x7a, 0x21, 0xe1, 0xc7, 0x74, 0xe7, 0xa4, 0xbc, 0x63,
0x33, 0xbf, 0xeb, 0xf6, 0x76, 0xfa, 0x8c, 0x47, 0xe5, 0x72, 0x29, 0x08, 0x59, 0xc4, 0xe0, 0xb3,
0x44, 0x53, 0x8a, 0x35, 0x25, 0xcf, 0xe9, 0x94, 0xc6, 0x9a, 0xd2, 0x49, 0xb9, 0x94, 0x68, 0x36,
0x1f, 0xf4, 0x18, 0xeb, 0x51, 0xb2, 0x13, 0x8b, 0x3a, 0x83, 0xee, 0xce, 0x69, 0x88, 0x83, 0x80,
0x84, 0x3c, 0xc1, 0x6c, 0xde, 0x9f, 0x0a, 0x7d, 0x82, 0xa9, 0xeb, 0xe0, 0xc8, 0x65, 0x7e, 0xb2,
0x5c, 0xfc, 0x4f, 0x09, 0xac, 0xb7, 0x47, 0xdc, 0xb7, 0x8c, 0x47, 0xd5, 0x98, 0x5b, 0x2e, 0x43,
0x0b, 0xc8, 0x21, 0xb1, 0xd9, 0x09, 0x09, 0xcf, 0x91, 0xe7, 0xfa, 0x08, 0x07, 0x01, 0x3d, 0x47,
0x0e, 0xa1, 0xf8, 0x5c, 0xce, 0x3d, 0xca, 0xbd, 0x58, 0xd8, 0xdd, 0x2a, 0x25, 0xc1, 0x4b, 0x69,
0xf0, 0x52, 0xc3, 0x8f, 0x5e, 0xef, 0x1d, 0x62, 0x3a, 0x20, 0xc6, 0x5a, 0x2a, 0x6e, 0xba, 0xbe,
0x22, 0xa4, 0x35, 0xa1, 0x84, 0x15, 0xb0, 0xcc, 0xfb, 0x38, 0x24, 0x0e, 0xea, 0x0c, 0xba, 0x5d,
0x12, 0x72, 0x79, 0x2e, 0x9b, 0xb5, 0x94, 0x48, 0x2a, 0x89, 0x02, 0x7e, 0x0f, 0x16, 0x23, 0xe2,
0x05, 0x23, 0xc2, 0x7c, 0x36, 0x61, 0x41, 0x08, 0x52, 0xfd, 0x6b, 0x70, 0xfb, 0x94, 0x85, 0x1f,
0x91, 0x47, 0x3c, 0xf9, 0x46, 0xb6, 0xf6, 0x96, 0x70, 0x6e, 0x12, 0x0f, 0x56, 0xc1, 0x4a, 0x1c,
0xb7, 0xeb, 0x52, 0x82, 0xa8, 0xeb, 0xb9, 0x91, 0xfc, 0xd5, 0x15, 0x92, 0x17, 0x9a, 0xba, 0x4b,
0x89, 0x26, 0x14, 0xf0, 0x3d, 0x28, 0x74, 0xb0, 0xfd, 0x91, 0xf8, 0x0e, 0xea, 0xd2, 0x01, 0xef,
0x23, 0xdc, 0x8d, 0x48, 0x28, 0xdf, 0xcc, 0x04, 0x55, 0xc0, 0xe7, 0x4f, 0xe5, 0x9b, 0x2f, 0xb7,
0x77, 0x5f, 0xee, 0xbd, 0x31, 0xf2, 0x43, 0x46, 0x5d, 0x20, 0x14, 0x41, 0x80, 0x08, 0xac, 0x33,
0xea, 0x20, 0xee, 0xe3, 0x80, 0xf7, 0x59, 0x84, 0xa2, 0x7e, 0x48, 0x78, 0x9f, 0x51, 0x47, 0xbe,
0x95, 0xcd, 0x5e, 0xfc, 0xfc, 0xa9, 0x7c, 0x7b, 0xbb, 0xbc, 0xfd, 0xe6, 0xf5, 0xde, 0xcb, 0x97,
0xc6, 0x2a, 0xa3, 0x8e, 0x39, 0xe4, 0x58, 0x29, 0x06, 0x7e, 0x00, 0x5b, 0x1e, 0x3e, 0x43, 0x3c,
0xc2, 0xbe, 0xd3, 0x39, 0x47, 0x3c, 0x0a, 0x09, 0xf6, 0x5c, 0xbf, 0x37, 0xec, 0x89, 0xdb, 0xd9,
0x5b, 0x21, 0x7b, 0xf8, 0xcc, 0x4c, 0xe4, 0x66, 0xaa, 0x4e, 0xda, 0xe2, 0xaf, 0x39, 0xb0, 0x6a,
0x33, 0x9f, 0x47, 0x21, 0x76, 0xfd, 0x08, 0x91, 0x33, 0x9b, 0x0e, 0xb8, 0xcb, 0x7c, 0xf9, 0xce,
0xa3, 0xdc, 0x8b, 0xe5, 0xdd, 0x77, 0xa5, 0x2b, 0x9d, 0x86, 0xd2, 0xec, 0x56, 0x2e, 0x55, 0x47,
0x64, 0x35, 0x05, 0x1b, 0x05, 0xfb, 0xb2, 0x11, 0xb6, 0xc1, 0x9a, 0x3d, 0x08, 0x39, 0x0b, 0x51,
0x34, 0x08, 0x28, 0x41, 0xdd, 0x10, 0xdb, 0xe2, 0xb4, 0xc8, 0x20, 0x7e, 0xb8, 0x7b, 0x97, 0x1e,
0xae, 0xc6, 0x06, 0x1d, 0x4a, 0x92, 0xa7, 0x2b, 0x24, 0x52, 0x4b, 0x28, 0xeb, 0x43, 0x21, 0xfc,
0x09, 0x14, 0xba, 0x21, 0xf3, 0x90, 0xcd, 0x28, 0xc5, 0x01, 0x4f, 0xfb, 0x66, 0x21, 0xbb, 0x24,
0xd2, 0xe7, 0x4f, 0xe5, 0xc5, 0xf2, 0xf6, 0x6e, 0x79, 0xef, 0xdb, 0xbd, 0x37, 0xaf, 0x5e, 0xef,
0x7d, 0x6b, 0xe4, 0x05, 0xa9, 0x3a, 0x04, 0x25, 0xdd, 0xf4, 0x13, 0x28, 0xfc, 0x91, 0xb9, 0xfe,
0x45, 0xfc, 0xe2, 0xcf, 0xc2, 0x0b, 0xd2, 0x34, 0xfe, 0x2f, 0xa0, 0xd0, 0x65, 0xa1, 0x4d, 0x50,
0x80, 0x43, 0x4c, 0x29, 0xa1, 0xc8, 0x63, 0x0e, 0x91, 0x97, 0xe2, 0xa2, 0xe8, 0xd7, 0x2b, 0x4a,
0x5d, 0x80, 0xdb, 0x43, 0x6e, 0x93, 0x39, 0xc4, 0xc8, 0x77, 0x2f, 0x9a, 0xe0, 0x09, 0x28, 0xd8,
0xd4, 0x25, 0x7e, 0x14, 0xbf, 0x82, 0x3c, 0xc2, 0x39, 0xee, 0x11, 0x2e, 0x2f, 0xc7, 0x09, 0xd4,
0xaf, 0x97, 0x80, 0xc6, 0x7a, 0x1a, 0x39, 0x21, 0xd4, 0xc8, 0x27, 0x21, 0x9a, 0xae, 0xdf, 0x1c,
0x06, 0x80, 0x01, 0x90, 0x28, 0xeb, 0x4d, 0x07, 0x5d, 0xf9, 0xa2, 0x41, 0x97, 0x29, 0xeb, 0x4d,
0x46, 0xfc, 0x33, 0xd8, 0x48, 0x23, 0x92, 0x30, 0x64, 0xa1, 0x38, 0x67, 0x11, 0xf1, 0x88, 0x1f,
0xc9, 0xd2, 0x17, 0x0d, 0xbc, 0x9a, 0x04, 0x56, 0x45, 0x10, 0x33, 0x8d, 0x01, 0x8f, 0xc0, 0x66,
0x1a, 0xde, 0x19, 0x84, 0xf1, 0x27, 0x62, 0x22, 0x83, 0x7c, 0xf6, 0xd9, 0xde, 0x48, 0xb0, 0xb5,
0xa1, 0x78, 0x4c, 0xae, 0x82, 0x15, 0x41, 0xb6, 0xfb, 0xc4, 0xfe, 0x18, 0x30, 0xd7, 0x8f, 0xb8,
0x0c, 0x63, 0xdc, 0xe6, 0x25, 0x5c, 0x85, 0x31, 0x9a, 0xd0, 0xc4, 0xee, 0x54, 0xc7, 0x8a, 0x11,
0x84, 0xf9, 0x3e, 0x89, 0x0f, 0x16, 0x97, 0x0b, 0x57, 0x83, 0x8c, 0x15, 0xb0, 0x01, 0xa0, 0x80,
0x38, 0x2e, 0x9f, 0xe4, 0xac, 0x66, 0x72, 0xf2, 0x94, 0xf5, 0x6a, 0x53, 0x22, 0xf8, 0x5b, 0xb0,
0x18, 0xa3, 0x86, 0x4f, 0x2b, 0xaf, 0x65, 0x42, 0x16, 0x04, 0x64, 0xe8, 0x2e, 0xce, 0x95, 0x90,
0x27, 0x85, 0x3e, 0x21, 0x61, 0x87, 0x71, 0x37, 0x3a, 0x97, 0xd7, 0xbf, 0xc4, 0xb9, 0xd2, 0x58,
0x2f, 0xae, 0xed, 0x61, 0x8a, 0x8d, 0xf3, 0x9f, 0x36, 0xc1, 0x1f, 0x80, 0xd8, 0x1c, 0x44, 0x99,
0xfd, 0x11, 0x9d, 0x62, 0x37, 0xe2, 0xf2, 0x46, 0xe6, 0x13, 0x88, 0x27, 0xd6, 0x98, 0xfd, 0xf1,
0xbd, 0xf0, 0x87, 0x0c, 0x2c, 0x09, 0xc2, 0xb8, 0x47, 0xe4, 0x38, 0xf9, 0xdf, 0x5d, 0x3b, 0xf9,
0x51, 0xe7, 0xc4, 0x01, 0xc7, 0x7d, 0xa4, 0x24, 0x29, 0x8f, 0xbe, 0xc0, 0x5c, 0xbe, 0x9b, 0xdd,
0x95, 0x02, 0x61, 0x0d, 0xbf, 0xbf, 0x1c, 0x3e, 0x04, 0x0b, 0x9c, 0xe0, 0xd0, 0xee, 0xa3, 0x00,
0x47, 0x7d, 0x79, 0xf3, 0x51, 0xee, 0xc5, 0x1d, 0x03, 0x24, 0xa6, 0x36, 0x8e, 0xfa, 0xa2, 0xac,
0x21, 0x3b, 0x45, 0x9c, 0xd8, 0x83, 0x50, 0x14, 0x64, 0x2b, 0xbb, 0xac, 0x21, 0x3b, 0x35, 0x87,
0xee, 0xf0, 0x1f, 0x39, 0x70, 0xdf, 0x21, 0x5d, 0x3c, 0xa0, 0x11, 0x8a, 0x42, 0xec, 0xf3, 0xe4,
0x23, 0x80, 0x5c, 0xce, 0x68, 0xd2, 0x27, 0xf7, 0xe2, 0x4d, 0x32, 0xae, 0xb7, 0x49, 0xd6, 0x18,
0xdd, 0x48, 0xc9, 0xc6, 0xd6, 0x30, 0xf0, 0xac, 0x45, 0xf8, 0x16, 0xe4, 0x47, 0x85, 0x42, 0x91,
0xeb, 0x11, 0x36, 0x88, 0xe4, 0xfb, 0xd9, 0xdb, 0x27, 0x8d, 0x54, 0x56, 0x22, 0x12, 0xb3, 0x57,
0xdc, 0x34, 0x29, 0xe4, 0xc1, 0x15, 0x66, 0x2f, 0x21, 0x48, 0xf5, 0x2e, 0x78, 0xe2, 0x3a, 0x94,
0x20, 0xd7, 0x9f, 0xda, 0x21, 0x4e, 0xb8, 0xf8, 0x00, 0x8f, 0xb0, 0x0f, 0xb3, 0xb1, 0x0f, 0x05,
0xa7, 0xe1, 0x4f, 0x3c, 0xaf, 0x99, 0x40, 0xd2, 0x50, 0x14, 0x2c, 0x76, 0xce, 0x23, 0x82, 0x11,
0x1b, 0x44, 0xc1, 0x20, 0x92, 0x1f, 0xc5, 0x7b, 0xdf, 0xb8, 0xde, 0xde, 0x57, 0x04, 0x51, 0x8f,
0x81, 0xc6, 0x42, 0x67, 0xfc, 0x03, 0x12, 0x70, 0xe7, 0xcc, 0xa3, 0x1d, 0xd7, 0xc7, 0xe1, 0xb9,
0xfc, 0x38, 0x0e, 0xb5, 0x7f, 0xbd, 0x50, 0x47, 0x1e, 0xad, 0xc4, 0x38, 0x63, 0x4c, 0x1e, 0x86,
0x61, 0x41, 0xdc, 0x4d, 0xc5, 0x2f, 0x14, 0x46, 0x8f, 0x71, 0xc6, 0x98, 0x0c, 0xdb, 0x60, 0xbd,
0xe7, 0xfa, 0x28, 0x20, 0xbe, 0x23, 0x26, 0x3c, 0xea, 0xf2, 0x68, 0x38, 0x5a, 0x3c, 0xc9, 0xae,
0x4c, 0xa1, 0xe7, 0xfa, 0xed, 0x44, 0xa9, 0xb9, 0x3c, 0x4a, 0x46, 0x89, 0x3a, 0x90, 0x1c, 0x82,
0x9d, 0xa9, 0xe6, 0x79, 0x9a, 0xcd, 0x5a, 0x49, 0x45, 0x69, 0x55, 0x0f, 0xc1, 0x5d, 0x31, 0x85,
0x0a, 0x13, 0x47, 0x01, 0x09, 0x27, 0xdb, 0x48, 0x7e, 0x96, 0x0d, 0x5c, 0xf7, 0xf0, 0x99, 0x78,
0x8b, 0xf1, 0x36, 0x09, 0x27, 0x7a, 0x07, 0x22, 0xf0, 0x40, 0x70, 0x03, 0x71, 0x35, 0x99, 0x0d,
0x7f, 0x9e, 0x0d, 0xdf, 0xf4, 0xf0, 0x59, 0x3b, 0x24, 0xce, 0xac, 0x00, 0xdf, 0x81, 0x05, 0x1c,
0x86, 0xf8, 0x1c, 0xf9, 0x03, 0x4a, 0xb9, 0xfc, 0xcb, 0xcc, 0x57, 0x0b, 0x88, 0xdd, 0x5b, 0xc2,
0x1b, 0x0e, 0xc0, 0x8a, 0x98, 0xf8, 0x39, 0xc5, 0xbc, 0x8f, 0x8e, 0x07, 0x2c, 0x22, 0xf2, 0x8b,
0xb8, 0xf8, 0xda, 0x35, 0xdb, 0x39, 0x85, 0xbe, 0x13, 0x4c, 0x63, 0xb9, 0x33, 0xf5, 0x1b, 0xd6,
0x41, 0x3e, 0x7d, 0x9f, 0x9d, 0xba, 0x51, 0x1f, 0x31, 0xd7, 0xe1, 0xf2, 0xd7, 0x99, 0x99, 0xaf,
0x0c, 0x45, 0xef, 0xdd, 0xa8, 0xaf, 0xbb, 0x0e, 0x87, 0x2d, 0xb0, 0x46, 0xb8, 0x8d, 0x03, 0x22,
0x6e, 0x0d, 0xa2, 0xa1, 0x4e, 0x71, 0xe8, 0xbb, 0x7e, 0x4f, 0xfe, 0x26, 0x93, 0x55, 0x48, 0x84,
0x66, 0xac, 0x7b, 0x9f, 0xc8, 0xa0, 0x06, 0x56, 0x29, 0x43, 0x36, 0xf3, 0x02, 0x1c, 0xa1, 0x20,
0x74, 0x4f, 0x5c, 0x4a, 0xc4, 0x88, 0xf6, 0xab, 0x4c, 0x1c, 0xa4, 0xac, 0x1a, 0xcb, 0xda, 0x23,
0x95, 0xb8, 0xd8, 0xb0, 0x80, 0x84, 0x38, 0x62, 0xa1, 0xa8, 0xbf, 0x4d, 0x1c, 0xe2, 0xdb, 0x64,
0x94, 0xe3, 0xaf, 0x33, 0xa1, 0x77, 0x53, 0x79, 0x7b, 0xa4, 0x4e, 0x33, 0x6d, 0x81, 0xb5, 0xb8,
0x5c, 0x08, 0x53, 0x8a, 0x5c, 0x87, 0xf8, 0x91, 0xdb, 0x75, 0xc5, 0xa5, 0x75, 0x3b, 0xfb, 0xc9,
0x63, 0xa1, 0x42, 0x69, 0x63, 0x2c, 0x13, 0xb9, 0xc6, 0x17, 0x30, 0x1c, 0x3a, 0x62, 0x1a, 0xea,
0xb2, 0x30, 0xbe, 0x82, 0x25, 0xdb, 0xca, 0xe5, 0x52, 0x76, 0xae, 0xa9, 0xbc, 0x3a, 0x52, 0x27,
0x7b, 0xcb, 0x61, 0x13, 0xac, 0xf2, 0x73, 0xdf, 0xee, 0x87, 0xcc, 0x77, 0xff, 0x44, 0x10, 0x27,
0xc7, 0xdc, 0xc6, 0x3e, 0x97, 0x77, 0xb2, 0x53, 0x9d, 0xd0, 0x99, 0x43, 0x99, 0x78, 0xf4, 0xf8,
0xf8, 0x88, 0x28, 0x71, 0xd3, 0x23, 0x72, 0x3c, 0xc0, 0x94, 0xcb, 0x2f, 0xb3, 0x79, 0x23, 0xa1,
0x68, 0x7f, 0x35, 0x96, 0xc1, 0xef, 0xc1, 0x12, 0x39, 0x73, 0x23, 0xc4, 0x86, 0x13, 0xb2, 0x5c,
0xce, 0xfe, 0x3a, 0x0b, 0x81, 0x9e, 0xcc, 0xba, 0xf0, 0x07, 0xb0, 0xc4, 0xc9, 0x31, 0x0a, 0x70,
0x8f, 0x20, 0x9b, 0xf1, 0x48, 0xde, 0xbd, 0xc2, 0xa5, 0x6e, 0x81, 0x93, 0xe3, 0x36, 0xee, 0x91,
0x2a, 0xe3, 0xf1, 0x3b, 0x2c, 0xc4, 0xbe, 0xc3, 0xbc, 0x09, 0xc8, 0xab, 0x2b, 0x40, 0x96, 0x13,
0x55, 0xca, 0x29, 0xfe, 0x2b, 0x07, 0x0a, 0x33, 0xee, 0xa4, 0xf0, 0x29, 0x78, 0x54, 0xd5, 0x5b,
0xa6, 0x65, 0x28, 0x8d, 0x96, 0x85, 0xd4, 0xa3, 0xaa, 0x76, 0x60, 0x36, 0xf4, 0x16, 0x3a, 0x68,
0x99, 0x6d, 0xb5, 0xda, 0xa8, 0x37, 0xd4, 0x9a, 0xf4, 0x0b, 0xb8, 0x05, 0x36, 0x66, 0x7a, 0xe9,
0x2d, 0x29, 0x07, 0xef, 0x01, 0x79, 0xf6, 0x62, 0xbd, 0x2e, 0xcd, 0xc1, 0x22, 0x78, 0x30, 0x73,
0xb5, 0xad, 0x18, 0x56, 0xc3, 0x6a, 0xe8, 0x2d, 0x69, 0xbe, 0xf8, 0xf7, 0x1c, 0xc8, 0x5f, 0xba,
0x9b, 0xc1, 0x27, 0xe0, 0x61, 0x5d, 0x37, 0xaa, 0xaa, 0x70, 0x55, 0x34, 0x4d, 0xd5, 0x50, 0x53,
0xaf, 0xa9, 0x17, 0x32, 0xdb, 0x04, 0xeb, 0xb3, 0x9c, 0xe2, 0xc4, 0xb6, 0xc0, 0xc6, 0xcc, 0xb5,
0x38, 0xaf, 0x87, 0x60, 0x6b, 0xd6, 0xa2, 0xa1, 0xee, 0x1b, 0xaa, 0x69, 0x8a, 0xa4, 0xe6, 0xc0,
0xed, 0xf4, 0x06, 0x03, 0xef, 0x82, 0x35, 0x4d, 0xdf, 0x47, 0x9a, 0x7a, 0xa8, 0x6a, 0x17, 0x32,
0x58, 0x05, 0xd2, 0x78, 0xa9, 0xa6, 0x56, 0x0e, 0xf6, 0x7f, 0x23, 0xe5, 0x66, 0x58, 0xf7, 0xa4,
0xb9, 0x19, 0xd6, 0x57, 0xd2, 0xfc, 0x0c, 0xeb, 0xae, 0x74, 0x63, 0x86, 0xb5, 0x2c, 0x7d, 0x05,
0xf3, 0x60, 0x69, 0x6c, 0xd5, 0xf4, 0x7d, 0xe9, 0xe6, 0xb4, 0x63, 0x4b, 0xb7, 0x1a, 0x55, 0x55,
0xba, 0x05, 0xd7, 0x40, 0x7e, 0x6c, 0x7d, 0xaf, 0x18, 0xad, 0x46, 0x6b, 0x5f, 0xba, 0x0d, 0x0b,
0x60, 0x65, 0x6c, 0x56, 0x0d, 0x43, 0x37, 0xa4, 0x3b, 0xd3, 0xc6, 0xba, 0x62, 0x29, 0x9a, 0x04,
0xa6, 0x8d, 0x6d, 0xa5, 0xd5, 0xa8, 0x4a, 0x0b, 0xc5, 0x7f, 0xe6, 0x40, 0xfe, 0xd2, 0xb4, 0x2f,
0x2a, 0x25, 0x5c, 0x63, 0x1c, 0x3a, 0x54, 0x8d, 0x8a, 0x6e, 0x36, 0xac, 0x1f, 0x2f, 0xec, 0xd3,
0x7d, 0x70, 0x77, 0x96, 0x93, 0xa5, 0x1a, 0xa6, 0x2a, 0xe5, 0x44, 0x3d, 0x66, 0x2d, 0xd7, 0xd4,
0xba, 0x72, 0xa0, 0x59, 0x49, 0xc1, 0x66, 0x39, 0x24, 0xff, 0x52, 0xa5, 0xf9, 0xe2, 0xdf, 0x72,
0x60, 0x71, 0x72, 0x98, 0x4f, 0x23, 0x9a, 0x96, 0x62, 0xa9, 0x4d, 0xb5, 0x65, 0x5d, 0x48, 0x68,
0x1d, 0xc0, 0xe9, 0xe5, 0x96, 0xde, 0x12, 0x99, 0x0c, 0x77, 0x6e, 0x6c, 0xaf, 0xd5, 0x34, 0x69,
0xee, 0xb2, 0xb9, 0xa9, 0xd7, 0xa4, 0xf9, 0xcb, 0x66, 0x45, 0xd3, 0xa4, 0x1b, 0xc5, 0x7f, 0xe7,
0xc0, 0xea, 0xcc, 0xb9, 0xf8, 0x19, 0x78, 0x6c, 0x19, 0x4a, 0xcb, 0x54, 0xaa, 0xa2, 0xf9, 0x51,
0xc3, 0xd4, 0x35, 0xc5, 0xba, 0x7c, 0xe2, 0xbe, 0x01, 0xcf, 0x67, 0xbb, 0x19, 0xaa, 0x52, 0x43,
0x07, 0xad, 0xaa, 0xde, 0x6c, 0x36, 0x2c, 0x4b, 0xad, 0x49, 0x39, 0xf8, 0x02, 0x3c, 0xfd, 0x3f,
0xbe, 0x63, 0xcf, 0x39, 0xf8, 0x35, 0x78, 0xf6, 0xbf, 0x3c, 0xdb, 0xaa, 0x62, 0x29, 0x15, 0x4d,
0x8d, 0x45, 0xd2, 0x3c, 0x7c, 0x0e, 0x8a, 0xb3, 0x5d, 0x4d, 0xd5, 0x68, 0x28, 0x5a, 0xe3, 0x83,
0x70, 0x96, 0x6e, 0x14, 0xff, 0x00, 0x16, 0x26, 0x06, 0x54, 0xf1, 0x32, 0xa8, 0xfc, 0x68, 0xa9,
0x0a, 0xd2, 0x0f, 0xac, 0xf6, 0x81, 0x75, 0xf9, 0xac, 0x4c, 0xad, 0xbe, 0x55, 0x8f, 0xa4, 0x1c,
0x94, 0xc1, 0xea, 0x94, 0x55, 0x35, 0xab, 0x4a, 0x5b, 0xe4, 0x5b, 0x34, 0xc0, 0x9d, 0xd1, 0x48,
0x2a, 0x8e, 0xfa, 0x51, 0x53, 0x43, 0x95, 0x46, 0x4b, 0x31, 0x2e, 0x36, 0xd7, 0x1a, 0xc8, 0x4f,
0xac, 0x55, 0x14, 0x53, 0x7d, 0xbd, 0x27, 0xe5, 0x20, 0x04, 0xcb, 0x13, 0x66, 0x11, 0x6d, 0xae,
0x78, 0x14, 0x33, 0x93, 0xf9, 0x33, 0x65, 0xea, 0xed, 0x19, 0x25, 0xd8, 0x00, 0x85, 0x89, 0xb5,
0x9a, 0x5e, 0x3d, 0x10, 0xf5, 0x95, 0x72, 0xa2, 0x71, 0x26, 0x16, 0xaa, 0x7a, 0xcb, 0x12, 0xf6,
0x39, 0xf1, 0x8e, 0x5d, 0x9e, 0x9e, 0x6e, 0x44, 0xd3, 0x56, 0x94, 0xea, 0xef, 0x4d, 0x4d, 0x31,
0xdf, 0xa2, 0x77, 0x07, 0xba, 0x75, 0xf1, 0xfd, 0x55, 0x00, 0x2b, 0x17, 0x1c, 0x92, 0x00, 0x17,
0x55, 0x7a, 0x4b, 0x9a, 0x13, 0x19, 0x5d, 0xb2, 0xd7, 0xeb, 0xd2, 0x3c, 0x7c, 0x0c, 0xee, 0x5f,
0x5c, 0x30, 0x95, 0xba, 0x8a, 0xd4, 0x56, 0x55, 0xaf, 0x89, 0x83, 0x7f, 0xa3, 0x72, 0xf8, 0xc1,
0xea, 0xb9, 0x51, 0x7f, 0xd0, 0x29, 0xd9, 0xcc, 0xdb, 0x49, 0x26, 0xb8, 0xed, 0xe4, 0xbf, 0xe8,
0x7b, 0x6c, 0xbb, 0x47, 0xfc, 0xf8, 0x33, 0xb2, 0x73, 0xa5, 0x3f, 0x1b, 0x7c, 0x37, 0x36, 0x76,
0x6e, 0xc6, 0xba, 0x57, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x9a, 0x16, 0x37, 0xd9, 0x71, 0x18,
0x00, 0x00,
}

955
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/config/host9_6.pb.go generated vendored Normal file
View File

@ -0,0 +1,955 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/postgresql/v1/config/host9_6.proto
package postgresql // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/config"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import wrappers "github.com/golang/protobuf/ptypes/wrappers"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type PostgresqlHostConfig9_6_ConstraintExclusion int32
const (
PostgresqlHostConfig9_6_CONSTRAINT_EXCLUSION_UNSPECIFIED PostgresqlHostConfig9_6_ConstraintExclusion = 0
PostgresqlHostConfig9_6_CONSTRAINT_EXCLUSION_ON PostgresqlHostConfig9_6_ConstraintExclusion = 1
PostgresqlHostConfig9_6_CONSTRAINT_EXCLUSION_OFF PostgresqlHostConfig9_6_ConstraintExclusion = 2
PostgresqlHostConfig9_6_CONSTRAINT_EXCLUSION_PARTITION PostgresqlHostConfig9_6_ConstraintExclusion = 3
)
var PostgresqlHostConfig9_6_ConstraintExclusion_name = map[int32]string{
0: "CONSTRAINT_EXCLUSION_UNSPECIFIED",
1: "CONSTRAINT_EXCLUSION_ON",
2: "CONSTRAINT_EXCLUSION_OFF",
3: "CONSTRAINT_EXCLUSION_PARTITION",
}
var PostgresqlHostConfig9_6_ConstraintExclusion_value = map[string]int32{
"CONSTRAINT_EXCLUSION_UNSPECIFIED": 0,
"CONSTRAINT_EXCLUSION_ON": 1,
"CONSTRAINT_EXCLUSION_OFF": 2,
"CONSTRAINT_EXCLUSION_PARTITION": 3,
}
func (x PostgresqlHostConfig9_6_ConstraintExclusion) String() string {
return proto.EnumName(PostgresqlHostConfig9_6_ConstraintExclusion_name, int32(x))
}
func (PostgresqlHostConfig9_6_ConstraintExclusion) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host9_6_bf21c75a83cd3758, []int{0, 0}
}
type PostgresqlHostConfig9_6_ForceParallelMode int32
const (
PostgresqlHostConfig9_6_FORCE_PARALLEL_MODE_UNSPECIFIED PostgresqlHostConfig9_6_ForceParallelMode = 0
PostgresqlHostConfig9_6_FORCE_PARALLEL_MODE_ON PostgresqlHostConfig9_6_ForceParallelMode = 1
PostgresqlHostConfig9_6_FORCE_PARALLEL_MODE_OFF PostgresqlHostConfig9_6_ForceParallelMode = 2
PostgresqlHostConfig9_6_FORCE_PARALLEL_MODE_REGRESS PostgresqlHostConfig9_6_ForceParallelMode = 3
)
var PostgresqlHostConfig9_6_ForceParallelMode_name = map[int32]string{
0: "FORCE_PARALLEL_MODE_UNSPECIFIED",
1: "FORCE_PARALLEL_MODE_ON",
2: "FORCE_PARALLEL_MODE_OFF",
3: "FORCE_PARALLEL_MODE_REGRESS",
}
var PostgresqlHostConfig9_6_ForceParallelMode_value = map[string]int32{
"FORCE_PARALLEL_MODE_UNSPECIFIED": 0,
"FORCE_PARALLEL_MODE_ON": 1,
"FORCE_PARALLEL_MODE_OFF": 2,
"FORCE_PARALLEL_MODE_REGRESS": 3,
}
func (x PostgresqlHostConfig9_6_ForceParallelMode) String() string {
return proto.EnumName(PostgresqlHostConfig9_6_ForceParallelMode_name, int32(x))
}
func (PostgresqlHostConfig9_6_ForceParallelMode) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host9_6_bf21c75a83cd3758, []int{0, 1}
}
type PostgresqlHostConfig9_6_LogLevel int32
const (
PostgresqlHostConfig9_6_LOG_LEVEL_UNSPECIFIED PostgresqlHostConfig9_6_LogLevel = 0
PostgresqlHostConfig9_6_LOG_LEVEL_DEBUG5 PostgresqlHostConfig9_6_LogLevel = 1
PostgresqlHostConfig9_6_LOG_LEVEL_DEBUG4 PostgresqlHostConfig9_6_LogLevel = 2
PostgresqlHostConfig9_6_LOG_LEVEL_DEBUG3 PostgresqlHostConfig9_6_LogLevel = 3
PostgresqlHostConfig9_6_LOG_LEVEL_DEBUG2 PostgresqlHostConfig9_6_LogLevel = 4
PostgresqlHostConfig9_6_LOG_LEVEL_DEBUG1 PostgresqlHostConfig9_6_LogLevel = 5
PostgresqlHostConfig9_6_LOG_LEVEL_LOG PostgresqlHostConfig9_6_LogLevel = 6
PostgresqlHostConfig9_6_LOG_LEVEL_NOTICE PostgresqlHostConfig9_6_LogLevel = 7
PostgresqlHostConfig9_6_LOG_LEVEL_WARNING PostgresqlHostConfig9_6_LogLevel = 8
PostgresqlHostConfig9_6_LOG_LEVEL_ERROR PostgresqlHostConfig9_6_LogLevel = 9
PostgresqlHostConfig9_6_LOG_LEVEL_FATAL PostgresqlHostConfig9_6_LogLevel = 10
PostgresqlHostConfig9_6_LOG_LEVEL_PANIC PostgresqlHostConfig9_6_LogLevel = 11
)
var PostgresqlHostConfig9_6_LogLevel_name = map[int32]string{
0: "LOG_LEVEL_UNSPECIFIED",
1: "LOG_LEVEL_DEBUG5",
2: "LOG_LEVEL_DEBUG4",
3: "LOG_LEVEL_DEBUG3",
4: "LOG_LEVEL_DEBUG2",
5: "LOG_LEVEL_DEBUG1",
6: "LOG_LEVEL_LOG",
7: "LOG_LEVEL_NOTICE",
8: "LOG_LEVEL_WARNING",
9: "LOG_LEVEL_ERROR",
10: "LOG_LEVEL_FATAL",
11: "LOG_LEVEL_PANIC",
}
var PostgresqlHostConfig9_6_LogLevel_value = map[string]int32{
"LOG_LEVEL_UNSPECIFIED": 0,
"LOG_LEVEL_DEBUG5": 1,
"LOG_LEVEL_DEBUG4": 2,
"LOG_LEVEL_DEBUG3": 3,
"LOG_LEVEL_DEBUG2": 4,
"LOG_LEVEL_DEBUG1": 5,
"LOG_LEVEL_LOG": 6,
"LOG_LEVEL_NOTICE": 7,
"LOG_LEVEL_WARNING": 8,
"LOG_LEVEL_ERROR": 9,
"LOG_LEVEL_FATAL": 10,
"LOG_LEVEL_PANIC": 11,
}
func (x PostgresqlHostConfig9_6_LogLevel) String() string {
return proto.EnumName(PostgresqlHostConfig9_6_LogLevel_name, int32(x))
}
func (PostgresqlHostConfig9_6_LogLevel) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host9_6_bf21c75a83cd3758, []int{0, 2}
}
type PostgresqlHostConfig9_6_LogErrorVerbosity int32
const (
PostgresqlHostConfig9_6_LOG_ERROR_VERBOSITY_UNSPECIFIED PostgresqlHostConfig9_6_LogErrorVerbosity = 0
PostgresqlHostConfig9_6_LOG_ERROR_VERBOSITY_TERSE PostgresqlHostConfig9_6_LogErrorVerbosity = 1
PostgresqlHostConfig9_6_LOG_ERROR_VERBOSITY_DEFAULT PostgresqlHostConfig9_6_LogErrorVerbosity = 2
PostgresqlHostConfig9_6_LOG_ERROR_VERBOSITY_VERBOSE PostgresqlHostConfig9_6_LogErrorVerbosity = 3
)
var PostgresqlHostConfig9_6_LogErrorVerbosity_name = map[int32]string{
0: "LOG_ERROR_VERBOSITY_UNSPECIFIED",
1: "LOG_ERROR_VERBOSITY_TERSE",
2: "LOG_ERROR_VERBOSITY_DEFAULT",
3: "LOG_ERROR_VERBOSITY_VERBOSE",
}
var PostgresqlHostConfig9_6_LogErrorVerbosity_value = map[string]int32{
"LOG_ERROR_VERBOSITY_UNSPECIFIED": 0,
"LOG_ERROR_VERBOSITY_TERSE": 1,
"LOG_ERROR_VERBOSITY_DEFAULT": 2,
"LOG_ERROR_VERBOSITY_VERBOSE": 3,
}
func (x PostgresqlHostConfig9_6_LogErrorVerbosity) String() string {
return proto.EnumName(PostgresqlHostConfig9_6_LogErrorVerbosity_name, int32(x))
}
func (PostgresqlHostConfig9_6_LogErrorVerbosity) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host9_6_bf21c75a83cd3758, []int{0, 3}
}
type PostgresqlHostConfig9_6_LogStatement int32
const (
PostgresqlHostConfig9_6_LOG_STATEMENT_UNSPECIFIED PostgresqlHostConfig9_6_LogStatement = 0
PostgresqlHostConfig9_6_LOG_STATEMENT_NONE PostgresqlHostConfig9_6_LogStatement = 1
PostgresqlHostConfig9_6_LOG_STATEMENT_DDL PostgresqlHostConfig9_6_LogStatement = 2
PostgresqlHostConfig9_6_LOG_STATEMENT_MOD PostgresqlHostConfig9_6_LogStatement = 3
PostgresqlHostConfig9_6_LOG_STATEMENT_ALL PostgresqlHostConfig9_6_LogStatement = 4
)
var PostgresqlHostConfig9_6_LogStatement_name = map[int32]string{
0: "LOG_STATEMENT_UNSPECIFIED",
1: "LOG_STATEMENT_NONE",
2: "LOG_STATEMENT_DDL",
3: "LOG_STATEMENT_MOD",
4: "LOG_STATEMENT_ALL",
}
var PostgresqlHostConfig9_6_LogStatement_value = map[string]int32{
"LOG_STATEMENT_UNSPECIFIED": 0,
"LOG_STATEMENT_NONE": 1,
"LOG_STATEMENT_DDL": 2,
"LOG_STATEMENT_MOD": 3,
"LOG_STATEMENT_ALL": 4,
}
func (x PostgresqlHostConfig9_6_LogStatement) String() string {
return proto.EnumName(PostgresqlHostConfig9_6_LogStatement_name, int32(x))
}
func (PostgresqlHostConfig9_6_LogStatement) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host9_6_bf21c75a83cd3758, []int{0, 4}
}
type PostgresqlHostConfig9_6_TransactionIsolation int32
const (
PostgresqlHostConfig9_6_TRANSACTION_ISOLATION_UNSPECIFIED PostgresqlHostConfig9_6_TransactionIsolation = 0
PostgresqlHostConfig9_6_TRANSACTION_ISOLATION_READ_UNCOMMITTED PostgresqlHostConfig9_6_TransactionIsolation = 1
PostgresqlHostConfig9_6_TRANSACTION_ISOLATION_READ_COMMITTED PostgresqlHostConfig9_6_TransactionIsolation = 2
PostgresqlHostConfig9_6_TRANSACTION_ISOLATION_REPEATABLE_READ PostgresqlHostConfig9_6_TransactionIsolation = 3
PostgresqlHostConfig9_6_TRANSACTION_ISOLATION_SERIALIZABLE PostgresqlHostConfig9_6_TransactionIsolation = 4
)
var PostgresqlHostConfig9_6_TransactionIsolation_name = map[int32]string{
0: "TRANSACTION_ISOLATION_UNSPECIFIED",
1: "TRANSACTION_ISOLATION_READ_UNCOMMITTED",
2: "TRANSACTION_ISOLATION_READ_COMMITTED",
3: "TRANSACTION_ISOLATION_REPEATABLE_READ",
4: "TRANSACTION_ISOLATION_SERIALIZABLE",
}
var PostgresqlHostConfig9_6_TransactionIsolation_value = map[string]int32{
"TRANSACTION_ISOLATION_UNSPECIFIED": 0,
"TRANSACTION_ISOLATION_READ_UNCOMMITTED": 1,
"TRANSACTION_ISOLATION_READ_COMMITTED": 2,
"TRANSACTION_ISOLATION_REPEATABLE_READ": 3,
"TRANSACTION_ISOLATION_SERIALIZABLE": 4,
}
func (x PostgresqlHostConfig9_6_TransactionIsolation) String() string {
return proto.EnumName(PostgresqlHostConfig9_6_TransactionIsolation_name, int32(x))
}
func (PostgresqlHostConfig9_6_TransactionIsolation) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host9_6_bf21c75a83cd3758, []int{0, 5}
}
type PostgresqlHostConfig9_6_ByteaOutput int32
const (
PostgresqlHostConfig9_6_BYTEA_OUTPUT_UNSPECIFIED PostgresqlHostConfig9_6_ByteaOutput = 0
PostgresqlHostConfig9_6_BYTEA_OUTPUT_HEX PostgresqlHostConfig9_6_ByteaOutput = 1
PostgresqlHostConfig9_6_BYTEA_OUTPUT_ESCAPED PostgresqlHostConfig9_6_ByteaOutput = 2
)
var PostgresqlHostConfig9_6_ByteaOutput_name = map[int32]string{
0: "BYTEA_OUTPUT_UNSPECIFIED",
1: "BYTEA_OUTPUT_HEX",
2: "BYTEA_OUTPUT_ESCAPED",
}
var PostgresqlHostConfig9_6_ByteaOutput_value = map[string]int32{
"BYTEA_OUTPUT_UNSPECIFIED": 0,
"BYTEA_OUTPUT_HEX": 1,
"BYTEA_OUTPUT_ESCAPED": 2,
}
func (x PostgresqlHostConfig9_6_ByteaOutput) String() string {
return proto.EnumName(PostgresqlHostConfig9_6_ByteaOutput_name, int32(x))
}
func (PostgresqlHostConfig9_6_ByteaOutput) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host9_6_bf21c75a83cd3758, []int{0, 6}
}
type PostgresqlHostConfig9_6_XmlBinary int32
const (
PostgresqlHostConfig9_6_XML_BINARY_UNSPECIFIED PostgresqlHostConfig9_6_XmlBinary = 0
PostgresqlHostConfig9_6_XML_BINARY_BASE64 PostgresqlHostConfig9_6_XmlBinary = 1
PostgresqlHostConfig9_6_XML_BINARY_HEX PostgresqlHostConfig9_6_XmlBinary = 2
)
var PostgresqlHostConfig9_6_XmlBinary_name = map[int32]string{
0: "XML_BINARY_UNSPECIFIED",
1: "XML_BINARY_BASE64",
2: "XML_BINARY_HEX",
}
var PostgresqlHostConfig9_6_XmlBinary_value = map[string]int32{
"XML_BINARY_UNSPECIFIED": 0,
"XML_BINARY_BASE64": 1,
"XML_BINARY_HEX": 2,
}
func (x PostgresqlHostConfig9_6_XmlBinary) String() string {
return proto.EnumName(PostgresqlHostConfig9_6_XmlBinary_name, int32(x))
}
func (PostgresqlHostConfig9_6_XmlBinary) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host9_6_bf21c75a83cd3758, []int{0, 7}
}
type PostgresqlHostConfig9_6_XmlOption int32
const (
PostgresqlHostConfig9_6_XML_OPTION_UNSPECIFIED PostgresqlHostConfig9_6_XmlOption = 0
PostgresqlHostConfig9_6_XML_OPTION_DOCUMENT PostgresqlHostConfig9_6_XmlOption = 1
PostgresqlHostConfig9_6_XML_OPTION_CONTENT PostgresqlHostConfig9_6_XmlOption = 2
)
var PostgresqlHostConfig9_6_XmlOption_name = map[int32]string{
0: "XML_OPTION_UNSPECIFIED",
1: "XML_OPTION_DOCUMENT",
2: "XML_OPTION_CONTENT",
}
var PostgresqlHostConfig9_6_XmlOption_value = map[string]int32{
"XML_OPTION_UNSPECIFIED": 0,
"XML_OPTION_DOCUMENT": 1,
"XML_OPTION_CONTENT": 2,
}
func (x PostgresqlHostConfig9_6_XmlOption) String() string {
return proto.EnumName(PostgresqlHostConfig9_6_XmlOption_name, int32(x))
}
func (PostgresqlHostConfig9_6_XmlOption) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host9_6_bf21c75a83cd3758, []int{0, 8}
}
type PostgresqlHostConfig9_6_BackslashQuote int32
const (
PostgresqlHostConfig9_6_BACKSLASH_QUOTE_UNSPECIFIED PostgresqlHostConfig9_6_BackslashQuote = 0
PostgresqlHostConfig9_6_BACKSLASH_QUOTE PostgresqlHostConfig9_6_BackslashQuote = 1
PostgresqlHostConfig9_6_BACKSLASH_QUOTE_ON PostgresqlHostConfig9_6_BackslashQuote = 2
PostgresqlHostConfig9_6_BACKSLASH_QUOTE_OFF PostgresqlHostConfig9_6_BackslashQuote = 3
PostgresqlHostConfig9_6_BACKSLASH_QUOTE_SAFE_ENCODING PostgresqlHostConfig9_6_BackslashQuote = 4
)
var PostgresqlHostConfig9_6_BackslashQuote_name = map[int32]string{
0: "BACKSLASH_QUOTE_UNSPECIFIED",
1: "BACKSLASH_QUOTE",
2: "BACKSLASH_QUOTE_ON",
3: "BACKSLASH_QUOTE_OFF",
4: "BACKSLASH_QUOTE_SAFE_ENCODING",
}
var PostgresqlHostConfig9_6_BackslashQuote_value = map[string]int32{
"BACKSLASH_QUOTE_UNSPECIFIED": 0,
"BACKSLASH_QUOTE": 1,
"BACKSLASH_QUOTE_ON": 2,
"BACKSLASH_QUOTE_OFF": 3,
"BACKSLASH_QUOTE_SAFE_ENCODING": 4,
}
func (x PostgresqlHostConfig9_6_BackslashQuote) String() string {
return proto.EnumName(PostgresqlHostConfig9_6_BackslashQuote_name, int32(x))
}
func (PostgresqlHostConfig9_6_BackslashQuote) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_host9_6_bf21c75a83cd3758, []int{0, 9}
}
// Options and structure of `PostgresqlHostConfig` reflects parameters of a PostgreSQL
// configuration file. Detailed description is available in
// [PostgreSQL documentation](https://www.postgresql.org/docs/9.6/runtime-config.html).
type PostgresqlHostConfig9_6 struct {
RecoveryMinApplyDelay *wrappers.Int64Value `protobuf:"bytes,1,opt,name=recovery_min_apply_delay,json=recoveryMinApplyDelay,proto3" json:"recovery_min_apply_delay,omitempty"`
SharedBuffers *wrappers.Int64Value `protobuf:"bytes,2,opt,name=shared_buffers,json=sharedBuffers,proto3" json:"shared_buffers,omitempty"`
TempBuffers *wrappers.Int64Value `protobuf:"bytes,3,opt,name=temp_buffers,json=tempBuffers,proto3" json:"temp_buffers,omitempty"`
WorkMem *wrappers.Int64Value `protobuf:"bytes,4,opt,name=work_mem,json=workMem,proto3" json:"work_mem,omitempty"`
ReplacementSortTuples *wrappers.Int64Value `protobuf:"bytes,5,opt,name=replacement_sort_tuples,json=replacementSortTuples,proto3" json:"replacement_sort_tuples,omitempty"`
TempFileLimit *wrappers.Int64Value `protobuf:"bytes,6,opt,name=temp_file_limit,json=tempFileLimit,proto3" json:"temp_file_limit,omitempty"`
BackendFlushAfter *wrappers.Int64Value `protobuf:"bytes,7,opt,name=backend_flush_after,json=backendFlushAfter,proto3" json:"backend_flush_after,omitempty"`
OldSnapshotThreshold *wrappers.Int64Value `protobuf:"bytes,8,opt,name=old_snapshot_threshold,json=oldSnapshotThreshold,proto3" json:"old_snapshot_threshold,omitempty"`
MaxStandbyStreamingDelay *wrappers.Int64Value `protobuf:"bytes,9,opt,name=max_standby_streaming_delay,json=maxStandbyStreamingDelay,proto3" json:"max_standby_streaming_delay,omitempty"`
ConstraintExclusion PostgresqlHostConfig9_6_ConstraintExclusion `protobuf:"varint,10,opt,name=constraint_exclusion,json=constraintExclusion,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_ConstraintExclusion" json:"constraint_exclusion,omitempty"`
CursorTupleFraction *wrappers.DoubleValue `protobuf:"bytes,11,opt,name=cursor_tuple_fraction,json=cursorTupleFraction,proto3" json:"cursor_tuple_fraction,omitempty"`
FromCollapseLimit *wrappers.Int64Value `protobuf:"bytes,12,opt,name=from_collapse_limit,json=fromCollapseLimit,proto3" json:"from_collapse_limit,omitempty"`
JoinCollapseLimit *wrappers.Int64Value `protobuf:"bytes,13,opt,name=join_collapse_limit,json=joinCollapseLimit,proto3" json:"join_collapse_limit,omitempty"`
ForceParallelMode PostgresqlHostConfig9_6_ForceParallelMode `protobuf:"varint,14,opt,name=force_parallel_mode,json=forceParallelMode,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_ForceParallelMode" json:"force_parallel_mode,omitempty"`
ClientMinMessages PostgresqlHostConfig9_6_LogLevel `protobuf:"varint,15,opt,name=client_min_messages,json=clientMinMessages,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_LogLevel" json:"client_min_messages,omitempty"`
LogMinMessages PostgresqlHostConfig9_6_LogLevel `protobuf:"varint,16,opt,name=log_min_messages,json=logMinMessages,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_LogLevel" json:"log_min_messages,omitempty"`
LogMinErrorStatement PostgresqlHostConfig9_6_LogLevel `protobuf:"varint,17,opt,name=log_min_error_statement,json=logMinErrorStatement,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_LogLevel" json:"log_min_error_statement,omitempty"`
LogMinDurationStatement *wrappers.Int64Value `protobuf:"bytes,18,opt,name=log_min_duration_statement,json=logMinDurationStatement,proto3" json:"log_min_duration_statement,omitempty"`
LogCheckpoints *wrappers.BoolValue `protobuf:"bytes,19,opt,name=log_checkpoints,json=logCheckpoints,proto3" json:"log_checkpoints,omitempty"`
LogConnections *wrappers.BoolValue `protobuf:"bytes,20,opt,name=log_connections,json=logConnections,proto3" json:"log_connections,omitempty"`
LogDisconnections *wrappers.BoolValue `protobuf:"bytes,21,opt,name=log_disconnections,json=logDisconnections,proto3" json:"log_disconnections,omitempty"`
LogDuration *wrappers.BoolValue `protobuf:"bytes,22,opt,name=log_duration,json=logDuration,proto3" json:"log_duration,omitempty"`
LogErrorVerbosity PostgresqlHostConfig9_6_LogErrorVerbosity `protobuf:"varint,23,opt,name=log_error_verbosity,json=logErrorVerbosity,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_LogErrorVerbosity" json:"log_error_verbosity,omitempty"`
LogLockWaits *wrappers.BoolValue `protobuf:"bytes,24,opt,name=log_lock_waits,json=logLockWaits,proto3" json:"log_lock_waits,omitempty"`
LogStatement PostgresqlHostConfig9_6_LogStatement `protobuf:"varint,25,opt,name=log_statement,json=logStatement,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_LogStatement" json:"log_statement,omitempty"`
LogTempFiles *wrappers.Int64Value `protobuf:"bytes,26,opt,name=log_temp_files,json=logTempFiles,proto3" json:"log_temp_files,omitempty"`
SearchPath string `protobuf:"bytes,27,opt,name=search_path,json=searchPath,proto3" json:"search_path,omitempty"`
RowSecurity *wrappers.BoolValue `protobuf:"bytes,28,opt,name=row_security,json=rowSecurity,proto3" json:"row_security,omitempty"`
DefaultTransactionIsolation PostgresqlHostConfig9_6_TransactionIsolation `protobuf:"varint,29,opt,name=default_transaction_isolation,json=defaultTransactionIsolation,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_TransactionIsolation" json:"default_transaction_isolation,omitempty"`
StatementTimeout *wrappers.Int64Value `protobuf:"bytes,30,opt,name=statement_timeout,json=statementTimeout,proto3" json:"statement_timeout,omitempty"`
LockTimeout *wrappers.Int64Value `protobuf:"bytes,31,opt,name=lock_timeout,json=lockTimeout,proto3" json:"lock_timeout,omitempty"`
IdleInTransactionSessionTimeout *wrappers.Int64Value `protobuf:"bytes,32,opt,name=idle_in_transaction_session_timeout,json=idleInTransactionSessionTimeout,proto3" json:"idle_in_transaction_session_timeout,omitempty"`
ByteaOutput PostgresqlHostConfig9_6_ByteaOutput `protobuf:"varint,33,opt,name=bytea_output,json=byteaOutput,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_ByteaOutput" json:"bytea_output,omitempty"`
Xmlbinary PostgresqlHostConfig9_6_XmlBinary `protobuf:"varint,34,opt,name=xmlbinary,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_XmlBinary" json:"xmlbinary,omitempty"`
Xmloption PostgresqlHostConfig9_6_XmlOption `protobuf:"varint,35,opt,name=xmloption,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_XmlOption" json:"xmloption,omitempty"`
GinPendingListLimit *wrappers.Int64Value `protobuf:"bytes,36,opt,name=gin_pending_list_limit,json=ginPendingListLimit,proto3" json:"gin_pending_list_limit,omitempty"`
DeadlockTimeout *wrappers.Int64Value `protobuf:"bytes,37,opt,name=deadlock_timeout,json=deadlockTimeout,proto3" json:"deadlock_timeout,omitempty"`
MaxLocksPerTransaction *wrappers.Int64Value `protobuf:"bytes,38,opt,name=max_locks_per_transaction,json=maxLocksPerTransaction,proto3" json:"max_locks_per_transaction,omitempty"`
MaxPredLocksPerTransaction *wrappers.Int64Value `protobuf:"bytes,39,opt,name=max_pred_locks_per_transaction,json=maxPredLocksPerTransaction,proto3" json:"max_pred_locks_per_transaction,omitempty"`
ArrayNulls *wrappers.BoolValue `protobuf:"bytes,40,opt,name=array_nulls,json=arrayNulls,proto3" json:"array_nulls,omitempty"`
BackslashQuote PostgresqlHostConfig9_6_BackslashQuote `protobuf:"varint,41,opt,name=backslash_quote,json=backslashQuote,proto3,enum=yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_BackslashQuote" json:"backslash_quote,omitempty"`
DefaultWithOids *wrappers.BoolValue `protobuf:"bytes,42,opt,name=default_with_oids,json=defaultWithOids,proto3" json:"default_with_oids,omitempty"`
EscapeStringWarning *wrappers.BoolValue `protobuf:"bytes,43,opt,name=escape_string_warning,json=escapeStringWarning,proto3" json:"escape_string_warning,omitempty"`
LoCompatPrivileges *wrappers.BoolValue `protobuf:"bytes,44,opt,name=lo_compat_privileges,json=loCompatPrivileges,proto3" json:"lo_compat_privileges,omitempty"`
OperatorPrecedenceWarning *wrappers.BoolValue `protobuf:"bytes,45,opt,name=operator_precedence_warning,json=operatorPrecedenceWarning,proto3" json:"operator_precedence_warning,omitempty"`
QuoteAllIdentifiers *wrappers.BoolValue `protobuf:"bytes,46,opt,name=quote_all_identifiers,json=quoteAllIdentifiers,proto3" json:"quote_all_identifiers,omitempty"`
StandardConformingStrings *wrappers.BoolValue `protobuf:"bytes,47,opt,name=standard_conforming_strings,json=standardConformingStrings,proto3" json:"standard_conforming_strings,omitempty"`
SynchronizeSeqscans *wrappers.BoolValue `protobuf:"bytes,48,opt,name=synchronize_seqscans,json=synchronizeSeqscans,proto3" json:"synchronize_seqscans,omitempty"`
TransformNullEquals *wrappers.BoolValue `protobuf:"bytes,49,opt,name=transform_null_equals,json=transformNullEquals,proto3" json:"transform_null_equals,omitempty"`
ExitOnError *wrappers.BoolValue `protobuf:"bytes,50,opt,name=exit_on_error,json=exitOnError,proto3" json:"exit_on_error,omitempty"`
SeqPageCost *wrappers.DoubleValue `protobuf:"bytes,51,opt,name=seq_page_cost,json=seqPageCost,proto3" json:"seq_page_cost,omitempty"`
RandomPageCost *wrappers.DoubleValue `protobuf:"bytes,52,opt,name=random_page_cost,json=randomPageCost,proto3" json:"random_page_cost,omitempty"`
// This option has been removed in PostgreSQL 10.
SqlInheritance *wrappers.BoolValue `protobuf:"bytes,53,opt,name=sql_inheritance,json=sqlInheritance,proto3" json:"sql_inheritance,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PostgresqlHostConfig9_6) Reset() { *m = PostgresqlHostConfig9_6{} }
func (m *PostgresqlHostConfig9_6) String() string { return proto.CompactTextString(m) }
func (*PostgresqlHostConfig9_6) ProtoMessage() {}
func (*PostgresqlHostConfig9_6) Descriptor() ([]byte, []int) {
return fileDescriptor_host9_6_bf21c75a83cd3758, []int{0}
}
func (m *PostgresqlHostConfig9_6) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PostgresqlHostConfig9_6.Unmarshal(m, b)
}
func (m *PostgresqlHostConfig9_6) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PostgresqlHostConfig9_6.Marshal(b, m, deterministic)
}
func (dst *PostgresqlHostConfig9_6) XXX_Merge(src proto.Message) {
xxx_messageInfo_PostgresqlHostConfig9_6.Merge(dst, src)
}
func (m *PostgresqlHostConfig9_6) XXX_Size() int {
return xxx_messageInfo_PostgresqlHostConfig9_6.Size(m)
}
func (m *PostgresqlHostConfig9_6) XXX_DiscardUnknown() {
xxx_messageInfo_PostgresqlHostConfig9_6.DiscardUnknown(m)
}
var xxx_messageInfo_PostgresqlHostConfig9_6 proto.InternalMessageInfo
func (m *PostgresqlHostConfig9_6) GetRecoveryMinApplyDelay() *wrappers.Int64Value {
if m != nil {
return m.RecoveryMinApplyDelay
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetSharedBuffers() *wrappers.Int64Value {
if m != nil {
return m.SharedBuffers
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetTempBuffers() *wrappers.Int64Value {
if m != nil {
return m.TempBuffers
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetWorkMem() *wrappers.Int64Value {
if m != nil {
return m.WorkMem
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetReplacementSortTuples() *wrappers.Int64Value {
if m != nil {
return m.ReplacementSortTuples
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetTempFileLimit() *wrappers.Int64Value {
if m != nil {
return m.TempFileLimit
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetBackendFlushAfter() *wrappers.Int64Value {
if m != nil {
return m.BackendFlushAfter
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetOldSnapshotThreshold() *wrappers.Int64Value {
if m != nil {
return m.OldSnapshotThreshold
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetMaxStandbyStreamingDelay() *wrappers.Int64Value {
if m != nil {
return m.MaxStandbyStreamingDelay
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetConstraintExclusion() PostgresqlHostConfig9_6_ConstraintExclusion {
if m != nil {
return m.ConstraintExclusion
}
return PostgresqlHostConfig9_6_CONSTRAINT_EXCLUSION_UNSPECIFIED
}
func (m *PostgresqlHostConfig9_6) GetCursorTupleFraction() *wrappers.DoubleValue {
if m != nil {
return m.CursorTupleFraction
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetFromCollapseLimit() *wrappers.Int64Value {
if m != nil {
return m.FromCollapseLimit
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetJoinCollapseLimit() *wrappers.Int64Value {
if m != nil {
return m.JoinCollapseLimit
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetForceParallelMode() PostgresqlHostConfig9_6_ForceParallelMode {
if m != nil {
return m.ForceParallelMode
}
return PostgresqlHostConfig9_6_FORCE_PARALLEL_MODE_UNSPECIFIED
}
func (m *PostgresqlHostConfig9_6) GetClientMinMessages() PostgresqlHostConfig9_6_LogLevel {
if m != nil {
return m.ClientMinMessages
}
return PostgresqlHostConfig9_6_LOG_LEVEL_UNSPECIFIED
}
func (m *PostgresqlHostConfig9_6) GetLogMinMessages() PostgresqlHostConfig9_6_LogLevel {
if m != nil {
return m.LogMinMessages
}
return PostgresqlHostConfig9_6_LOG_LEVEL_UNSPECIFIED
}
func (m *PostgresqlHostConfig9_6) GetLogMinErrorStatement() PostgresqlHostConfig9_6_LogLevel {
if m != nil {
return m.LogMinErrorStatement
}
return PostgresqlHostConfig9_6_LOG_LEVEL_UNSPECIFIED
}
func (m *PostgresqlHostConfig9_6) GetLogMinDurationStatement() *wrappers.Int64Value {
if m != nil {
return m.LogMinDurationStatement
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetLogCheckpoints() *wrappers.BoolValue {
if m != nil {
return m.LogCheckpoints
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetLogConnections() *wrappers.BoolValue {
if m != nil {
return m.LogConnections
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetLogDisconnections() *wrappers.BoolValue {
if m != nil {
return m.LogDisconnections
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetLogDuration() *wrappers.BoolValue {
if m != nil {
return m.LogDuration
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetLogErrorVerbosity() PostgresqlHostConfig9_6_LogErrorVerbosity {
if m != nil {
return m.LogErrorVerbosity
}
return PostgresqlHostConfig9_6_LOG_ERROR_VERBOSITY_UNSPECIFIED
}
func (m *PostgresqlHostConfig9_6) GetLogLockWaits() *wrappers.BoolValue {
if m != nil {
return m.LogLockWaits
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetLogStatement() PostgresqlHostConfig9_6_LogStatement {
if m != nil {
return m.LogStatement
}
return PostgresqlHostConfig9_6_LOG_STATEMENT_UNSPECIFIED
}
func (m *PostgresqlHostConfig9_6) GetLogTempFiles() *wrappers.Int64Value {
if m != nil {
return m.LogTempFiles
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetSearchPath() string {
if m != nil {
return m.SearchPath
}
return ""
}
func (m *PostgresqlHostConfig9_6) GetRowSecurity() *wrappers.BoolValue {
if m != nil {
return m.RowSecurity
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetDefaultTransactionIsolation() PostgresqlHostConfig9_6_TransactionIsolation {
if m != nil {
return m.DefaultTransactionIsolation
}
return PostgresqlHostConfig9_6_TRANSACTION_ISOLATION_UNSPECIFIED
}
func (m *PostgresqlHostConfig9_6) GetStatementTimeout() *wrappers.Int64Value {
if m != nil {
return m.StatementTimeout
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetLockTimeout() *wrappers.Int64Value {
if m != nil {
return m.LockTimeout
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetIdleInTransactionSessionTimeout() *wrappers.Int64Value {
if m != nil {
return m.IdleInTransactionSessionTimeout
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetByteaOutput() PostgresqlHostConfig9_6_ByteaOutput {
if m != nil {
return m.ByteaOutput
}
return PostgresqlHostConfig9_6_BYTEA_OUTPUT_UNSPECIFIED
}
func (m *PostgresqlHostConfig9_6) GetXmlbinary() PostgresqlHostConfig9_6_XmlBinary {
if m != nil {
return m.Xmlbinary
}
return PostgresqlHostConfig9_6_XML_BINARY_UNSPECIFIED
}
func (m *PostgresqlHostConfig9_6) GetXmloption() PostgresqlHostConfig9_6_XmlOption {
if m != nil {
return m.Xmloption
}
return PostgresqlHostConfig9_6_XML_OPTION_UNSPECIFIED
}
func (m *PostgresqlHostConfig9_6) GetGinPendingListLimit() *wrappers.Int64Value {
if m != nil {
return m.GinPendingListLimit
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetDeadlockTimeout() *wrappers.Int64Value {
if m != nil {
return m.DeadlockTimeout
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetMaxLocksPerTransaction() *wrappers.Int64Value {
if m != nil {
return m.MaxLocksPerTransaction
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetMaxPredLocksPerTransaction() *wrappers.Int64Value {
if m != nil {
return m.MaxPredLocksPerTransaction
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetArrayNulls() *wrappers.BoolValue {
if m != nil {
return m.ArrayNulls
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetBackslashQuote() PostgresqlHostConfig9_6_BackslashQuote {
if m != nil {
return m.BackslashQuote
}
return PostgresqlHostConfig9_6_BACKSLASH_QUOTE_UNSPECIFIED
}
func (m *PostgresqlHostConfig9_6) GetDefaultWithOids() *wrappers.BoolValue {
if m != nil {
return m.DefaultWithOids
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetEscapeStringWarning() *wrappers.BoolValue {
if m != nil {
return m.EscapeStringWarning
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetLoCompatPrivileges() *wrappers.BoolValue {
if m != nil {
return m.LoCompatPrivileges
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetOperatorPrecedenceWarning() *wrappers.BoolValue {
if m != nil {
return m.OperatorPrecedenceWarning
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetQuoteAllIdentifiers() *wrappers.BoolValue {
if m != nil {
return m.QuoteAllIdentifiers
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetStandardConformingStrings() *wrappers.BoolValue {
if m != nil {
return m.StandardConformingStrings
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetSynchronizeSeqscans() *wrappers.BoolValue {
if m != nil {
return m.SynchronizeSeqscans
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetTransformNullEquals() *wrappers.BoolValue {
if m != nil {
return m.TransformNullEquals
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetExitOnError() *wrappers.BoolValue {
if m != nil {
return m.ExitOnError
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetSeqPageCost() *wrappers.DoubleValue {
if m != nil {
return m.SeqPageCost
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetRandomPageCost() *wrappers.DoubleValue {
if m != nil {
return m.RandomPageCost
}
return nil
}
func (m *PostgresqlHostConfig9_6) GetSqlInheritance() *wrappers.BoolValue {
if m != nil {
return m.SqlInheritance
}
return nil
}
func init() {
proto.RegisterType((*PostgresqlHostConfig9_6)(nil), "yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6")
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_ConstraintExclusion", PostgresqlHostConfig9_6_ConstraintExclusion_name, PostgresqlHostConfig9_6_ConstraintExclusion_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_ForceParallelMode", PostgresqlHostConfig9_6_ForceParallelMode_name, PostgresqlHostConfig9_6_ForceParallelMode_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_LogLevel", PostgresqlHostConfig9_6_LogLevel_name, PostgresqlHostConfig9_6_LogLevel_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_LogErrorVerbosity", PostgresqlHostConfig9_6_LogErrorVerbosity_name, PostgresqlHostConfig9_6_LogErrorVerbosity_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_LogStatement", PostgresqlHostConfig9_6_LogStatement_name, PostgresqlHostConfig9_6_LogStatement_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_TransactionIsolation", PostgresqlHostConfig9_6_TransactionIsolation_name, PostgresqlHostConfig9_6_TransactionIsolation_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_ByteaOutput", PostgresqlHostConfig9_6_ByteaOutput_name, PostgresqlHostConfig9_6_ByteaOutput_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_XmlBinary", PostgresqlHostConfig9_6_XmlBinary_name, PostgresqlHostConfig9_6_XmlBinary_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_XmlOption", PostgresqlHostConfig9_6_XmlOption_name, PostgresqlHostConfig9_6_XmlOption_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.config.PostgresqlHostConfig9_6_BackslashQuote", PostgresqlHostConfig9_6_BackslashQuote_name, PostgresqlHostConfig9_6_BackslashQuote_value)
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/postgresql/v1/config/host9_6.proto", fileDescriptor_host9_6_bf21c75a83cd3758)
}
var fileDescriptor_host9_6_bf21c75a83cd3758 = []byte{
// 2235 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x99, 0x5b, 0x73, 0xdb, 0xb8,
0x15, 0xc7, 0x2b, 0x3b, 0x9b, 0x4d, 0xe0, 0x1b, 0x05, 0xf9, 0xc2, 0xd8, 0xb9, 0x2a, 0x97, 0x66,
0xb7, 0xb5, 0x7c, 0x89, 0xd7, 0x9b, 0x9d, 0x9d, 0xee, 0x2c, 0x25, 0x51, 0x8e, 0xba, 0x94, 0xa8,
0x25, 0x69, 0xc7, 0x9b, 0xce, 0x0e, 0x06, 0x22, 0x21, 0x89, 0x0d, 0x48, 0xd0, 0x04, 0xe5, 0x4b,
0x1f, 0x3a, 0x7d, 0xe9, 0x4b, 0x1f, 0xfb, 0xd2, 0x69, 0x67, 0xfa, 0x79, 0xf2, 0x4d, 0xfa, 0x21,
0xf2, 0xd4, 0x01, 0x29, 0xea, 0x62, 0x6b, 0x4b, 0x4f, 0x9d, 0x37, 0xfb, 0xe0, 0xfc, 0x7f, 0xe7,
0x00, 0x38, 0x00, 0x0f, 0x46, 0xe0, 0xd5, 0x05, 0xf6, 0x1d, 0x72, 0xbe, 0x65, 0x53, 0xd6, 0x77,
0xb6, 0x3c, 0xa7, 0xbd, 0x15, 0x30, 0x1e, 0x75, 0x43, 0xc2, 0x4f, 0xe8, 0xd6, 0xe9, 0xce, 0x96,
0xcd, 0xfc, 0x8e, 0xdb, 0xdd, 0xea, 0x31, 0x1e, 0x7d, 0x83, 0xf6, 0x4b, 0x41, 0xc8, 0x22, 0x06,
0x9f, 0x27, 0xa2, 0x52, 0x2c, 0x2a, 0x79, 0x4e, 0xbb, 0x34, 0x12, 0x95, 0x4e, 0x77, 0x4a, 0x89,
0x68, 0xfd, 0x61, 0x97, 0xb1, 0x2e, 0x25, 0x5b, 0xb1, 0xa8, 0xdd, 0xef, 0x6c, 0x9d, 0x85, 0x38,
0x08, 0x48, 0xc8, 0x13, 0xcc, 0xfa, 0x83, 0x89, 0xd8, 0xa7, 0x98, 0xba, 0x0e, 0x8e, 0x5c, 0xe6,
0x27, 0xc3, 0xc5, 0x7f, 0x6f, 0x83, 0xb5, 0xd6, 0x90, 0xfb, 0x86, 0xf1, 0xa8, 0x12, 0x73, 0xbf,
0x41, 0xfb, 0xd0, 0x02, 0x72, 0x48, 0x6c, 0x76, 0x4a, 0xc2, 0x0b, 0xe4, 0xb9, 0x3e, 0xc2, 0x41,
0x40, 0x2f, 0x90, 0x43, 0x28, 0xbe, 0x90, 0x73, 0x8f, 0x73, 0x2f, 0xe7, 0x76, 0x37, 0x4a, 0x49,
0xf4, 0x52, 0x1a, 0xbd, 0x54, 0xf7, 0xa3, 0xfd, 0xbd, 0x23, 0x4c, 0xfb, 0xc4, 0x58, 0x49, 0xc5,
0x0d, 0xd7, 0x57, 0x84, 0xb4, 0x2a, 0x94, 0xb0, 0x0c, 0x16, 0x79, 0x0f, 0x87, 0xc4, 0x41, 0xed,
0x7e, 0xa7, 0x43, 0x42, 0x2e, 0xcf, 0x64, 0xb3, 0x16, 0x12, 0x49, 0x39, 0x51, 0xc0, 0xef, 0xc0,
0x7c, 0x44, 0xbc, 0x60, 0x48, 0x98, 0xcd, 0x26, 0xcc, 0x09, 0x41, 0xaa, 0xdf, 0x07, 0x77, 0xce,
0x58, 0xf8, 0x1e, 0x79, 0xc4, 0x93, 0x6f, 0x65, 0x6b, 0x3f, 0x17, 0xce, 0x0d, 0xe2, 0x41, 0x13,
0xac, 0x85, 0x24, 0xa0, 0xd8, 0x26, 0x1e, 0xf1, 0x23, 0xc4, 0x59, 0x18, 0xa1, 0xa8, 0x1f, 0x50,
0xc2, 0xe5, 0xcf, 0xae, 0xb5, 0x20, 0x43, 0xad, 0xc9, 0xc2, 0xc8, 0x8a, 0x95, 0xb0, 0x02, 0x96,
0xe2, 0xc9, 0x74, 0x5c, 0x4a, 0x10, 0x75, 0x3d, 0x37, 0x92, 0x6f, 0x5f, 0x63, 0x45, 0x84, 0xa6,
0xe6, 0x52, 0xa2, 0x09, 0x05, 0x7c, 0x0b, 0x0a, 0x6d, 0x6c, 0xbf, 0x27, 0xbe, 0x83, 0x3a, 0xb4,
0xcf, 0x7b, 0x08, 0x77, 0x22, 0x12, 0xca, 0x9f, 0x67, 0x82, 0xca, 0xe0, 0xe3, 0x87, 0x9d, 0xdb,
0xdb, 0x9b, 0xbb, 0xdb, 0x7b, 0xaf, 0x8d, 0xfc, 0x80, 0x51, 0x13, 0x08, 0x45, 0x10, 0x20, 0x02,
0xab, 0x8c, 0x3a, 0x88, 0xfb, 0x38, 0xe0, 0x3d, 0x16, 0xa1, 0xa8, 0x17, 0x12, 0xde, 0x63, 0xd4,
0x91, 0xef, 0x64, 0xb3, 0xe7, 0x3f, 0x7e, 0xd8, 0xb9, 0xb3, 0xb9, 0xb3, 0xf9, 0x7a, 0x7f, 0x6f,
0x7b, 0xdb, 0x58, 0x66, 0xd4, 0x31, 0x07, 0x1c, 0x2b, 0xc5, 0xc0, 0x77, 0x60, 0xc3, 0xc3, 0xe7,
0x88, 0x47, 0xd8, 0x77, 0xda, 0x17, 0x88, 0x47, 0x21, 0xc1, 0x9e, 0xeb, 0x77, 0x07, 0x85, 0x76,
0x37, 0x7b, 0x29, 0x64, 0x0f, 0x9f, 0x9b, 0x89, 0xdc, 0x4c, 0xd5, 0x49, 0xad, 0xfd, 0x35, 0x07,
0x96, 0x6d, 0xe6, 0xf3, 0x28, 0xc4, 0xae, 0x1f, 0x21, 0x72, 0x6e, 0xd3, 0x3e, 0x77, 0x99, 0x2f,
0x83, 0xc7, 0xb9, 0x97, 0x8b, 0xbb, 0x46, 0xe9, 0x5a, 0x67, 0xac, 0xf4, 0x0b, 0x07, 0xa4, 0x54,
0x19, 0xa2, 0xd5, 0x94, 0x6c, 0x14, 0xec, 0xab, 0x46, 0xd8, 0x02, 0x2b, 0x76, 0x3f, 0xe4, 0x2c,
0x4c, 0xaa, 0x05, 0x75, 0x42, 0x6c, 0x8b, 0x43, 0x28, 0xcf, 0xc5, 0xb3, 0xbb, 0x7f, 0x65, 0x76,
0x55, 0xd6, 0x6f, 0x53, 0x92, 0x4c, 0xaf, 0x90, 0x48, 0xe3, 0x6a, 0xa9, 0x0d, 0x84, 0xf0, 0x67,
0x50, 0xe8, 0x84, 0xcc, 0x43, 0x36, 0xa3, 0x14, 0x07, 0x3c, 0x2d, 0x9c, 0xf9, 0xec, 0x3d, 0x91,
0x3e, 0x7e, 0xd8, 0x99, 0xdf, 0xd9, 0xdc, 0xdd, 0xd9, 0xfb, 0x7a, 0xef, 0xf5, 0xab, 0xfd, 0xbd,
0xaf, 0x8d, 0xbc, 0x20, 0x55, 0x06, 0xa0, 0xa4, 0x9c, 0x7e, 0x06, 0x85, 0x3f, 0x32, 0xd7, 0xbf,
0x8c, 0x5f, 0xf8, 0xbf, 0xf0, 0x82, 0x34, 0x89, 0xff, 0x4b, 0x0e, 0x14, 0x3a, 0x2c, 0xb4, 0x09,
0x0a, 0x70, 0x88, 0x29, 0x25, 0x14, 0x79, 0xcc, 0x21, 0xf2, 0x62, 0xbc, 0x2d, 0xad, 0x1b, 0x6e,
0x4b, 0x4d, 0x90, 0x5b, 0x03, 0x70, 0x83, 0x39, 0xc4, 0xc8, 0x77, 0x2e, 0x9b, 0xe0, 0x19, 0x28,
0xd8, 0xd4, 0x15, 0xa7, 0x58, 0x5c, 0x6d, 0x1e, 0xe1, 0x1c, 0x77, 0x09, 0x97, 0x97, 0xe2, 0x0c,
0x0e, 0x6e, 0x98, 0x81, 0xc6, 0xba, 0x1a, 0x39, 0x25, 0xd4, 0xc8, 0x27, 0x31, 0x1a, 0xae, 0xdf,
0x18, 0x44, 0x80, 0x27, 0x40, 0xa2, 0xac, 0x3b, 0x19, 0x55, 0xfa, 0xb4, 0x51, 0x17, 0x29, 0xeb,
0x8e, 0x87, 0xfc, 0x33, 0x58, 0x4b, 0x43, 0x92, 0x30, 0x64, 0xa1, 0x38, 0x6c, 0x51, 0x7c, 0x0d,
0xc9, 0xf9, 0x4f, 0x1b, 0x79, 0x39, 0x89, 0xac, 0x8a, 0x28, 0x66, 0x1a, 0x04, 0x1e, 0x83, 0xf5,
0x34, 0xbe, 0xd3, 0x0f, 0xe3, 0xcf, 0xcf, 0x58, 0x0a, 0x30, 0xfb, 0x84, 0xaf, 0x25, 0xd8, 0xea,
0x40, 0x3c, 0x22, 0x57, 0xc0, 0x92, 0x20, 0xdb, 0x3d, 0x62, 0xbf, 0x0f, 0x98, 0xeb, 0x47, 0x5c,
0x2e, 0xc4, 0xb8, 0xf5, 0x2b, 0xb8, 0x32, 0x63, 0x34, 0xa1, 0x89, 0xe5, 0xa9, 0x8c, 0x14, 0x43,
0x08, 0xf3, 0x7d, 0x12, 0x9f, 0x2e, 0x2e, 0x2f, 0x5f, 0x0f, 0x32, 0x52, 0xc0, 0x3a, 0x80, 0x02,
0xe2, 0xb8, 0x7c, 0x9c, 0xb3, 0x92, 0xc9, 0xc9, 0x53, 0xd6, 0xad, 0x4e, 0x88, 0xe0, 0xef, 0xc0,
0x7c, 0x8c, 0x1a, 0xcc, 0x56, 0x5e, 0xcd, 0x84, 0xcc, 0x09, 0xc8, 0xc0, 0x3d, 0x3e, 0x5c, 0x42,
0x9f, 0x6c, 0xf5, 0x29, 0x09, 0xdb, 0x8c, 0xbb, 0xd1, 0x85, 0xbc, 0xf6, 0x49, 0x0e, 0x97, 0xc6,
0xba, 0xf1, 0xee, 0x1e, 0xa5, 0xdc, 0x78, 0x06, 0x93, 0x26, 0xf8, 0x3d, 0x10, 0xcb, 0x83, 0x28,
0xb3, 0xdf, 0xa3, 0x33, 0xec, 0x46, 0x5c, 0x96, 0x33, 0xe7, 0x20, 0xe6, 0xac, 0x31, 0xfb, 0xfd,
0x5b, 0xe1, 0x0f, 0x03, 0xb0, 0x20, 0x08, 0xa3, 0x2a, 0xb9, 0x17, 0x67, 0xff, 0xc3, 0xcd, 0xb3,
0x1f, 0x16, 0x4f, 0x1c, 0x71, 0x54, 0x4a, 0x4a, 0x92, 0xf3, 0xf0, 0x53, 0xcc, 0xe5, 0xf5, 0xec,
0xc2, 0x14, 0x08, 0x6b, 0xf0, 0x21, 0xe6, 0xf0, 0x11, 0x98, 0xe3, 0x04, 0x87, 0x76, 0x0f, 0x05,
0x38, 0xea, 0xc9, 0x1b, 0x8f, 0x73, 0x2f, 0xef, 0x1a, 0x20, 0x31, 0xb5, 0x70, 0xd4, 0x13, 0x3b,
0x1b, 0xb2, 0x33, 0xc4, 0x89, 0xdd, 0x0f, 0xc5, 0x96, 0xdc, 0xcf, 0xde, 0xd9, 0x90, 0x9d, 0x99,
0x03, 0x77, 0xf8, 0x8f, 0x1c, 0x78, 0xe0, 0x90, 0x0e, 0xee, 0xd3, 0x08, 0x45, 0x21, 0xf6, 0x79,
0xf2, 0x31, 0x40, 0x2e, 0x67, 0x34, 0x29, 0x95, 0x07, 0xf1, 0x2a, 0x99, 0x37, 0x5c, 0x25, 0x6b,
0xc4, 0xae, 0xa7, 0x68, 0x63, 0x63, 0x10, 0x79, 0xda, 0x20, 0x7c, 0x03, 0xf2, 0xc3, 0xad, 0x42,
0x91, 0xeb, 0x11, 0xd6, 0x8f, 0xe4, 0x87, 0xd9, 0xeb, 0x27, 0x0d, 0x55, 0x56, 0x22, 0x12, 0xad,
0x5d, 0x5c, 0x36, 0x29, 0xe4, 0xd1, 0x35, 0x5a, 0x3b, 0x21, 0x48, 0xf5, 0x2e, 0x78, 0xea, 0x3a,
0x94, 0x20, 0xd7, 0x9f, 0x58, 0x22, 0x4e, 0xb8, 0xf8, 0x12, 0x0f, 0xb1, 0x8f, 0xb3, 0xb1, 0x8f,
0x04, 0xa7, 0xee, 0x8f, 0xcd, 0xd7, 0x4c, 0x20, 0x69, 0x28, 0x0f, 0xcc, 0xb7, 0x2f, 0x22, 0x82,
0x11, 0xeb, 0x47, 0x41, 0x3f, 0x92, 0x9f, 0xc4, 0x8b, 0xff, 0xfb, 0x1b, 0x2e, 0x7e, 0x59, 0x20,
0xf5, 0x98, 0x68, 0xcc, 0xb5, 0x47, 0xff, 0xc0, 0x0e, 0xb8, 0x7b, 0xee, 0xd1, 0xb6, 0xeb, 0xe3,
0xf0, 0x42, 0x2e, 0xc6, 0xb1, 0xde, 0xdc, 0x30, 0xd6, 0xb1, 0x47, 0xcb, 0x31, 0xcf, 0x18, 0xa1,
0x07, 0x71, 0x58, 0x10, 0x17, 0xd4, 0xd3, 0x4f, 0x15, 0x47, 0x8f, 0x79, 0xc6, 0x08, 0x0d, 0x5b,
0x60, 0xb5, 0xeb, 0xfa, 0x28, 0x20, 0xbe, 0x23, 0xda, 0x3d, 0xea, 0xf2, 0x68, 0xd0, 0x66, 0x3c,
0xcb, 0xde, 0x9c, 0x42, 0xd7, 0xf5, 0x5b, 0x89, 0x52, 0x73, 0x79, 0x94, 0xb4, 0x15, 0x35, 0x20,
0x39, 0x04, 0x3b, 0x13, 0xf5, 0xf3, 0x3c, 0x9b, 0xb5, 0x94, 0x8a, 0xd2, 0x8d, 0x3d, 0x02, 0xf7,
0x44, 0x4b, 0x2a, 0x4c, 0x1c, 0x05, 0x24, 0x1c, 0xaf, 0x24, 0xf9, 0x45, 0x36, 0x70, 0xd5, 0xc3,
0xe7, 0xe2, 0x2a, 0xe3, 0x2d, 0x12, 0x8e, 0x95, 0x0f, 0x44, 0xe0, 0xa1, 0xe0, 0x06, 0xe2, 0xf1,
0x33, 0x1d, 0xfe, 0xeb, 0x6c, 0xf8, 0xba, 0x87, 0xcf, 0x5b, 0x21, 0x71, 0xa6, 0x05, 0xf8, 0x16,
0xcc, 0xe1, 0x30, 0xc4, 0x17, 0xc8, 0xef, 0x53, 0xca, 0xe5, 0x97, 0x99, 0xd7, 0x0b, 0x88, 0xdd,
0x9b, 0xc2, 0x1b, 0x9e, 0x82, 0x25, 0xd1, 0xfe, 0x73, 0x8a, 0x79, 0x0f, 0x9d, 0xf4, 0x59, 0x44,
0xe4, 0x2f, 0xe2, 0xdd, 0x6f, 0xdc, 0xb4, 0xa2, 0x53, 0xea, 0x8f, 0x02, 0x6a, 0x2c, 0xb6, 0x27,
0xfe, 0x87, 0x35, 0x90, 0x4f, 0x2f, 0xb5, 0x33, 0x37, 0xea, 0x21, 0xe6, 0x3a, 0x5c, 0xfe, 0x32,
0x33, 0xf5, 0xa5, 0x81, 0xe8, 0xad, 0x1b, 0xf5, 0x74, 0xd7, 0xe1, 0xb0, 0x09, 0x56, 0x08, 0xb7,
0x71, 0x40, 0xc4, 0x1b, 0x42, 0x54, 0xd4, 0x19, 0x0e, 0x7d, 0xd7, 0xef, 0xca, 0xbf, 0xc9, 0x64,
0x15, 0x12, 0xa1, 0x19, 0xeb, 0xde, 0x26, 0x32, 0xa8, 0x81, 0x65, 0xca, 0x90, 0xcd, 0xbc, 0x00,
0x47, 0x28, 0x08, 0xdd, 0x53, 0x97, 0x12, 0xd1, 0xac, 0xfd, 0x36, 0x13, 0x07, 0x29, 0xab, 0xc4,
0xb2, 0xd6, 0x50, 0x25, 0x9e, 0x39, 0x2c, 0x20, 0x21, 0x8e, 0x58, 0x28, 0x0a, 0xc0, 0x26, 0x0e,
0xf1, 0x6d, 0x32, 0xcc, 0x71, 0x33, 0x13, 0x7a, 0x2f, 0x95, 0xb7, 0x86, 0xea, 0x34, 0xd3, 0x26,
0x58, 0x89, 0xf7, 0x0b, 0x61, 0x4a, 0x91, 0xeb, 0x10, 0x3f, 0x72, 0x3b, 0xae, 0x78, 0x17, 0x97,
0xb2, 0x67, 0x1e, 0x0b, 0x15, 0x4a, 0xeb, 0x23, 0x99, 0xc8, 0x35, 0x7e, 0x8e, 0xe1, 0xd0, 0x11,
0x5d, 0x51, 0x87, 0x85, 0xf1, 0x83, 0x2c, 0x59, 0x56, 0x2e, 0x6f, 0x65, 0xe7, 0x9a, 0xca, 0x2b,
0x43, 0x75, 0xb2, 0xb6, 0x1c, 0x36, 0xc0, 0x32, 0xbf, 0xf0, 0xed, 0x5e, 0xc8, 0x7c, 0xf7, 0x4f,
0x04, 0x71, 0x72, 0xc2, 0x6d, 0xec, 0x73, 0x79, 0x3b, 0x3b, 0xd5, 0x31, 0x9d, 0x39, 0x90, 0x89,
0xa9, 0xc7, 0xe7, 0x47, 0x44, 0x89, 0xab, 0x1e, 0x91, 0x93, 0x3e, 0xa6, 0x5c, 0xde, 0xc9, 0xe6,
0x0d, 0x85, 0xa2, 0xfe, 0xd5, 0x58, 0x06, 0xbf, 0x03, 0x0b, 0xe4, 0xdc, 0x8d, 0x10, 0x1b, 0xb4,
0xca, 0xf2, 0x6e, 0xf6, 0x27, 0x5a, 0x08, 0xf4, 0xa4, 0xe7, 0x85, 0xdf, 0x83, 0x05, 0x4e, 0x4e,
0x50, 0x80, 0xbb, 0x04, 0xd9, 0x8c, 0x47, 0xf2, 0xab, 0x6b, 0xbc, 0xf0, 0xe6, 0x38, 0x39, 0x69,
0xe1, 0x2e, 0xa9, 0x30, 0x1e, 0x5f, 0x62, 0x21, 0xf6, 0x1d, 0xe6, 0x8d, 0x41, 0xf6, 0xae, 0x01,
0x59, 0x4c, 0x54, 0x43, 0x4e, 0x05, 0x2c, 0xf1, 0x13, 0x8a, 0x5c, 0xbf, 0x47, 0x42, 0x37, 0xc2,
0xbe, 0x4d, 0xe4, 0xaf, 0xb2, 0xbb, 0x5a, 0x7e, 0x42, 0xeb, 0x23, 0x45, 0xf1, 0x5f, 0x39, 0x50,
0x98, 0xf2, 0xca, 0x85, 0xcf, 0xc0, 0xe3, 0x8a, 0xde, 0x34, 0x2d, 0x43, 0xa9, 0x37, 0x2d, 0xa4,
0x1e, 0x57, 0xb4, 0x43, 0xb3, 0xae, 0x37, 0xd1, 0x61, 0xd3, 0x6c, 0xa9, 0x95, 0x7a, 0xad, 0xae,
0x56, 0xa5, 0x5f, 0xc1, 0x0d, 0xb0, 0x36, 0xd5, 0x4b, 0x6f, 0x4a, 0x39, 0x78, 0x1f, 0xc8, 0xd3,
0x07, 0x6b, 0x35, 0x69, 0x06, 0x16, 0xc1, 0xc3, 0xa9, 0xa3, 0x2d, 0xc5, 0xb0, 0xea, 0x56, 0x5d,
0x6f, 0x4a, 0xb3, 0xc5, 0xbf, 0xe7, 0x40, 0xfe, 0xca, 0x5b, 0x0f, 0x3e, 0x05, 0x8f, 0x6a, 0xba,
0x51, 0x51, 0x85, 0xab, 0xa2, 0x69, 0xaa, 0x86, 0x1a, 0x7a, 0x55, 0xbd, 0x94, 0xd9, 0x3a, 0x58,
0x9d, 0xe6, 0x14, 0x27, 0xb6, 0x01, 0xd6, 0xa6, 0x8e, 0xc5, 0x79, 0x3d, 0x02, 0x1b, 0xd3, 0x06,
0x0d, 0xf5, 0xc0, 0x50, 0x4d, 0x53, 0x24, 0x35, 0x03, 0xee, 0xa4, 0xcf, 0x21, 0x78, 0x0f, 0xac,
0x68, 0xfa, 0x01, 0xd2, 0xd4, 0x23, 0x55, 0xbb, 0x94, 0xc1, 0x32, 0x90, 0x46, 0x43, 0x55, 0xb5,
0x7c, 0x78, 0xf0, 0x95, 0x94, 0x9b, 0x62, 0xdd, 0x93, 0x66, 0xa6, 0x58, 0x5f, 0x49, 0xb3, 0x53,
0xac, 0xbb, 0xd2, 0xad, 0x29, 0xd6, 0x1d, 0xe9, 0x33, 0x98, 0x07, 0x0b, 0x23, 0xab, 0xa6, 0x1f,
0x48, 0xb7, 0x27, 0x1d, 0x9b, 0xba, 0x55, 0xaf, 0xa8, 0xd2, 0xe7, 0x70, 0x05, 0xe4, 0x47, 0xd6,
0xb7, 0x8a, 0xd1, 0xac, 0x37, 0x0f, 0xa4, 0x3b, 0xb0, 0x00, 0x96, 0x46, 0x66, 0xd5, 0x30, 0x74,
0x43, 0xba, 0x3b, 0x69, 0xac, 0x29, 0x96, 0xa2, 0x49, 0x60, 0xd2, 0xd8, 0x52, 0x9a, 0xf5, 0x8a,
0x34, 0x57, 0xfc, 0x67, 0x0e, 0xe4, 0xaf, 0x3c, 0x1c, 0xc4, 0x4e, 0x09, 0xd7, 0x18, 0x87, 0x8e,
0x54, 0xa3, 0xac, 0x9b, 0x75, 0xeb, 0xa7, 0x4b, 0xeb, 0xf4, 0x00, 0xdc, 0x9b, 0xe6, 0x64, 0xa9,
0x86, 0xa9, 0x4a, 0x39, 0xb1, 0x1f, 0xd3, 0x86, 0xab, 0x6a, 0x4d, 0x39, 0xd4, 0xac, 0x64, 0xc3,
0xa6, 0x39, 0x24, 0x7f, 0xa9, 0xd2, 0x6c, 0xf1, 0x6f, 0x39, 0x30, 0x3f, 0xfe, 0x2c, 0x48, 0x23,
0x9a, 0x96, 0x62, 0xa9, 0x0d, 0xb5, 0x69, 0x5d, 0x4a, 0x68, 0x15, 0xc0, 0xc9, 0xe1, 0xa6, 0xde,
0x14, 0x99, 0x0c, 0x56, 0x6e, 0x64, 0xaf, 0x56, 0x35, 0x69, 0xe6, 0xaa, 0xb9, 0xa1, 0x57, 0xa5,
0xd9, 0xab, 0x66, 0x45, 0xd3, 0xa4, 0x5b, 0xc5, 0xff, 0xe4, 0xc0, 0xf2, 0xd4, 0x06, 0xfb, 0x39,
0x78, 0x62, 0x19, 0x4a, 0xd3, 0x54, 0x2a, 0xa2, 0xf8, 0x51, 0xdd, 0xd4, 0x35, 0xc5, 0xba, 0x7a,
0xe2, 0xbe, 0x04, 0x2f, 0xa6, 0xbb, 0x19, 0xaa, 0x52, 0x45, 0x87, 0xcd, 0x8a, 0xde, 0x68, 0xd4,
0x2d, 0x4b, 0xad, 0x4a, 0x39, 0xf8, 0x12, 0x3c, 0xfb, 0x1f, 0xbe, 0x23, 0xcf, 0x19, 0xf8, 0x05,
0x78, 0xfe, 0x4b, 0x9e, 0x2d, 0x55, 0xb1, 0x94, 0xb2, 0xa6, 0xc6, 0x22, 0x69, 0x16, 0xbe, 0x00,
0xc5, 0xe9, 0xae, 0xa6, 0x6a, 0xd4, 0x15, 0xad, 0xfe, 0x4e, 0x38, 0x4b, 0xb7, 0x8a, 0x7f, 0x00,
0x73, 0x63, 0x8d, 0xae, 0xb8, 0x0c, 0xca, 0x3f, 0x59, 0xaa, 0x82, 0xf4, 0x43, 0xab, 0x75, 0x68,
0x5d, 0x3d, 0x2b, 0x13, 0xa3, 0x6f, 0xd4, 0x63, 0x29, 0x07, 0x65, 0xb0, 0x3c, 0x61, 0x55, 0xcd,
0x8a, 0xd2, 0x12, 0xf9, 0x16, 0x0d, 0x70, 0x77, 0xd8, 0xd9, 0x8a, 0xa3, 0x7e, 0xdc, 0xd0, 0x50,
0xb9, 0xde, 0x54, 0x8c, 0xcb, 0xc5, 0xb5, 0x02, 0xf2, 0x63, 0x63, 0x65, 0xc5, 0x54, 0xf7, 0xf7,
0xa4, 0x1c, 0x84, 0x60, 0x71, 0xcc, 0x2c, 0xa2, 0xcd, 0x14, 0x8f, 0x63, 0x66, 0xd2, 0xc5, 0xa6,
0x4c, 0xbd, 0x35, 0x65, 0x0b, 0xd6, 0x40, 0x61, 0x6c, 0xac, 0xaa, 0x57, 0x0e, 0xc5, 0xfe, 0x4a,
0x39, 0x51, 0x38, 0x63, 0x03, 0x15, 0xbd, 0x69, 0x09, 0xfb, 0x8c, 0xb8, 0x63, 0x17, 0x27, 0x5b,
0x24, 0x51, 0xb4, 0x65, 0xa5, 0xf2, 0x83, 0xa9, 0x29, 0xe6, 0x1b, 0xf4, 0xe3, 0xa1, 0x6e, 0x5d,
0xbe, 0xbf, 0x0a, 0x60, 0xe9, 0x92, 0x43, 0x12, 0xe0, 0xb2, 0x4a, 0x6f, 0x4a, 0x33, 0x22, 0xa3,
0x2b, 0xf6, 0x5a, 0x4d, 0x9a, 0x85, 0x4f, 0xc0, 0x83, 0xcb, 0x03, 0xa6, 0x52, 0x53, 0x91, 0xda,
0xac, 0xe8, 0x55, 0x71, 0xf0, 0x6f, 0x95, 0x8f, 0xde, 0x59, 0x5d, 0x37, 0xea, 0xf5, 0xdb, 0x25,
0x9b, 0x79, 0x5b, 0x49, 0x1f, 0xb8, 0x99, 0xfc, 0x96, 0xd0, 0x65, 0x9b, 0x5d, 0xe2, 0xc7, 0x1f,
0x91, 0xad, 0x6b, 0xfd, 0xc0, 0xf1, 0xed, 0xc8, 0xd8, 0xbe, 0x1d, 0xeb, 0x5e, 0xfd, 0x37, 0x00,
0x00, 0xff, 0xff, 0xc7, 0x30, 0xd1, 0x37, 0x1b, 0x19, 0x00, 0x00,
}

1301
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/config/postgresql10.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1291
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/config/postgresql11.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1312
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/config/postgresql9_6.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

275
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/database.pb.go generated vendored Normal file
View File

@ -0,0 +1,275 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/postgresql/v1/database.proto
package postgresql // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// A PostgreSQL Database resource. For more information, see
// the [Developer's Guide](/docs/managed-postgresql/concepts).
type Database struct {
// Name of the database.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// ID of the PostgreSQL cluster that the database belongs to.
ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the user assigned as the owner of the database.
Owner string `protobuf:"bytes,3,opt,name=owner,proto3" json:"owner,omitempty"`
// POSIX locale for string sorting order.
// Can only be set at creation time.
LcCollate string `protobuf:"bytes,4,opt,name=lc_collate,json=lcCollate,proto3" json:"lc_collate,omitempty"`
// POSIX locale for character classification.
// Can only be set at creation time.
LcCtype string `protobuf:"bytes,5,opt,name=lc_ctype,json=lcCtype,proto3" json:"lc_ctype,omitempty"`
// PostgreSQL extensions enabled for the database.
Extensions []*Extension `protobuf:"bytes,6,rep,name=extensions,proto3" json:"extensions,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Database) Reset() { *m = Database{} }
func (m *Database) String() string { return proto.CompactTextString(m) }
func (*Database) ProtoMessage() {}
func (*Database) Descriptor() ([]byte, []int) {
return fileDescriptor_database_b1308b0a06a4388e, []int{0}
}
func (m *Database) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Database.Unmarshal(m, b)
}
func (m *Database) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Database.Marshal(b, m, deterministic)
}
func (dst *Database) XXX_Merge(src proto.Message) {
xxx_messageInfo_Database.Merge(dst, src)
}
func (m *Database) XXX_Size() int {
return xxx_messageInfo_Database.Size(m)
}
func (m *Database) XXX_DiscardUnknown() {
xxx_messageInfo_Database.DiscardUnknown(m)
}
var xxx_messageInfo_Database proto.InternalMessageInfo
func (m *Database) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Database) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *Database) GetOwner() string {
if m != nil {
return m.Owner
}
return ""
}
func (m *Database) GetLcCollate() string {
if m != nil {
return m.LcCollate
}
return ""
}
func (m *Database) GetLcCtype() string {
if m != nil {
return m.LcCtype
}
return ""
}
func (m *Database) GetExtensions() []*Extension {
if m != nil {
return m.Extensions
}
return nil
}
type Extension struct {
// Name of the extension, e.g. `pg_trgm` or `pg_btree`.
// Extensions supported by MDB are [listed in the Developer's Guide](/docs/managed-postgresql/concepts).
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Version of the extension.
Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Extension) Reset() { *m = Extension{} }
func (m *Extension) String() string { return proto.CompactTextString(m) }
func (*Extension) ProtoMessage() {}
func (*Extension) Descriptor() ([]byte, []int) {
return fileDescriptor_database_b1308b0a06a4388e, []int{1}
}
func (m *Extension) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Extension.Unmarshal(m, b)
}
func (m *Extension) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Extension.Marshal(b, m, deterministic)
}
func (dst *Extension) XXX_Merge(src proto.Message) {
xxx_messageInfo_Extension.Merge(dst, src)
}
func (m *Extension) XXX_Size() int {
return xxx_messageInfo_Extension.Size(m)
}
func (m *Extension) XXX_DiscardUnknown() {
xxx_messageInfo_Extension.DiscardUnknown(m)
}
var xxx_messageInfo_Extension proto.InternalMessageInfo
func (m *Extension) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Extension) GetVersion() string {
if m != nil {
return m.Version
}
return ""
}
type DatabaseSpec struct {
// Name of the PostgreSQL database. 1-63 characters long.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Name of the user to be assigned as the owner of the database.
// To get the list of available PostgreSQL users, make a [UserService.List] request.
Owner string `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"`
// POSIX locale for string sorting order.
// Can only be set at creation time.
LcCollate string `protobuf:"bytes,3,opt,name=lc_collate,json=lcCollate,proto3" json:"lc_collate,omitempty"`
// POSIX locale for character classification.
// Can only be set at creation time.
LcCtype string `protobuf:"bytes,4,opt,name=lc_ctype,json=lcCtype,proto3" json:"lc_ctype,omitempty"`
// PostgreSQL extensions to be enabled for the database.
Extensions []*Extension `protobuf:"bytes,5,rep,name=extensions,proto3" json:"extensions,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DatabaseSpec) Reset() { *m = DatabaseSpec{} }
func (m *DatabaseSpec) String() string { return proto.CompactTextString(m) }
func (*DatabaseSpec) ProtoMessage() {}
func (*DatabaseSpec) Descriptor() ([]byte, []int) {
return fileDescriptor_database_b1308b0a06a4388e, []int{2}
}
func (m *DatabaseSpec) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DatabaseSpec.Unmarshal(m, b)
}
func (m *DatabaseSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DatabaseSpec.Marshal(b, m, deterministic)
}
func (dst *DatabaseSpec) XXX_Merge(src proto.Message) {
xxx_messageInfo_DatabaseSpec.Merge(dst, src)
}
func (m *DatabaseSpec) XXX_Size() int {
return xxx_messageInfo_DatabaseSpec.Size(m)
}
func (m *DatabaseSpec) XXX_DiscardUnknown() {
xxx_messageInfo_DatabaseSpec.DiscardUnknown(m)
}
var xxx_messageInfo_DatabaseSpec proto.InternalMessageInfo
func (m *DatabaseSpec) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *DatabaseSpec) GetOwner() string {
if m != nil {
return m.Owner
}
return ""
}
func (m *DatabaseSpec) GetLcCollate() string {
if m != nil {
return m.LcCollate
}
return ""
}
func (m *DatabaseSpec) GetLcCtype() string {
if m != nil {
return m.LcCtype
}
return ""
}
func (m *DatabaseSpec) GetExtensions() []*Extension {
if m != nil {
return m.Extensions
}
return nil
}
func init() {
proto.RegisterType((*Database)(nil), "yandex.cloud.mdb.postgresql.v1.Database")
proto.RegisterType((*Extension)(nil), "yandex.cloud.mdb.postgresql.v1.Extension")
proto.RegisterType((*DatabaseSpec)(nil), "yandex.cloud.mdb.postgresql.v1.DatabaseSpec")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/postgresql/v1/database.proto", fileDescriptor_database_b1308b0a06a4388e)
}
var fileDescriptor_database_b1308b0a06a4388e = []byte{
// 407 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x92, 0xcf, 0xaa, 0xd3, 0x40,
0x14, 0x87, 0xc9, 0xbd, 0xe9, 0xbd, 0xb7, 0xe3, 0x9f, 0xc5, 0x28, 0x18, 0x85, 0x96, 0xd2, 0x55,
0x55, 0x66, 0x62, 0x5a, 0x28, 0x16, 0x75, 0x61, 0xaa, 0x42, 0x17, 0x22, 0x54, 0xdd, 0x54, 0x4a,
0x98, 0xcc, 0x0c, 0x31, 0x30, 0xc9, 0xc4, 0x64, 0x1a, 0x5b, 0xe9, 0x13, 0xf8, 0x30, 0xbe, 0x46,
0x7d, 0x04, 0x1f, 0xc1, 0x75, 0x9f, 0x40, 0x32, 0x49, 0x6c, 0x0a, 0xda, 0xcd, 0xdd, 0xcd, 0x99,
0xdf, 0xf9, 0x0e, 0x9c, 0x8f, 0x03, 0xd0, 0x86, 0xc4, 0x8c, 0xaf, 0x6d, 0x2a, 0xe4, 0x8a, 0xd9,
0x11, 0xf3, 0xed, 0x44, 0x66, 0x2a, 0x48, 0x79, 0xf6, 0x45, 0xd8, 0xb9, 0x63, 0x33, 0xa2, 0x88,
0x4f, 0x32, 0x8e, 0x93, 0x54, 0x2a, 0x09, 0xbb, 0x65, 0x3b, 0xd6, 0xed, 0x38, 0x62, 0x3e, 0x3e,
0xb4, 0xe3, 0xdc, 0x79, 0xd0, 0x39, 0x1a, 0x97, 0x13, 0x11, 0x32, 0xa2, 0x42, 0x19, 0x97, 0x78,
0xff, 0x97, 0x01, 0xae, 0x5e, 0x55, 0x13, 0x21, 0x04, 0x66, 0x4c, 0x22, 0x6e, 0x19, 0x3d, 0x63,
0xd0, 0x9e, 0xeb, 0x37, 0xec, 0x00, 0x40, 0xc5, 0x2a, 0x53, 0x3c, 0xf5, 0x42, 0x66, 0x9d, 0xe9,
0xa4, 0x5d, 0xfd, 0xcc, 0x18, 0xbc, 0x0b, 0x5a, 0xf2, 0x6b, 0xcc, 0x53, 0xeb, 0x5c, 0x27, 0x65,
0x51, 0x40, 0x82, 0x7a, 0x54, 0x0a, 0x41, 0x14, 0xb7, 0xcc, 0x12, 0x12, 0x74, 0x5a, 0x7e, 0xc0,
0xfb, 0xe0, 0xaa, 0x88, 0xd5, 0x26, 0xe1, 0x56, 0x4b, 0x87, 0x97, 0x82, 0x4e, 0x8b, 0x12, 0xce,
0x00, 0xe0, 0x6b, 0xc5, 0xe3, 0x2c, 0x94, 0x71, 0x66, 0x5d, 0xf4, 0xce, 0x07, 0x37, 0x86, 0x0f,
0xf1, 0xe9, 0x1d, 0xf1, 0xeb, 0x9a, 0x98, 0x37, 0xe0, 0xfe, 0x04, 0xb4, 0xff, 0x06, 0xff, 0x5c,
0xcd, 0x02, 0x97, 0x39, 0x4f, 0x8b, 0xb8, 0xda, 0xab, 0x2e, 0xfb, 0x3f, 0xce, 0xc0, 0xcd, 0xda,
0xca, 0xfb, 0x84, 0x53, 0x38, 0x6c, 0xe2, 0x6e, 0xf7, 0xf7, 0xce, 0x31, 0xf6, 0x3b, 0xe7, 0xf6,
0x27, 0x82, 0xbe, 0xbd, 0x44, 0x8b, 0x27, 0x68, 0xe2, 0xa1, 0xe5, 0xa3, 0xef, 0x3f, 0x1d, 0xf3,
0xf9, 0x8b, 0xf1, 0xa8, 0x1a, 0x3f, 0xaa, 0xd5, 0xe8, 0xe1, 0x6e, 0xa7, 0x82, 0x6e, 0x35, 0xa0,
0x06, 0x53, 0x99, 0x1b, 0x1f, 0x99, 0xd3, 0x52, 0xdd, 0x7b, 0xfb, 0x9d, 0x73, 0x67, 0x5b, 0x61,
0xde, 0xf2, 0x31, 0xfe, 0xf8, 0xe1, 0x0d, 0x7a, 0xba, 0x9d, 0x36, 0x95, 0x0e, 0x1b, 0x4a, 0xcd,
0xd3, 0xd4, 0x7f, 0x5c, 0xb7, 0xae, 0xe1, 0xda, 0x7d, 0xb7, 0x78, 0x1b, 0x84, 0xea, 0xf3, 0xca,
0xc7, 0x54, 0x46, 0x76, 0x39, 0x02, 0x95, 0x27, 0x17, 0x48, 0x14, 0xf0, 0x58, 0x5f, 0x9b, 0x7d,
0xfa, 0xb4, 0x9f, 0x1d, 0x2a, 0xff, 0x42, 0x03, 0xa3, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x01,
0x69, 0x06, 0xe9, 0x0e, 0x03, 0x00, 0x00,
}

792
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/database_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,792 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/postgresql/v1/database_service.proto
package postgresql // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/api"
import operation "github.com/yandex-cloud/go-genproto/yandex/cloud/operation"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import field_mask "google.golang.org/genproto/protobuf/field_mask"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetDatabaseRequest struct {
// ID of the PostgreSQL cluster that the database belongs to.
// To get the cluster ID use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the PostgreSQL Database resource to return.
// To get the name of the database use a [DatabaseService.List] request.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetDatabaseRequest) Reset() { *m = GetDatabaseRequest{} }
func (m *GetDatabaseRequest) String() string { return proto.CompactTextString(m) }
func (*GetDatabaseRequest) ProtoMessage() {}
func (*GetDatabaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_0cedf08b74fe82ed, []int{0}
}
func (m *GetDatabaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetDatabaseRequest.Unmarshal(m, b)
}
func (m *GetDatabaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetDatabaseRequest.Marshal(b, m, deterministic)
}
func (dst *GetDatabaseRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetDatabaseRequest.Merge(dst, src)
}
func (m *GetDatabaseRequest) XXX_Size() int {
return xxx_messageInfo_GetDatabaseRequest.Size(m)
}
func (m *GetDatabaseRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetDatabaseRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetDatabaseRequest proto.InternalMessageInfo
func (m *GetDatabaseRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *GetDatabaseRequest) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type ListDatabasesRequest struct {
// ID of the PostgreSQL cluster to list databases in.
// To get the cluster ID use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, Set [page_token] to the [ListDatabasesResponse.next_page_token]
// returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListDatabasesRequest) Reset() { *m = ListDatabasesRequest{} }
func (m *ListDatabasesRequest) String() string { return proto.CompactTextString(m) }
func (*ListDatabasesRequest) ProtoMessage() {}
func (*ListDatabasesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_0cedf08b74fe82ed, []int{1}
}
func (m *ListDatabasesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListDatabasesRequest.Unmarshal(m, b)
}
func (m *ListDatabasesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListDatabasesRequest.Marshal(b, m, deterministic)
}
func (dst *ListDatabasesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListDatabasesRequest.Merge(dst, src)
}
func (m *ListDatabasesRequest) XXX_Size() int {
return xxx_messageInfo_ListDatabasesRequest.Size(m)
}
func (m *ListDatabasesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListDatabasesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListDatabasesRequest proto.InternalMessageInfo
func (m *ListDatabasesRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *ListDatabasesRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListDatabasesRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListDatabasesResponse struct {
// List of PostgreSQL Database resources.
Databases []*Database `protobuf:"bytes,1,rep,name=databases,proto3" json:"databases,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListDatabasesRequest.page_size], use the [next_page_token] as the value
// for the [ListDatabasesRequest.page_token] parameter in the next list request. Each subsequent
// list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListDatabasesResponse) Reset() { *m = ListDatabasesResponse{} }
func (m *ListDatabasesResponse) String() string { return proto.CompactTextString(m) }
func (*ListDatabasesResponse) ProtoMessage() {}
func (*ListDatabasesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_0cedf08b74fe82ed, []int{2}
}
func (m *ListDatabasesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListDatabasesResponse.Unmarshal(m, b)
}
func (m *ListDatabasesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListDatabasesResponse.Marshal(b, m, deterministic)
}
func (dst *ListDatabasesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListDatabasesResponse.Merge(dst, src)
}
func (m *ListDatabasesResponse) XXX_Size() int {
return xxx_messageInfo_ListDatabasesResponse.Size(m)
}
func (m *ListDatabasesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListDatabasesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListDatabasesResponse proto.InternalMessageInfo
func (m *ListDatabasesResponse) GetDatabases() []*Database {
if m != nil {
return m.Databases
}
return nil
}
func (m *ListDatabasesResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
type CreateDatabaseRequest struct {
// Required. ID of the PostgreSQL cluster to create a database in.
// To get the cluster ID use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Required. Configuration of the database to create.
DatabaseSpec *DatabaseSpec `protobuf:"bytes,2,opt,name=database_spec,json=databaseSpec,proto3" json:"database_spec,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateDatabaseRequest) Reset() { *m = CreateDatabaseRequest{} }
func (m *CreateDatabaseRequest) String() string { return proto.CompactTextString(m) }
func (*CreateDatabaseRequest) ProtoMessage() {}
func (*CreateDatabaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_0cedf08b74fe82ed, []int{3}
}
func (m *CreateDatabaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateDatabaseRequest.Unmarshal(m, b)
}
func (m *CreateDatabaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateDatabaseRequest.Marshal(b, m, deterministic)
}
func (dst *CreateDatabaseRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateDatabaseRequest.Merge(dst, src)
}
func (m *CreateDatabaseRequest) XXX_Size() int {
return xxx_messageInfo_CreateDatabaseRequest.Size(m)
}
func (m *CreateDatabaseRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateDatabaseRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateDatabaseRequest proto.InternalMessageInfo
func (m *CreateDatabaseRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *CreateDatabaseRequest) GetDatabaseSpec() *DatabaseSpec {
if m != nil {
return m.DatabaseSpec
}
return nil
}
type CreateDatabaseMetadata struct {
// ID of the PostgreSQL cluster where a database is being created.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the PostgreSQL database that is being created.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateDatabaseMetadata) Reset() { *m = CreateDatabaseMetadata{} }
func (m *CreateDatabaseMetadata) String() string { return proto.CompactTextString(m) }
func (*CreateDatabaseMetadata) ProtoMessage() {}
func (*CreateDatabaseMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_0cedf08b74fe82ed, []int{4}
}
func (m *CreateDatabaseMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateDatabaseMetadata.Unmarshal(m, b)
}
func (m *CreateDatabaseMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateDatabaseMetadata.Marshal(b, m, deterministic)
}
func (dst *CreateDatabaseMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateDatabaseMetadata.Merge(dst, src)
}
func (m *CreateDatabaseMetadata) XXX_Size() int {
return xxx_messageInfo_CreateDatabaseMetadata.Size(m)
}
func (m *CreateDatabaseMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_CreateDatabaseMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_CreateDatabaseMetadata proto.InternalMessageInfo
func (m *CreateDatabaseMetadata) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *CreateDatabaseMetadata) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type UpdateDatabaseRequest struct {
// Required. ID of the PostgreSQL cluster to update a database in.
// To get the cluster ID use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Required. Name of the database to update.
// To get the name of the database use a [DatabaseService.List] request.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
// Field mask that specifies which fields of the Database resource should be updated.
UpdateMask *field_mask.FieldMask `protobuf:"bytes,3,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"`
// PostgreSQL extensions that should be enabled for the database.
//
// If the field is sent, the list of enabled extensions is rewritten entirely.
// Therefore, to disable an active extension you should simply send the list omitting this extension.
Extensions []*Extension `protobuf:"bytes,4,rep,name=extensions,proto3" json:"extensions,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UpdateDatabaseRequest) Reset() { *m = UpdateDatabaseRequest{} }
func (m *UpdateDatabaseRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateDatabaseRequest) ProtoMessage() {}
func (*UpdateDatabaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_0cedf08b74fe82ed, []int{5}
}
func (m *UpdateDatabaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateDatabaseRequest.Unmarshal(m, b)
}
func (m *UpdateDatabaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UpdateDatabaseRequest.Marshal(b, m, deterministic)
}
func (dst *UpdateDatabaseRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_UpdateDatabaseRequest.Merge(dst, src)
}
func (m *UpdateDatabaseRequest) XXX_Size() int {
return xxx_messageInfo_UpdateDatabaseRequest.Size(m)
}
func (m *UpdateDatabaseRequest) XXX_DiscardUnknown() {
xxx_messageInfo_UpdateDatabaseRequest.DiscardUnknown(m)
}
var xxx_messageInfo_UpdateDatabaseRequest proto.InternalMessageInfo
func (m *UpdateDatabaseRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *UpdateDatabaseRequest) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
func (m *UpdateDatabaseRequest) GetUpdateMask() *field_mask.FieldMask {
if m != nil {
return m.UpdateMask
}
return nil
}
func (m *UpdateDatabaseRequest) GetExtensions() []*Extension {
if m != nil {
return m.Extensions
}
return nil
}
type UpdateDatabaseMetadata struct {
// ID of the PostgreSQL cluster where a database is being updated.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the PostgreSQL database that is being updated.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UpdateDatabaseMetadata) Reset() { *m = UpdateDatabaseMetadata{} }
func (m *UpdateDatabaseMetadata) String() string { return proto.CompactTextString(m) }
func (*UpdateDatabaseMetadata) ProtoMessage() {}
func (*UpdateDatabaseMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_0cedf08b74fe82ed, []int{6}
}
func (m *UpdateDatabaseMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UpdateDatabaseMetadata.Unmarshal(m, b)
}
func (m *UpdateDatabaseMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UpdateDatabaseMetadata.Marshal(b, m, deterministic)
}
func (dst *UpdateDatabaseMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_UpdateDatabaseMetadata.Merge(dst, src)
}
func (m *UpdateDatabaseMetadata) XXX_Size() int {
return xxx_messageInfo_UpdateDatabaseMetadata.Size(m)
}
func (m *UpdateDatabaseMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_UpdateDatabaseMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_UpdateDatabaseMetadata proto.InternalMessageInfo
func (m *UpdateDatabaseMetadata) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *UpdateDatabaseMetadata) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type DeleteDatabaseRequest struct {
// Required. ID of the PostgreSQL cluster to delete a database in.
// To get the cluster ID, use a [ClusterService.List] request.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Required. Name of the database to delete.
// To get the name of the database, use a [DatabaseService.List] request.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteDatabaseRequest) Reset() { *m = DeleteDatabaseRequest{} }
func (m *DeleteDatabaseRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteDatabaseRequest) ProtoMessage() {}
func (*DeleteDatabaseRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_0cedf08b74fe82ed, []int{7}
}
func (m *DeleteDatabaseRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteDatabaseRequest.Unmarshal(m, b)
}
func (m *DeleteDatabaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteDatabaseRequest.Marshal(b, m, deterministic)
}
func (dst *DeleteDatabaseRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteDatabaseRequest.Merge(dst, src)
}
func (m *DeleteDatabaseRequest) XXX_Size() int {
return xxx_messageInfo_DeleteDatabaseRequest.Size(m)
}
func (m *DeleteDatabaseRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteDatabaseRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteDatabaseRequest proto.InternalMessageInfo
func (m *DeleteDatabaseRequest) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *DeleteDatabaseRequest) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type DeleteDatabaseMetadata struct {
// ID of the PostgreSQL cluster where a database is being deleted.
ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Name of the PostgreSQL database that is being deleted.
DatabaseName string `protobuf:"bytes,2,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteDatabaseMetadata) Reset() { *m = DeleteDatabaseMetadata{} }
func (m *DeleteDatabaseMetadata) String() string { return proto.CompactTextString(m) }
func (*DeleteDatabaseMetadata) ProtoMessage() {}
func (*DeleteDatabaseMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_database_service_0cedf08b74fe82ed, []int{8}
}
func (m *DeleteDatabaseMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DeleteDatabaseMetadata.Unmarshal(m, b)
}
func (m *DeleteDatabaseMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DeleteDatabaseMetadata.Marshal(b, m, deterministic)
}
func (dst *DeleteDatabaseMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_DeleteDatabaseMetadata.Merge(dst, src)
}
func (m *DeleteDatabaseMetadata) XXX_Size() int {
return xxx_messageInfo_DeleteDatabaseMetadata.Size(m)
}
func (m *DeleteDatabaseMetadata) XXX_DiscardUnknown() {
xxx_messageInfo_DeleteDatabaseMetadata.DiscardUnknown(m)
}
var xxx_messageInfo_DeleteDatabaseMetadata proto.InternalMessageInfo
func (m *DeleteDatabaseMetadata) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *DeleteDatabaseMetadata) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
func init() {
proto.RegisterType((*GetDatabaseRequest)(nil), "yandex.cloud.mdb.postgresql.v1.GetDatabaseRequest")
proto.RegisterType((*ListDatabasesRequest)(nil), "yandex.cloud.mdb.postgresql.v1.ListDatabasesRequest")
proto.RegisterType((*ListDatabasesResponse)(nil), "yandex.cloud.mdb.postgresql.v1.ListDatabasesResponse")
proto.RegisterType((*CreateDatabaseRequest)(nil), "yandex.cloud.mdb.postgresql.v1.CreateDatabaseRequest")
proto.RegisterType((*CreateDatabaseMetadata)(nil), "yandex.cloud.mdb.postgresql.v1.CreateDatabaseMetadata")
proto.RegisterType((*UpdateDatabaseRequest)(nil), "yandex.cloud.mdb.postgresql.v1.UpdateDatabaseRequest")
proto.RegisterType((*UpdateDatabaseMetadata)(nil), "yandex.cloud.mdb.postgresql.v1.UpdateDatabaseMetadata")
proto.RegisterType((*DeleteDatabaseRequest)(nil), "yandex.cloud.mdb.postgresql.v1.DeleteDatabaseRequest")
proto.RegisterType((*DeleteDatabaseMetadata)(nil), "yandex.cloud.mdb.postgresql.v1.DeleteDatabaseMetadata")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// DatabaseServiceClient is the client API for DatabaseService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DatabaseServiceClient interface {
// Returns the specified PostgreSQL Database resource.
//
// To get the list of available PostgreSQL Database resources, make a [List] request.
Get(ctx context.Context, in *GetDatabaseRequest, opts ...grpc.CallOption) (*Database, error)
// Retrieves the list of PostgreSQL Database resources in the specified cluster.
List(ctx context.Context, in *ListDatabasesRequest, opts ...grpc.CallOption) (*ListDatabasesResponse, error)
// Creates a new PostgreSQL database in the specified cluster.
Create(ctx context.Context, in *CreateDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error)
// Updates the specified PostgreSQL database.
Update(ctx context.Context, in *UpdateDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error)
// Deletes the specified PostgreSQL database.
Delete(ctx context.Context, in *DeleteDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error)
}
type databaseServiceClient struct {
cc *grpc.ClientConn
}
func NewDatabaseServiceClient(cc *grpc.ClientConn) DatabaseServiceClient {
return &databaseServiceClient{cc}
}
func (c *databaseServiceClient) Get(ctx context.Context, in *GetDatabaseRequest, opts ...grpc.CallOption) (*Database, error) {
out := new(Database)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.postgresql.v1.DatabaseService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *databaseServiceClient) List(ctx context.Context, in *ListDatabasesRequest, opts ...grpc.CallOption) (*ListDatabasesResponse, error) {
out := new(ListDatabasesResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.postgresql.v1.DatabaseService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *databaseServiceClient) Create(ctx context.Context, in *CreateDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.postgresql.v1.DatabaseService/Create", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *databaseServiceClient) Update(ctx context.Context, in *UpdateDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.postgresql.v1.DatabaseService/Update", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *databaseServiceClient) Delete(ctx context.Context, in *DeleteDatabaseRequest, opts ...grpc.CallOption) (*operation.Operation, error) {
out := new(operation.Operation)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.postgresql.v1.DatabaseService/Delete", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// DatabaseServiceServer is the server API for DatabaseService service.
type DatabaseServiceServer interface {
// Returns the specified PostgreSQL Database resource.
//
// To get the list of available PostgreSQL Database resources, make a [List] request.
Get(context.Context, *GetDatabaseRequest) (*Database, error)
// Retrieves the list of PostgreSQL Database resources in the specified cluster.
List(context.Context, *ListDatabasesRequest) (*ListDatabasesResponse, error)
// Creates a new PostgreSQL database in the specified cluster.
Create(context.Context, *CreateDatabaseRequest) (*operation.Operation, error)
// Updates the specified PostgreSQL database.
Update(context.Context, *UpdateDatabaseRequest) (*operation.Operation, error)
// Deletes the specified PostgreSQL database.
Delete(context.Context, *DeleteDatabaseRequest) (*operation.Operation, error)
}
func RegisterDatabaseServiceServer(s *grpc.Server, srv DatabaseServiceServer) {
s.RegisterService(&_DatabaseService_serviceDesc, srv)
}
func _DatabaseService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetDatabaseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.postgresql.v1.DatabaseService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).Get(ctx, req.(*GetDatabaseRequest))
}
return interceptor(ctx, in, info, handler)
}
func _DatabaseService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListDatabasesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.postgresql.v1.DatabaseService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).List(ctx, req.(*ListDatabasesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _DatabaseService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateDatabaseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.postgresql.v1.DatabaseService/Create",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).Create(ctx, req.(*CreateDatabaseRequest))
}
return interceptor(ctx, in, info, handler)
}
func _DatabaseService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UpdateDatabaseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).Update(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.postgresql.v1.DatabaseService/Update",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).Update(ctx, req.(*UpdateDatabaseRequest))
}
return interceptor(ctx, in, info, handler)
}
func _DatabaseService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteDatabaseRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DatabaseServiceServer).Delete(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.postgresql.v1.DatabaseService/Delete",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DatabaseServiceServer).Delete(ctx, req.(*DeleteDatabaseRequest))
}
return interceptor(ctx, in, info, handler)
}
var _DatabaseService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.mdb.postgresql.v1.DatabaseService",
HandlerType: (*DatabaseServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _DatabaseService_Get_Handler,
},
{
MethodName: "List",
Handler: _DatabaseService_List_Handler,
},
{
MethodName: "Create",
Handler: _DatabaseService_Create_Handler,
},
{
MethodName: "Update",
Handler: _DatabaseService_Update_Handler,
},
{
MethodName: "Delete",
Handler: _DatabaseService_Delete_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/mdb/postgresql/v1/database_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/postgresql/v1/database_service.proto", fileDescriptor_database_service_0cedf08b74fe82ed)
}
var fileDescriptor_database_service_0cedf08b74fe82ed = []byte{
// 818 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0x4d, 0x4f, 0x1b, 0x47,
0x18, 0xd6, 0x62, 0xd7, 0xc2, 0x63, 0x28, 0xd2, 0xa8, 0xae, 0x2c, 0xab, 0x20, 0xba, 0x95, 0xa8,
0xeb, 0x76, 0x77, 0xbd, 0xa6, 0xa0, 0xb6, 0x40, 0xa5, 0x9a, 0xaf, 0xa2, 0x04, 0x88, 0x96, 0x44,
0x91, 0x48, 0x22, 0x6b, 0xec, 0x1d, 0x36, 0x2b, 0xbc, 0x1f, 0x78, 0xc6, 0x0e, 0x1f, 0xe2, 0x90,
0x1c, 0x12, 0x85, 0x5b, 0x12, 0x29, 0xb7, 0xfc, 0x09, 0xf2, 0x23, 0x40, 0xca, 0x8d, 0x1c, 0x73,
0x8d, 0xa2, 0x9c, 0x73, 0xcc, 0x29, 0x9a, 0x19, 0x7f, 0x2d, 0x18, 0xec, 0x80, 0x0f, 0xb9, 0xed,
0xce, 0xfb, 0x3e, 0xb3, 0xcf, 0xf3, 0xce, 0xfb, 0x3e, 0x3b, 0x60, 0x62, 0x07, 0xb9, 0x26, 0xde,
0xd6, 0x8a, 0x25, 0xaf, 0x62, 0x6a, 0x8e, 0x59, 0xd0, 0x7c, 0x8f, 0x50, 0xab, 0x8c, 0xc9, 0x56,
0x49, 0xab, 0xea, 0x9a, 0x89, 0x28, 0x2a, 0x20, 0x82, 0xf3, 0x04, 0x97, 0xab, 0x76, 0x11, 0xab,
0x7e, 0xd9, 0xa3, 0x1e, 0x1c, 0x11, 0x30, 0x95, 0xc3, 0x54, 0xc7, 0x2c, 0xa8, 0x4d, 0x98, 0x5a,
0xd5, 0x93, 0x3f, 0x59, 0x9e, 0x67, 0x95, 0xb0, 0x86, 0x7c, 0x5b, 0x43, 0xae, 0xeb, 0x51, 0x44,
0x6d, 0xcf, 0x25, 0x02, 0x9d, 0x1c, 0xad, 0x45, 0xf9, 0x5b, 0xa1, 0xb2, 0xa1, 0x6d, 0xd8, 0xb8,
0x64, 0xe6, 0x1d, 0x44, 0x36, 0x6b, 0x19, 0xc9, 0x1a, 0x2d, 0x86, 0xf7, 0x7c, 0x5c, 0xe6, 0xf0,
0x5a, 0x6c, 0x38, 0x40, 0xb9, 0x8a, 0x4a, 0xb6, 0xd9, 0x1a, 0x1e, 0x0b, 0x84, 0x1b, 0xe0, 0x33,
0xdb, 0x28, 0x5d, 0x2a, 0x17, 0xe9, 0xf2, 0x63, 0x09, 0xc0, 0x45, 0x4c, 0xe7, 0x6a, 0xab, 0x06,
0xde, 0xaa, 0x60, 0x42, 0xe1, 0xef, 0x00, 0x14, 0x4b, 0x15, 0x42, 0x71, 0x39, 0x6f, 0x9b, 0x09,
0x69, 0x54, 0x4a, 0x45, 0x73, 0x03, 0x1f, 0x8f, 0x74, 0xe9, 0xe0, 0x58, 0x0f, 0x4f, 0xcf, 0x4c,
0x64, 0x8c, 0x68, 0x2d, 0xbe, 0x64, 0xc2, 0x59, 0x30, 0xd8, 0xa8, 0xa7, 0x8b, 0x1c, 0x9c, 0xe8,
0xe3, 0xf9, 0x23, 0x2c, 0xff, 0xd3, 0x91, 0xfe, 0xfd, 0x1d, 0xa4, 0xec, 0xfe, 0xa7, 0xac, 0x67,
0x94, 0xbf, 0xf3, 0xca, 0xbd, 0xb4, 0xd8, 0x61, 0x72, 0xdc, 0x18, 0xa8, 0x83, 0x56, 0x90, 0x83,
0xe5, 0x97, 0x12, 0xf8, 0xe1, 0xba, 0x4d, 0x1a, 0x4c, 0xc8, 0xa5, 0xa8, 0xfc, 0x0a, 0xa2, 0x3e,
0xb2, 0x70, 0x9e, 0xd8, 0xbb, 0x82, 0x46, 0x28, 0x07, 0x3e, 0x1f, 0xe9, 0x91, 0xe9, 0x19, 0x3d,
0x93, 0xc9, 0x18, 0xfd, 0x2c, 0xb8, 0x66, 0xef, 0x62, 0x98, 0x02, 0x80, 0x27, 0x52, 0x6f, 0x13,
0xbb, 0x89, 0x10, 0xdf, 0x35, 0x7a, 0x70, 0xac, 0x7f, 0xc7, 0x33, 0x0d, 0xbe, 0xcb, 0x4d, 0x16,
0x93, 0x9f, 0x48, 0x20, 0x7e, 0x8a, 0x18, 0xf1, 0x3d, 0x97, 0x60, 0xb8, 0x00, 0xa2, 0x75, 0x09,
0x24, 0x21, 0x8d, 0x86, 0x52, 0xb1, 0x6c, 0x4a, 0xbd, 0xb8, 0x83, 0xd4, 0x46, 0xa1, 0x9b, 0x50,
0x38, 0x06, 0x86, 0x5c, 0xbc, 0x4d, 0xf3, 0x2d, 0x84, 0x78, 0x05, 0x8d, 0x41, 0xb6, 0x7c, 0xa3,
0xc1, 0xe4, 0x95, 0x04, 0xe2, 0xb3, 0x65, 0x8c, 0x28, 0xbe, 0xd2, 0x71, 0xdd, 0x6e, 0x39, 0x2e,
0xe2, 0xe3, 0x22, 0xff, 0x58, 0x2c, 0xfb, 0x47, 0xb7, 0xd4, 0xd7, 0x7c, 0x5c, 0xcc, 0x85, 0xd9,
0xee, 0xcd, 0x23, 0x64, 0x6b, 0xf2, 0x5d, 0xf0, 0x63, 0x90, 0xde, 0x32, 0xa6, 0x88, 0x65, 0xc0,
0xe1, 0xb3, 0xfc, 0x5a, 0x19, 0xfd, 0xd2, 0xb6, 0x81, 0x4e, 0x35, 0xc8, 0xb3, 0x3e, 0x10, 0xbf,
0xe5, 0x9b, 0x57, 0x55, 0xdf, 0x8b, 0x66, 0x85, 0x53, 0x20, 0x56, 0xe1, 0x54, 0xf8, 0x70, 0xf3,
0xf6, 0x89, 0x65, 0x93, 0xaa, 0x98, 0x7f, 0xb5, 0x3e, 0xff, 0xea, 0x02, 0x9b, 0xff, 0x65, 0x44,
0x36, 0x0d, 0x20, 0xd2, 0xd9, 0x33, 0x5c, 0x02, 0x00, 0x6f, 0x53, 0xec, 0x12, 0x66, 0x1d, 0x89,
0x30, 0xef, 0x9b, 0xdf, 0x3a, 0x15, 0x7f, 0xbe, 0x8e, 0x30, 0x5a, 0xc0, 0xac, 0xe2, 0xc1, 0x92,
0xf4, 0xb4, 0xe2, 0x4f, 0x25, 0x10, 0x9f, 0xc3, 0x25, 0xfc, 0x0d, 0x54, 0x9c, 0x29, 0x0d, 0x52,
0xe9, 0xa5, 0xd2, 0xec, 0xf3, 0x7e, 0x30, 0xd4, 0x68, 0x6f, 0xf1, 0x47, 0x80, 0xaf, 0x25, 0x10,
0x5a, 0xc4, 0x14, 0x66, 0x3b, 0x1d, 0xcd, 0x59, 0xfb, 0x4c, 0x76, 0x6d, 0x03, 0xf2, 0xca, 0xa3,
0xb7, 0xef, 0x5f, 0xf4, 0xfd, 0x0f, 0x17, 0x34, 0x07, 0xb9, 0xc8, 0xc2, 0xa6, 0x12, 0xb4, 0xeb,
0x9a, 0x10, 0xa2, 0xed, 0x35, 0x45, 0xee, 0x37, 0x4c, 0x9c, 0x68, 0x7b, 0x01, 0x71, 0xfb, 0x8c,
0x75, 0x98, 0xb9, 0x15, 0xfc, 0xb3, 0x13, 0x85, 0x76, 0x66, 0x9b, 0x9c, 0xf8, 0x4a, 0x94, 0x70,
0x42, 0xf9, 0x5f, 0xae, 0xe2, 0x2f, 0x38, 0x79, 0x39, 0x15, 0xf0, 0x8d, 0x04, 0x22, 0xc2, 0x3a,
0x60, 0x47, 0x06, 0x6d, 0x1d, 0x30, 0xf9, 0x73, 0x10, 0xd6, 0xfc, 0x2b, 0xae, 0xd6, 0x9f, 0x64,
0xeb, 0xf0, 0x24, 0x2d, 0x9f, 0x6b, 0x51, 0xfd, 0xf5, 0x15, 0x2e, 0x65, 0x4a, 0xbe, 0xa4, 0x94,
0x7f, 0xa4, 0x34, 0x7c, 0x27, 0x81, 0x88, 0x18, 0xcb, 0xce, 0x6a, 0xda, 0x3a, 0x5a, 0x37, 0x6a,
0x1e, 0x08, 0x35, 0xe7, 0x8c, 0x7f, 0x50, 0xcd, 0xb5, 0x6c, 0x8f, 0xda, 0x8b, 0xa9, 0xfb, 0x20,
0x81, 0x88, 0x18, 0xc5, 0xce, 0xea, 0xda, 0xba, 0x47, 0x37, 0xea, 0x1e, 0x4a, 0x87, 0x27, 0x69,
0xed, 0xdc, 0x99, 0x8f, 0x9f, 0x76, 0xda, 0x79, 0xc7, 0xa7, 0x3b, 0x62, 0x94, 0xd2, 0x3d, 0xd2,
0x9a, 0x5b, 0x5d, 0x5f, 0xb6, 0x6c, 0x7a, 0xbf, 0x52, 0x50, 0x8b, 0x9e, 0xa3, 0x09, 0xca, 0x8a,
0xb8, 0x56, 0x59, 0x9e, 0x62, 0x61, 0x97, 0x7f, 0x5d, 0xbb, 0xf8, 0xbe, 0x35, 0xd5, 0x7c, 0x2b,
0x44, 0x38, 0x60, 0xfc, 0x4b, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4c, 0xef, 0xdf, 0x75, 0x9d, 0x0a,
0x00, 0x00,
}

112
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/resource_preset.pb.go generated vendored Normal file
View File

@ -0,0 +1,112 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/postgresql/v1/resource_preset.proto
package postgresql // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// A ResourcePreset resource for describing hardware configuration presets.
type ResourcePreset struct {
// ID of the ResourcePreset resource.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// IDs of availability zones where the resource preset is available.
ZoneIds []string `protobuf:"bytes,2,rep,name=zone_ids,json=zoneIds,proto3" json:"zone_ids,omitempty"`
// Number of CPU cores for a PostgreSQL host created with the preset.
Cores int64 `protobuf:"varint,3,opt,name=cores,proto3" json:"cores,omitempty"`
// RAM volume for a PostgreSQL host created with the preset, in bytes.
Memory int64 `protobuf:"varint,4,opt,name=memory,proto3" json:"memory,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ResourcePreset) Reset() { *m = ResourcePreset{} }
func (m *ResourcePreset) String() string { return proto.CompactTextString(m) }
func (*ResourcePreset) ProtoMessage() {}
func (*ResourcePreset) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_4cba9c3462d84462, []int{0}
}
func (m *ResourcePreset) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ResourcePreset.Unmarshal(m, b)
}
func (m *ResourcePreset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ResourcePreset.Marshal(b, m, deterministic)
}
func (dst *ResourcePreset) XXX_Merge(src proto.Message) {
xxx_messageInfo_ResourcePreset.Merge(dst, src)
}
func (m *ResourcePreset) XXX_Size() int {
return xxx_messageInfo_ResourcePreset.Size(m)
}
func (m *ResourcePreset) XXX_DiscardUnknown() {
xxx_messageInfo_ResourcePreset.DiscardUnknown(m)
}
var xxx_messageInfo_ResourcePreset proto.InternalMessageInfo
func (m *ResourcePreset) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *ResourcePreset) GetZoneIds() []string {
if m != nil {
return m.ZoneIds
}
return nil
}
func (m *ResourcePreset) GetCores() int64 {
if m != nil {
return m.Cores
}
return 0
}
func (m *ResourcePreset) GetMemory() int64 {
if m != nil {
return m.Memory
}
return 0
}
func init() {
proto.RegisterType((*ResourcePreset)(nil), "yandex.cloud.mdb.postgresql.v1.ResourcePreset")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/postgresql/v1/resource_preset.proto", fileDescriptor_resource_preset_4cba9c3462d84462)
}
var fileDescriptor_resource_preset_4cba9c3462d84462 = []byte{
// 215 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0xcf, 0xb1, 0x4b, 0x03, 0x31,
0x14, 0xc7, 0x71, 0xee, 0x4e, 0xab, 0xcd, 0xd0, 0x21, 0x88, 0xc4, 0x45, 0x0e, 0xa7, 0x5b, 0x9a,
0x50, 0x74, 0x73, 0x73, 0x73, 0x10, 0x25, 0xa3, 0x4b, 0x31, 0x79, 0x8f, 0x18, 0x68, 0xee, 0x9d,
0x49, 0xae, 0x58, 0xff, 0x7a, 0x31, 0x29, 0x74, 0x73, 0xfc, 0x3e, 0xf8, 0xc0, 0xfb, 0xb1, 0x87,
0xc3, 0xc7, 0x08, 0xf8, 0xad, 0xec, 0x8e, 0x66, 0x50, 0x01, 0x8c, 0x9a, 0x28, 0x65, 0x17, 0x31,
0x7d, 0xed, 0xd4, 0x7e, 0xa3, 0x22, 0x26, 0x9a, 0xa3, 0xc5, 0xed, 0x14, 0x31, 0x61, 0x96, 0x53,
0xa4, 0x4c, 0xfc, 0xb6, 0x2a, 0x59, 0x94, 0x0c, 0x60, 0xe4, 0x49, 0xc9, 0xfd, 0xe6, 0xce, 0xb3,
0x95, 0x3e, 0xc2, 0xb7, 0xe2, 0xf8, 0x8a, 0xb5, 0x1e, 0x44, 0xd3, 0x37, 0xc3, 0x52, 0xb7, 0x1e,
0xf8, 0x0d, 0xbb, 0xfc, 0xa1, 0x11, 0xb7, 0x1e, 0x92, 0x68, 0xfb, 0x6e, 0x58, 0xea, 0x8b, 0xbf,
0x7e, 0x86, 0xc4, 0xaf, 0xd8, 0xb9, 0xa5, 0x88, 0x49, 0x74, 0x7d, 0x33, 0x74, 0xba, 0x06, 0xbf,
0x66, 0x8b, 0x80, 0x81, 0xe2, 0x41, 0x9c, 0x95, 0xf3, 0xb1, 0x9e, 0x5e, 0xdf, 0x5f, 0x9c, 0xcf,
0x9f, 0xb3, 0x91, 0x96, 0x82, 0xaa, 0x7f, 0xad, 0xeb, 0x1a, 0x47, 0x6b, 0x87, 0x63, 0xf9, 0x58,
0xfd, 0x3f, 0xf3, 0xf1, 0x54, 0x66, 0x51, 0xc0, 0xfd, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x6f,
0x56, 0x82, 0xa9, 0x1a, 0x01, 0x00, 0x00,
}

324
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/resource_preset_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,324 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/postgresql/v1/resource_preset_service.proto
package postgresql // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetResourcePresetRequest struct {
// Required. ID of the resource preset to return.
// To get the resource preset ID, use a [ResourcePresetService.List] request.
ResourcePresetId string `protobuf:"bytes,1,opt,name=resource_preset_id,json=resourcePresetId,proto3" json:"resource_preset_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetResourcePresetRequest) Reset() { *m = GetResourcePresetRequest{} }
func (m *GetResourcePresetRequest) String() string { return proto.CompactTextString(m) }
func (*GetResourcePresetRequest) ProtoMessage() {}
func (*GetResourcePresetRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_service_5dc2866710ef140a, []int{0}
}
func (m *GetResourcePresetRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetResourcePresetRequest.Unmarshal(m, b)
}
func (m *GetResourcePresetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetResourcePresetRequest.Marshal(b, m, deterministic)
}
func (dst *GetResourcePresetRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetResourcePresetRequest.Merge(dst, src)
}
func (m *GetResourcePresetRequest) XXX_Size() int {
return xxx_messageInfo_GetResourcePresetRequest.Size(m)
}
func (m *GetResourcePresetRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetResourcePresetRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetResourcePresetRequest proto.InternalMessageInfo
func (m *GetResourcePresetRequest) GetResourcePresetId() string {
if m != nil {
return m.ResourcePresetId
}
return ""
}
type ListResourcePresetsRequest struct {
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size], the service returns a [ListResourcePresetsResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the [ListResourcePresetsResponse.next_page_token]
// returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListResourcePresetsRequest) Reset() { *m = ListResourcePresetsRequest{} }
func (m *ListResourcePresetsRequest) String() string { return proto.CompactTextString(m) }
func (*ListResourcePresetsRequest) ProtoMessage() {}
func (*ListResourcePresetsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_service_5dc2866710ef140a, []int{1}
}
func (m *ListResourcePresetsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListResourcePresetsRequest.Unmarshal(m, b)
}
func (m *ListResourcePresetsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListResourcePresetsRequest.Marshal(b, m, deterministic)
}
func (dst *ListResourcePresetsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListResourcePresetsRequest.Merge(dst, src)
}
func (m *ListResourcePresetsRequest) XXX_Size() int {
return xxx_messageInfo_ListResourcePresetsRequest.Size(m)
}
func (m *ListResourcePresetsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListResourcePresetsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListResourcePresetsRequest proto.InternalMessageInfo
func (m *ListResourcePresetsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListResourcePresetsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListResourcePresetsResponse struct {
// List of ResourcePreset resources.
ResourcePresets []*ResourcePreset `protobuf:"bytes,1,rep,name=resource_presets,json=resourcePresets,proto3" json:"resource_presets,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListResourcePresetsRequest.page_size], use the [next_page_token] as the value
// for the [ListResourcePresetsRequest.page_token] parameter in the next list request. Each subsequent
// list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListResourcePresetsResponse) Reset() { *m = ListResourcePresetsResponse{} }
func (m *ListResourcePresetsResponse) String() string { return proto.CompactTextString(m) }
func (*ListResourcePresetsResponse) ProtoMessage() {}
func (*ListResourcePresetsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_resource_preset_service_5dc2866710ef140a, []int{2}
}
func (m *ListResourcePresetsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListResourcePresetsResponse.Unmarshal(m, b)
}
func (m *ListResourcePresetsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListResourcePresetsResponse.Marshal(b, m, deterministic)
}
func (dst *ListResourcePresetsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListResourcePresetsResponse.Merge(dst, src)
}
func (m *ListResourcePresetsResponse) XXX_Size() int {
return xxx_messageInfo_ListResourcePresetsResponse.Size(m)
}
func (m *ListResourcePresetsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListResourcePresetsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListResourcePresetsResponse proto.InternalMessageInfo
func (m *ListResourcePresetsResponse) GetResourcePresets() []*ResourcePreset {
if m != nil {
return m.ResourcePresets
}
return nil
}
func (m *ListResourcePresetsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetResourcePresetRequest)(nil), "yandex.cloud.mdb.postgresql.v1.GetResourcePresetRequest")
proto.RegisterType((*ListResourcePresetsRequest)(nil), "yandex.cloud.mdb.postgresql.v1.ListResourcePresetsRequest")
proto.RegisterType((*ListResourcePresetsResponse)(nil), "yandex.cloud.mdb.postgresql.v1.ListResourcePresetsResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// ResourcePresetServiceClient is the client API for ResourcePresetService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ResourcePresetServiceClient interface {
// Returns the specified ResourcePreset resource.
//
// To get the list of available ResourcePreset resources, make a [List] request.
Get(ctx context.Context, in *GetResourcePresetRequest, opts ...grpc.CallOption) (*ResourcePreset, error)
// Retrieves the list of available ResourcePreset resources.
List(ctx context.Context, in *ListResourcePresetsRequest, opts ...grpc.CallOption) (*ListResourcePresetsResponse, error)
}
type resourcePresetServiceClient struct {
cc *grpc.ClientConn
}
func NewResourcePresetServiceClient(cc *grpc.ClientConn) ResourcePresetServiceClient {
return &resourcePresetServiceClient{cc}
}
func (c *resourcePresetServiceClient) Get(ctx context.Context, in *GetResourcePresetRequest, opts ...grpc.CallOption) (*ResourcePreset, error) {
out := new(ResourcePreset)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.postgresql.v1.ResourcePresetService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *resourcePresetServiceClient) List(ctx context.Context, in *ListResourcePresetsRequest, opts ...grpc.CallOption) (*ListResourcePresetsResponse, error) {
out := new(ListResourcePresetsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.postgresql.v1.ResourcePresetService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// ResourcePresetServiceServer is the server API for ResourcePresetService service.
type ResourcePresetServiceServer interface {
// Returns the specified ResourcePreset resource.
//
// To get the list of available ResourcePreset resources, make a [List] request.
Get(context.Context, *GetResourcePresetRequest) (*ResourcePreset, error)
// Retrieves the list of available ResourcePreset resources.
List(context.Context, *ListResourcePresetsRequest) (*ListResourcePresetsResponse, error)
}
func RegisterResourcePresetServiceServer(s *grpc.Server, srv ResourcePresetServiceServer) {
s.RegisterService(&_ResourcePresetService_serviceDesc, srv)
}
func _ResourcePresetService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetResourcePresetRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ResourcePresetServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.postgresql.v1.ResourcePresetService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ResourcePresetServiceServer).Get(ctx, req.(*GetResourcePresetRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ResourcePresetService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListResourcePresetsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ResourcePresetServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.postgresql.v1.ResourcePresetService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ResourcePresetServiceServer).List(ctx, req.(*ListResourcePresetsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ResourcePresetService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.mdb.postgresql.v1.ResourcePresetService",
HandlerType: (*ResourcePresetServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _ResourcePresetService_Get_Handler,
},
{
MethodName: "List",
Handler: _ResourcePresetService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/mdb/postgresql/v1/resource_preset_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/postgresql/v1/resource_preset_service.proto", fileDescriptor_resource_preset_service_5dc2866710ef140a)
}
var fileDescriptor_resource_preset_service_5dc2866710ef140a = []byte{
// 459 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x53, 0xcb, 0x6e, 0x13, 0x31,
0x14, 0x95, 0x33, 0xa5, 0x22, 0x46, 0xa8, 0x95, 0x25, 0xa4, 0xd1, 0xf0, 0x50, 0x34, 0x0b, 0x98,
0x4d, 0xec, 0x4c, 0x60, 0x81, 0x48, 0xbb, 0x09, 0x8b, 0x0a, 0x89, 0x47, 0x35, 0x65, 0x03, 0x9b,
0xc8, 0x89, 0xaf, 0x8c, 0x45, 0x62, 0x4f, 0xc7, 0x4e, 0x54, 0x8a, 0x90, 0x10, 0x4b, 0xb6, 0x7c,
0x06, 0x0b, 0x36, 0xfc, 0x43, 0xd9, 0xf3, 0x0b, 0x2c, 0xf8, 0x06, 0x56, 0x68, 0x3c, 0xa9, 0xca,
0x0c, 0x7d, 0x10, 0x96, 0xd6, 0xb9, 0xe7, 0x9e, 0x73, 0x7c, 0xef, 0xc5, 0x5b, 0x6f, 0xb8, 0x16,
0x70, 0xc0, 0x26, 0x53, 0x33, 0x17, 0x6c, 0x26, 0xc6, 0x2c, 0x37, 0xd6, 0xc9, 0x02, 0xec, 0xfe,
0x94, 0x2d, 0x52, 0x56, 0x80, 0x35, 0xf3, 0x62, 0x02, 0xa3, 0xbc, 0x00, 0x0b, 0x6e, 0x64, 0xa1,
0x58, 0xa8, 0x09, 0xd0, 0xbc, 0x30, 0xce, 0x90, 0x5b, 0x15, 0x9b, 0x7a, 0x36, 0x9d, 0x89, 0x31,
0x3d, 0x61, 0xd3, 0x45, 0x1a, 0xdd, 0x90, 0xc6, 0xc8, 0x29, 0x30, 0x9e, 0x2b, 0xc6, 0xb5, 0x36,
0x8e, 0x3b, 0x65, 0xb4, 0xad, 0xd8, 0xd1, 0xcd, 0x9a, 0xf6, 0x82, 0x4f, 0x95, 0xf0, 0xf8, 0x12,
0xbe, 0xb7, 0x9a, 0xb5, 0x8a, 0x15, 0x3f, 0xc5, 0xe1, 0x0e, 0xb8, 0x6c, 0x89, 0xed, 0x7a, 0x28,
0x83, 0xfd, 0x39, 0x58, 0x47, 0xfa, 0x98, 0x34, 0xf3, 0x28, 0x11, 0xa2, 0x0e, 0x4a, 0xda, 0xc3,
0xb5, 0x9f, 0x47, 0x29, 0xca, 0x36, 0x8b, 0x1a, 0xf1, 0x91, 0x88, 0x0d, 0x8e, 0x1e, 0x2b, 0xdb,
0x68, 0x68, 0x8f, 0x3b, 0xde, 0xc1, 0xed, 0x9c, 0x4b, 0x18, 0x59, 0x75, 0x08, 0x61, 0xab, 0x83,
0x92, 0x60, 0x88, 0x7f, 0x1d, 0xa5, 0xeb, 0x5b, 0xdb, 0x69, 0xaf, 0xd7, 0xcb, 0x2e, 0x97, 0xe0,
0x9e, 0x3a, 0x04, 0x92, 0x60, 0xec, 0x0b, 0x9d, 0x79, 0x0d, 0x3a, 0x0c, 0xbc, 0x64, 0xfb, 0xe3,
0xb7, 0xf4, 0x92, 0xaf, 0xcc, 0x7c, 0x97, 0xe7, 0x25, 0x16, 0x7f, 0x46, 0xf8, 0xfa, 0xa9, 0x8a,
0x36, 0x37, 0xda, 0x02, 0x79, 0x81, 0x37, 0x1b, 0x21, 0x6c, 0x88, 0x3a, 0x41, 0x72, 0xa5, 0x4f,
0xe9, 0xf9, 0xe3, 0xa0, 0x8d, 0x5f, 0xd9, 0xa8, 0x87, 0xb5, 0x24, 0xc5, 0x1b, 0x1a, 0x0e, 0xdc,
0xe8, 0x0f, 0xa7, 0xad, 0xa6, 0xd3, 0xab, 0x65, 0xc5, 0xee, 0xb1, 0xdb, 0xfe, 0xfb, 0x00, 0x5f,
0xab, 0xb7, 0xdd, 0xab, 0x36, 0x84, 0x7c, 0x45, 0x38, 0xd8, 0x01, 0x47, 0xee, 0x5f, 0xe4, 0xea,
0xac, 0x71, 0x45, 0x2b, 0xe6, 0x89, 0x1f, 0x7e, 0xf8, 0xfe, 0xe3, 0x53, 0x6b, 0x9b, 0x0c, 0xd8,
0x8c, 0x6b, 0x2e, 0x41, 0x74, 0x4f, 0x5f, 0x98, 0x65, 0x5c, 0xf6, 0xf6, 0xef, 0x65, 0x78, 0x47,
0xbe, 0x20, 0xbc, 0x56, 0x7e, 0x3f, 0x79, 0x70, 0x91, 0xfa, 0xd9, 0x6b, 0x11, 0x0d, 0xfe, 0x8b,
0x5b, 0x0d, 0x38, 0xa6, 0x3e, 0x46, 0x42, 0x6e, 0xff, 0x5b, 0x8c, 0xe1, 0xb3, 0x97, 0x4f, 0xa4,
0x72, 0xaf, 0xe6, 0x63, 0x3a, 0x31, 0x33, 0x56, 0x09, 0x77, 0xab, 0xa3, 0x91, 0xa6, 0x2b, 0x41,
0xfb, 0xc3, 0x60, 0xe7, 0x5f, 0xd3, 0xe0, 0xe4, 0x35, 0x5e, 0xf7, 0x84, 0xbb, 0xbf, 0x03, 0x00,
0x00, 0xff, 0xff, 0xb8, 0x37, 0xeb, 0x6f, 0x1c, 0x04, 0x00, 0x00,
}

456
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/user.pb.go generated vendored Normal file
View File

@ -0,0 +1,456 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/postgresql/v1/user.proto
package postgresql // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import wrappers "github.com/golang/protobuf/ptypes/wrappers"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type UserSettings_SynchronousCommit int32
const (
UserSettings_SYNCHRONOUS_COMMIT_UNSPECIFIED UserSettings_SynchronousCommit = 0
UserSettings_SYNCHRONOUS_COMMIT_ON UserSettings_SynchronousCommit = 1
UserSettings_SYNCHRONOUS_COMMIT_OFF UserSettings_SynchronousCommit = 2
UserSettings_SYNCHRONOUS_COMMIT_LOCAL UserSettings_SynchronousCommit = 3
UserSettings_SYNCHRONOUS_COMMIT_REMOTE_WRITE UserSettings_SynchronousCommit = 4
UserSettings_SYNCHRONOUS_COMMIT_REMOTE_APPLY UserSettings_SynchronousCommit = 5
)
var UserSettings_SynchronousCommit_name = map[int32]string{
0: "SYNCHRONOUS_COMMIT_UNSPECIFIED",
1: "SYNCHRONOUS_COMMIT_ON",
2: "SYNCHRONOUS_COMMIT_OFF",
3: "SYNCHRONOUS_COMMIT_LOCAL",
4: "SYNCHRONOUS_COMMIT_REMOTE_WRITE",
5: "SYNCHRONOUS_COMMIT_REMOTE_APPLY",
}
var UserSettings_SynchronousCommit_value = map[string]int32{
"SYNCHRONOUS_COMMIT_UNSPECIFIED": 0,
"SYNCHRONOUS_COMMIT_ON": 1,
"SYNCHRONOUS_COMMIT_OFF": 2,
"SYNCHRONOUS_COMMIT_LOCAL": 3,
"SYNCHRONOUS_COMMIT_REMOTE_WRITE": 4,
"SYNCHRONOUS_COMMIT_REMOTE_APPLY": 5,
}
func (x UserSettings_SynchronousCommit) String() string {
return proto.EnumName(UserSettings_SynchronousCommit_name, int32(x))
}
func (UserSettings_SynchronousCommit) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_user_86f81a23ffeb3ce2, []int{3, 0}
}
type UserSettings_LogStatement int32
const (
UserSettings_LOG_STATEMENT_UNSPECIFIED UserSettings_LogStatement = 0
UserSettings_LOG_STATEMENT_NONE UserSettings_LogStatement = 1
UserSettings_LOG_STATEMENT_DDL UserSettings_LogStatement = 2
UserSettings_LOG_STATEMENT_MOD UserSettings_LogStatement = 3
UserSettings_LOG_STATEMENT_ALL UserSettings_LogStatement = 4
)
var UserSettings_LogStatement_name = map[int32]string{
0: "LOG_STATEMENT_UNSPECIFIED",
1: "LOG_STATEMENT_NONE",
2: "LOG_STATEMENT_DDL",
3: "LOG_STATEMENT_MOD",
4: "LOG_STATEMENT_ALL",
}
var UserSettings_LogStatement_value = map[string]int32{
"LOG_STATEMENT_UNSPECIFIED": 0,
"LOG_STATEMENT_NONE": 1,
"LOG_STATEMENT_DDL": 2,
"LOG_STATEMENT_MOD": 3,
"LOG_STATEMENT_ALL": 4,
}
func (x UserSettings_LogStatement) String() string {
return proto.EnumName(UserSettings_LogStatement_name, int32(x))
}
func (UserSettings_LogStatement) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_user_86f81a23ffeb3ce2, []int{3, 1}
}
type UserSettings_TransactionIsolation int32
const (
UserSettings_TRANSACTION_ISOLATION_UNSPECIFIED UserSettings_TransactionIsolation = 0
UserSettings_TRANSACTION_ISOLATION_READ_UNCOMMITTED UserSettings_TransactionIsolation = 1
UserSettings_TRANSACTION_ISOLATION_READ_COMMITTED UserSettings_TransactionIsolation = 2
UserSettings_TRANSACTION_ISOLATION_REPEATABLE_READ UserSettings_TransactionIsolation = 3
UserSettings_TRANSACTION_ISOLATION_SERIALIZABLE UserSettings_TransactionIsolation = 4
)
var UserSettings_TransactionIsolation_name = map[int32]string{
0: "TRANSACTION_ISOLATION_UNSPECIFIED",
1: "TRANSACTION_ISOLATION_READ_UNCOMMITTED",
2: "TRANSACTION_ISOLATION_READ_COMMITTED",
3: "TRANSACTION_ISOLATION_REPEATABLE_READ",
4: "TRANSACTION_ISOLATION_SERIALIZABLE",
}
var UserSettings_TransactionIsolation_value = map[string]int32{
"TRANSACTION_ISOLATION_UNSPECIFIED": 0,
"TRANSACTION_ISOLATION_READ_UNCOMMITTED": 1,
"TRANSACTION_ISOLATION_READ_COMMITTED": 2,
"TRANSACTION_ISOLATION_REPEATABLE_READ": 3,
"TRANSACTION_ISOLATION_SERIALIZABLE": 4,
}
func (x UserSettings_TransactionIsolation) String() string {
return proto.EnumName(UserSettings_TransactionIsolation_name, int32(x))
}
func (UserSettings_TransactionIsolation) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_user_86f81a23ffeb3ce2, []int{3, 2}
}
// A PostgreSQL User resource. For more information, see
// the [Developer's Guide](/docs/managed-postgresql/concepts).
type User struct {
// Name of the PostgreSQL user.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// ID of the PostgreSQL cluster the user belongs to.
ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// Set of permissions granted to the user.
Permissions []*Permission `protobuf:"bytes,3,rep,name=permissions,proto3" json:"permissions,omitempty"`
// Number of database connections available to the user.
ConnLimit int64 `protobuf:"varint,4,opt,name=conn_limit,json=connLimit,proto3" json:"conn_limit,omitempty"`
// Postgresql settings for this user
Settings *UserSettings `protobuf:"bytes,5,opt,name=settings,proto3" json:"settings,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *User) Reset() { *m = User{} }
func (m *User) String() string { return proto.CompactTextString(m) }
func (*User) ProtoMessage() {}
func (*User) Descriptor() ([]byte, []int) {
return fileDescriptor_user_86f81a23ffeb3ce2, []int{0}
}
func (m *User) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_User.Unmarshal(m, b)
}
func (m *User) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_User.Marshal(b, m, deterministic)
}
func (dst *User) XXX_Merge(src proto.Message) {
xxx_messageInfo_User.Merge(dst, src)
}
func (m *User) XXX_Size() int {
return xxx_messageInfo_User.Size(m)
}
func (m *User) XXX_DiscardUnknown() {
xxx_messageInfo_User.DiscardUnknown(m)
}
var xxx_messageInfo_User proto.InternalMessageInfo
func (m *User) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *User) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *User) GetPermissions() []*Permission {
if m != nil {
return m.Permissions
}
return nil
}
func (m *User) GetConnLimit() int64 {
if m != nil {
return m.ConnLimit
}
return 0
}
func (m *User) GetSettings() *UserSettings {
if m != nil {
return m.Settings
}
return nil
}
type Permission struct {
// Name of the database that the permission grants access to.
DatabaseName string `protobuf:"bytes,1,opt,name=database_name,json=databaseName,proto3" json:"database_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Permission) Reset() { *m = Permission{} }
func (m *Permission) String() string { return proto.CompactTextString(m) }
func (*Permission) ProtoMessage() {}
func (*Permission) Descriptor() ([]byte, []int) {
return fileDescriptor_user_86f81a23ffeb3ce2, []int{1}
}
func (m *Permission) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Permission.Unmarshal(m, b)
}
func (m *Permission) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Permission.Marshal(b, m, deterministic)
}
func (dst *Permission) XXX_Merge(src proto.Message) {
xxx_messageInfo_Permission.Merge(dst, src)
}
func (m *Permission) XXX_Size() int {
return xxx_messageInfo_Permission.Size(m)
}
func (m *Permission) XXX_DiscardUnknown() {
xxx_messageInfo_Permission.DiscardUnknown(m)
}
var xxx_messageInfo_Permission proto.InternalMessageInfo
func (m *Permission) GetDatabaseName() string {
if m != nil {
return m.DatabaseName
}
return ""
}
type UserSpec struct {
// Name of the PostgreSQL user.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Password of the PostgreSQL user.
Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
// Set of permissions to grant to the user.
Permissions []*Permission `protobuf:"bytes,3,rep,name=permissions,proto3" json:"permissions,omitempty"`
// Number of database connections that should be available to the user.
ConnLimit *wrappers.Int64Value `protobuf:"bytes,4,opt,name=conn_limit,json=connLimit,proto3" json:"conn_limit,omitempty"`
// Postgresql settings for this user
Settings *UserSettings `protobuf:"bytes,5,opt,name=settings,proto3" json:"settings,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UserSpec) Reset() { *m = UserSpec{} }
func (m *UserSpec) String() string { return proto.CompactTextString(m) }
func (*UserSpec) ProtoMessage() {}
func (*UserSpec) Descriptor() ([]byte, []int) {
return fileDescriptor_user_86f81a23ffeb3ce2, []int{2}
}
func (m *UserSpec) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UserSpec.Unmarshal(m, b)
}
func (m *UserSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UserSpec.Marshal(b, m, deterministic)
}
func (dst *UserSpec) XXX_Merge(src proto.Message) {
xxx_messageInfo_UserSpec.Merge(dst, src)
}
func (m *UserSpec) XXX_Size() int {
return xxx_messageInfo_UserSpec.Size(m)
}
func (m *UserSpec) XXX_DiscardUnknown() {
xxx_messageInfo_UserSpec.DiscardUnknown(m)
}
var xxx_messageInfo_UserSpec proto.InternalMessageInfo
func (m *UserSpec) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *UserSpec) GetPassword() string {
if m != nil {
return m.Password
}
return ""
}
func (m *UserSpec) GetPermissions() []*Permission {
if m != nil {
return m.Permissions
}
return nil
}
func (m *UserSpec) GetConnLimit() *wrappers.Int64Value {
if m != nil {
return m.ConnLimit
}
return nil
}
func (m *UserSpec) GetSettings() *UserSettings {
if m != nil {
return m.Settings
}
return nil
}
// Postgresql user settings config
type UserSettings struct {
DefaultTransactionIsolation UserSettings_TransactionIsolation `protobuf:"varint,1,opt,name=default_transaction_isolation,json=defaultTransactionIsolation,proto3,enum=yandex.cloud.mdb.postgresql.v1.UserSettings_TransactionIsolation" json:"default_transaction_isolation,omitempty"`
// in milliseconds.
LockTimeout *wrappers.Int64Value `protobuf:"bytes,2,opt,name=lock_timeout,json=lockTimeout,proto3" json:"lock_timeout,omitempty"`
// in milliseconds.
LogMinDurationStatement *wrappers.Int64Value `protobuf:"bytes,3,opt,name=log_min_duration_statement,json=logMinDurationStatement,proto3" json:"log_min_duration_statement,omitempty"`
SynchronousCommit UserSettings_SynchronousCommit `protobuf:"varint,4,opt,name=synchronous_commit,json=synchronousCommit,proto3,enum=yandex.cloud.mdb.postgresql.v1.UserSettings_SynchronousCommit" json:"synchronous_commit,omitempty"`
// in bytes.
TempFileLimit *wrappers.Int64Value `protobuf:"bytes,5,opt,name=temp_file_limit,json=tempFileLimit,proto3" json:"temp_file_limit,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UserSettings) Reset() { *m = UserSettings{} }
func (m *UserSettings) String() string { return proto.CompactTextString(m) }
func (*UserSettings) ProtoMessage() {}
func (*UserSettings) Descriptor() ([]byte, []int) {
return fileDescriptor_user_86f81a23ffeb3ce2, []int{3}
}
func (m *UserSettings) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UserSettings.Unmarshal(m, b)
}
func (m *UserSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UserSettings.Marshal(b, m, deterministic)
}
func (dst *UserSettings) XXX_Merge(src proto.Message) {
xxx_messageInfo_UserSettings.Merge(dst, src)
}
func (m *UserSettings) XXX_Size() int {
return xxx_messageInfo_UserSettings.Size(m)
}
func (m *UserSettings) XXX_DiscardUnknown() {
xxx_messageInfo_UserSettings.DiscardUnknown(m)
}
var xxx_messageInfo_UserSettings proto.InternalMessageInfo
func (m *UserSettings) GetDefaultTransactionIsolation() UserSettings_TransactionIsolation {
if m != nil {
return m.DefaultTransactionIsolation
}
return UserSettings_TRANSACTION_ISOLATION_UNSPECIFIED
}
func (m *UserSettings) GetLockTimeout() *wrappers.Int64Value {
if m != nil {
return m.LockTimeout
}
return nil
}
func (m *UserSettings) GetLogMinDurationStatement() *wrappers.Int64Value {
if m != nil {
return m.LogMinDurationStatement
}
return nil
}
func (m *UserSettings) GetSynchronousCommit() UserSettings_SynchronousCommit {
if m != nil {
return m.SynchronousCommit
}
return UserSettings_SYNCHRONOUS_COMMIT_UNSPECIFIED
}
func (m *UserSettings) GetTempFileLimit() *wrappers.Int64Value {
if m != nil {
return m.TempFileLimit
}
return nil
}
func init() {
proto.RegisterType((*User)(nil), "yandex.cloud.mdb.postgresql.v1.User")
proto.RegisterType((*Permission)(nil), "yandex.cloud.mdb.postgresql.v1.Permission")
proto.RegisterType((*UserSpec)(nil), "yandex.cloud.mdb.postgresql.v1.UserSpec")
proto.RegisterType((*UserSettings)(nil), "yandex.cloud.mdb.postgresql.v1.UserSettings")
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.UserSettings_SynchronousCommit", UserSettings_SynchronousCommit_name, UserSettings_SynchronousCommit_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.UserSettings_LogStatement", UserSettings_LogStatement_name, UserSettings_LogStatement_value)
proto.RegisterEnum("yandex.cloud.mdb.postgresql.v1.UserSettings_TransactionIsolation", UserSettings_TransactionIsolation_name, UserSettings_TransactionIsolation_value)
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/postgresql/v1/user.proto", fileDescriptor_user_86f81a23ffeb3ce2)
}
var fileDescriptor_user_86f81a23ffeb3ce2 = []byte{
// 848 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xdf, 0x6e, 0xdb, 0x54,
0x18, 0xc7, 0x49, 0x8a, 0xd2, 0x2f, 0xed, 0x70, 0x8f, 0xd8, 0xc8, 0x3a, 0x52, 0x4a, 0xc6, 0xa6,
0xb4, 0x22, 0xf6, 0x9c, 0xa1, 0x69, 0x08, 0x56, 0xc9, 0x49, 0x5c, 0x66, 0xc9, 0xb1, 0x23, 0xdb,
0x05, 0x56, 0x84, 0x8e, 0x9c, 0xf8, 0xd4, 0xb3, 0xb0, 0x7d, 0x82, 0xcf, 0x71, 0xc7, 0xb8, 0xe7,
0xa6, 0xaf, 0xc3, 0x3b, 0xd0, 0x3d, 0x01, 0x8f, 0x80, 0xb8, 0x44, 0x5c, 0x72, 0x85, 0xe2, 0x24,
0x4d, 0xbb, 0x84, 0x54, 0x93, 0xd8, 0x9d, 0xfd, 0xfb, 0xf3, 0x7d, 0xc7, 0xbf, 0xf3, 0x93, 0x0c,
0x7b, 0x2f, 0xbd, 0xc4, 0x27, 0x3f, 0xc9, 0xc3, 0x88, 0x66, 0xbe, 0x1c, 0xfb, 0x03, 0x79, 0x44,
0x19, 0x0f, 0x52, 0xc2, 0x7e, 0x8c, 0xe4, 0x53, 0x45, 0xce, 0x18, 0x49, 0xa5, 0x51, 0x4a, 0x39,
0x45, 0x3b, 0x13, 0xa9, 0x94, 0x4b, 0xa5, 0xd8, 0x1f, 0x48, 0x73, 0xa9, 0x74, 0xaa, 0x6c, 0xef,
0x04, 0x94, 0x06, 0x11, 0x91, 0x73, 0xf5, 0x20, 0x3b, 0x91, 0x5f, 0xa4, 0xde, 0x68, 0x44, 0x52,
0x36, 0xf1, 0x6f, 0xd7, 0xae, 0xac, 0x3a, 0xf5, 0xa2, 0xd0, 0xf7, 0x78, 0x48, 0x93, 0x09, 0x5d,
0xff, 0x4b, 0x80, 0xd2, 0x11, 0x23, 0x29, 0x42, 0x50, 0x4a, 0xbc, 0x98, 0x54, 0x85, 0x5d, 0xa1,
0xb1, 0x6e, 0xe7, 0xcf, 0xa8, 0x06, 0x30, 0x8c, 0x32, 0xc6, 0x49, 0x8a, 0x43, 0xbf, 0x5a, 0xc8,
0x99, 0xf5, 0x29, 0xa2, 0xfb, 0xc8, 0x80, 0xca, 0x88, 0xa4, 0x71, 0xc8, 0x58, 0x48, 0x13, 0x56,
0x2d, 0xee, 0x16, 0x1b, 0x95, 0xd6, 0xbe, 0xb4, 0xfa, 0xc0, 0x52, 0xff, 0xc2, 0x62, 0x5f, 0xb6,
0xe7, 0xcb, 0x68, 0x92, 0xe0, 0x28, 0x8c, 0x43, 0x5e, 0x2d, 0xed, 0x0a, 0x8d, 0xa2, 0xbd, 0x3e,
0x46, 0x8c, 0x31, 0x80, 0x9e, 0x42, 0x99, 0x11, 0xce, 0xc3, 0x24, 0x60, 0xd5, 0xb5, 0x5d, 0xa1,
0x51, 0x69, 0x7d, 0x7a, 0xdd, 0xa6, 0xf1, 0x77, 0x39, 0x53, 0x8f, 0x7d, 0xe1, 0xae, 0x2b, 0x00,
0xf3, 0x33, 0xa0, 0xbb, 0xb0, 0xe9, 0x7b, 0xdc, 0x1b, 0x78, 0x8c, 0xe0, 0x4b, 0x01, 0x6c, 0xcc,
0x40, 0xd3, 0x8b, 0x49, 0xfd, 0xb7, 0x02, 0x94, 0xf3, 0x69, 0x23, 0x32, 0x44, 0xca, 0xe5, 0xa4,
0xda, 0xb5, 0x3f, 0xcf, 0x15, 0xe1, 0xef, 0x73, 0x65, 0xf3, 0x3b, 0xaf, 0xf9, 0xb3, 0xda, 0x3c,
0x7e, 0xd0, 0xfc, 0x1c, 0x7f, 0xbf, 0x7f, 0xf6, 0x4a, 0x29, 0x7d, 0xf9, 0xe4, 0xd1, 0xc3, 0x69,
0x90, 0x7b, 0x50, 0x1e, 0x79, 0x8c, 0xbd, 0xa0, 0xe9, 0x34, 0xc6, 0xf6, 0xe6, 0xd8, 0x76, 0xf6,
0x4a, 0x59, 0x7b, 0xdc, 0x54, 0x5a, 0x8f, 0xed, 0x0b, 0xfa, 0x7f, 0x0e, 0xb5, 0xbb, 0x10, 0x6a,
0xa5, 0x75, 0x47, 0x9a, 0x54, 0x46, 0x9a, 0x55, 0x46, 0xd2, 0x13, 0xfe, 0xe8, 0xb3, 0xaf, 0xbd,
0x28, 0x23, 0xed, 0xf2, 0x3f, 0xe7, 0x4a, 0xe9, 0xe0, 0x89, 0xf2, 0xe0, 0xed, 0x64, 0xff, 0x6b,
0x19, 0x36, 0x2e, 0x53, 0xe8, 0x17, 0x01, 0x6a, 0x3e, 0x39, 0xf1, 0xb2, 0x88, 0x63, 0x9e, 0x7a,
0x09, 0xf3, 0x86, 0xe3, 0x76, 0xe2, 0x90, 0xd1, 0x28, 0xef, 0x69, 0x1e, 0xf3, 0x8d, 0x96, 0xfa,
0x26, 0x0b, 0x25, 0x77, 0x3e, 0x49, 0x9f, 0x0d, 0xb2, 0xef, 0x4c, 0xf7, 0x2c, 0x23, 0xd1, 0x01,
0x6c, 0x44, 0x74, 0xf8, 0x03, 0xe6, 0x61, 0x4c, 0x68, 0xc6, 0xf3, 0x5b, 0x5a, 0x1d, 0x95, 0x5d,
0x19, 0x1b, 0xdc, 0x89, 0x1e, 0x7d, 0x0b, 0xdb, 0x11, 0x0d, 0x70, 0x1c, 0x26, 0xd8, 0xcf, 0xd2,
0x7c, 0x26, 0x66, 0xdc, 0xe3, 0x24, 0x26, 0x09, 0xaf, 0x16, 0xaf, 0x9f, 0xf6, 0x41, 0x44, 0x83,
0x5e, 0x98, 0x74, 0xa7, 0x66, 0x67, 0xe6, 0x45, 0x31, 0x20, 0xf6, 0x32, 0x19, 0x3e, 0x4f, 0x69,
0x42, 0x33, 0x86, 0x87, 0x34, 0x9e, 0x5d, 0xe5, 0x8d, 0xd6, 0xc1, 0x1b, 0xa5, 0xe2, 0xcc, 0xc7,
0x74, 0xf2, 0x29, 0xf6, 0x16, 0x7b, 0x1d, 0x42, 0x1d, 0x78, 0x8f, 0x93, 0x78, 0x84, 0x4f, 0xc2,
0x88, 0x4c, 0x6b, 0xb3, 0x76, 0xfd, 0xe9, 0x37, 0xc7, 0x9e, 0xc3, 0x30, 0x22, 0x79, 0x61, 0xea,
0xbf, 0x0b, 0xb0, 0xb5, 0xb0, 0x0d, 0xd5, 0x61, 0xc7, 0x79, 0x66, 0x76, 0x9e, 0xda, 0x96, 0x69,
0x1d, 0x39, 0xb8, 0x63, 0xf5, 0x7a, 0xba, 0x8b, 0x8f, 0x4c, 0xa7, 0xaf, 0x75, 0xf4, 0x43, 0x5d,
0xeb, 0x8a, 0xef, 0xa0, 0xdb, 0x70, 0x73, 0x89, 0xc6, 0x32, 0x45, 0x01, 0x6d, 0xc3, 0xad, 0x65,
0xd4, 0xe1, 0xa1, 0x58, 0x40, 0x1f, 0x42, 0x75, 0x09, 0x67, 0x58, 0x1d, 0xd5, 0x10, 0x8b, 0xe8,
0x2e, 0x7c, 0xb4, 0x84, 0xb5, 0xb5, 0x9e, 0xe5, 0x6a, 0xf8, 0x1b, 0x5b, 0x77, 0x35, 0xb1, 0xb4,
0x5a, 0xa4, 0xf6, 0xfb, 0xc6, 0x33, 0x71, 0xad, 0x7e, 0x26, 0xc0, 0x86, 0x41, 0x83, 0xf9, 0xed,
0xd4, 0xe0, 0xb6, 0x61, 0x7d, 0x85, 0x1d, 0x57, 0x75, 0xb5, 0x9e, 0x66, 0xbe, 0xfe, 0x39, 0xb7,
0x00, 0x5d, 0xa5, 0x4d, 0xcb, 0xd4, 0x44, 0x01, 0xdd, 0x84, 0xad, 0xab, 0x78, 0xb7, 0x6b, 0x88,
0x85, 0x45, 0xb8, 0x67, 0x75, 0xc5, 0xe2, 0x22, 0xac, 0x1a, 0x86, 0x58, 0xaa, 0xff, 0x21, 0xc0,
0xfb, 0x4b, 0xcb, 0x7c, 0x0f, 0x3e, 0x76, 0x6d, 0xd5, 0x74, 0xd4, 0x8e, 0xab, 0x5b, 0x26, 0xd6,
0x1d, 0xcb, 0x50, 0xf3, 0xa7, 0xab, 0x87, 0xdb, 0x87, 0xfb, 0xcb, 0x65, 0xb6, 0xa6, 0x76, 0xf1,
0x91, 0x39, 0x89, 0xc0, 0xd5, 0xba, 0xa2, 0x80, 0x1a, 0xf0, 0xc9, 0x0a, 0xed, 0x5c, 0x59, 0x40,
0x7b, 0x70, 0xef, 0xbf, 0x94, 0x7d, 0x4d, 0x75, 0xd5, 0xb6, 0xa1, 0xe5, 0x26, 0xb1, 0x88, 0xee,
0x43, 0x7d, 0xb9, 0xd4, 0xd1, 0x6c, 0x5d, 0x35, 0xf4, 0xe3, 0xb1, 0x58, 0x2c, 0xb5, 0xad, 0xe3,
0x5e, 0x10, 0xf2, 0xe7, 0xd9, 0x40, 0x1a, 0xd2, 0x58, 0x9e, 0x54, 0xbe, 0x39, 0xf9, 0xa1, 0x05,
0xb4, 0x19, 0x90, 0x24, 0xaf, 0xa4, 0xbc, 0xfa, 0xa7, 0xfa, 0xc5, 0xfc, 0x6d, 0xf0, 0x6e, 0x6e,
0x78, 0xf8, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdc, 0x72, 0x36, 0x79, 0x88, 0x07, 0x00, 0x00,
}

1122
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/postgresql/v1/user_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

128
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1alpha/backup.pb.go generated vendored Normal file
View File

@ -0,0 +1,128 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/redis/v1alpha/backup.proto
package redis // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1alpha"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
// Description of a Redis backup. For more information, see
// the Managed Service for Redis [documentation](/docs/managed-redis/concepts/backup).
type Backup struct {
// ID of the backup.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the backup belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format
// (i.e. when the backup operation was completed).
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// ID of the Redis cluster that the backup was created for.
SourceClusterId string `protobuf:"bytes,4,opt,name=source_cluster_id,json=sourceClusterId,proto3" json:"source_cluster_id,omitempty"`
// Start timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format
// (i.e. when the backup operation was started).
StartedAt *timestamp.Timestamp `protobuf:"bytes,5,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Backup) Reset() { *m = Backup{} }
func (m *Backup) String() string { return proto.CompactTextString(m) }
func (*Backup) ProtoMessage() {}
func (*Backup) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_0460337759388c73, []int{0}
}
func (m *Backup) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Backup.Unmarshal(m, b)
}
func (m *Backup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Backup.Marshal(b, m, deterministic)
}
func (dst *Backup) XXX_Merge(src proto.Message) {
xxx_messageInfo_Backup.Merge(dst, src)
}
func (m *Backup) XXX_Size() int {
return xxx_messageInfo_Backup.Size(m)
}
func (m *Backup) XXX_DiscardUnknown() {
xxx_messageInfo_Backup.DiscardUnknown(m)
}
var xxx_messageInfo_Backup proto.InternalMessageInfo
func (m *Backup) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Backup) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Backup) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Backup) GetSourceClusterId() string {
if m != nil {
return m.SourceClusterId
}
return ""
}
func (m *Backup) GetStartedAt() *timestamp.Timestamp {
if m != nil {
return m.StartedAt
}
return nil
}
func init() {
proto.RegisterType((*Backup)(nil), "yandex.cloud.mdb.redis.v1alpha.Backup")
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/redis/v1alpha/backup.proto", fileDescriptor_backup_0460337759388c73)
}
var fileDescriptor_backup_0460337759388c73 = []byte{
// 264 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x90, 0xc1, 0x4a, 0x33, 0x31,
0x14, 0x85, 0x99, 0xf9, 0x7f, 0x8b, 0x13, 0x41, 0x71, 0x56, 0x43, 0x05, 0x2d, 0xae, 0x8a, 0xd2,
0x04, 0x75, 0x25, 0xae, 0x5a, 0x37, 0xea, 0xb2, 0xb8, 0x72, 0x33, 0x24, 0xb9, 0xe9, 0x34, 0x98,
0x34, 0x43, 0x72, 0x23, 0xfa, 0xa4, 0xbe, 0x8e, 0x90, 0xa4, 0x5b, 0x5d, 0xe6, 0xe4, 0xbb, 0xe7,
0x83, 0x43, 0xae, 0xbf, 0xf8, 0x0e, 0xd4, 0x27, 0x93, 0xc6, 0x45, 0x60, 0x16, 0x04, 0xf3, 0x0a,
0x74, 0x60, 0x1f, 0x37, 0xdc, 0x8c, 0x5b, 0xce, 0x04, 0x97, 0xef, 0x71, 0xa4, 0xa3, 0x77, 0xe8,
0xda, 0xf3, 0x0c, 0xd3, 0x04, 0x53, 0x0b, 0x82, 0x26, 0x98, 0x16, 0x78, 0x7a, 0x31, 0x38, 0x37,
0x18, 0xc5, 0x12, 0x2d, 0xe2, 0x86, 0xa1, 0xb6, 0x2a, 0x20, 0xb7, 0xa5, 0xe0, 0xf2, 0xbb, 0x22,
0x93, 0x55, 0x6a, 0x6c, 0x8f, 0x49, 0xad, 0xa1, 0xab, 0x66, 0xd5, 0xbc, 0x59, 0xd7, 0x1a, 0xda,
0x33, 0xd2, 0x6c, 0x9c, 0x01, 0xe5, 0x7b, 0x0d, 0x5d, 0x9d, 0xe2, 0xc3, 0x1c, 0x3c, 0x43, 0x7b,
0x4f, 0x88, 0xf4, 0x8a, 0xa3, 0x82, 0x9e, 0x63, 0xf7, 0x6f, 0x56, 0xcd, 0x8f, 0x6e, 0xa7, 0x34,
0xdb, 0xe8, 0xde, 0x46, 0x5f, 0xf7, 0xb6, 0x75, 0x53, 0xe8, 0x25, 0xb6, 0x57, 0xe4, 0x34, 0xb8,
0xe8, 0xa5, 0xea, 0xa5, 0x89, 0x01, 0x73, 0xff, 0xff, 0xd4, 0x7f, 0x92, 0x3f, 0x1e, 0x73, 0x9e,
0x35, 0x01, 0xb9, 0x2f, 0x9a, 0x83, 0xbf, 0x35, 0x85, 0x5e, 0xe2, 0xea, 0xe5, 0xed, 0x69, 0xd0,
0xb8, 0x8d, 0x82, 0x4a, 0x67, 0x59, 0xde, 0x69, 0x91, 0x47, 0x1d, 0xdc, 0x62, 0x50, 0xbb, 0x74,
0xce, 0x7e, 0x5f, 0xfb, 0x21, 0xbd, 0xc4, 0x24, 0xb1, 0x77, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff,
0xe5, 0xf6, 0x76, 0x8c, 0x9c, 0x01, 0x00, 0x00,
}

334
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1alpha/backup_service.pb.go generated vendored Normal file
View File

@ -0,0 +1,334 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/redis/v1alpha/backup_service.proto
package redis // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1alpha"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/yandex-cloud/go-genproto/yandex/cloud/validation"
import _ "google.golang.org/genproto/googleapis/api/annotations"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type GetBackupRequest struct {
// ID of the Redis backup to return.
// To get the backup ID, use a [ClusterService.ListBackups] request.
BackupId string `protobuf:"bytes,1,opt,name=backup_id,json=backupId,proto3" json:"backup_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetBackupRequest) Reset() { *m = GetBackupRequest{} }
func (m *GetBackupRequest) String() string { return proto.CompactTextString(m) }
func (*GetBackupRequest) ProtoMessage() {}
func (*GetBackupRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_fa97172451e1ee31, []int{0}
}
func (m *GetBackupRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetBackupRequest.Unmarshal(m, b)
}
func (m *GetBackupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetBackupRequest.Marshal(b, m, deterministic)
}
func (dst *GetBackupRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetBackupRequest.Merge(dst, src)
}
func (m *GetBackupRequest) XXX_Size() int {
return xxx_messageInfo_GetBackupRequest.Size(m)
}
func (m *GetBackupRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetBackupRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetBackupRequest proto.InternalMessageInfo
func (m *GetBackupRequest) GetBackupId() string {
if m != nil {
return m.BackupId
}
return ""
}
type ListBackupsRequest struct {
// ID of the folder to list backups in.
// To get the folder ID, use a [yandex.cloud.resourcemanager.v1.FolderService.List] request.
FolderId string `protobuf:"bytes,1,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// The maximum number of results per page to return. If the number of available
// results is larger than [page_size], the service returns a [ListBackupsResponse.next_page_token]
// that can be used to get the next page of results in subsequent list requests.
PageSize int64 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
// Page token. To get the next page of results, set [page_token] to the [ListBackupsResponse.next_page_token]
// returned by a previous list request.
PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListBackupsRequest) Reset() { *m = ListBackupsRequest{} }
func (m *ListBackupsRequest) String() string { return proto.CompactTextString(m) }
func (*ListBackupsRequest) ProtoMessage() {}
func (*ListBackupsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_fa97172451e1ee31, []int{1}
}
func (m *ListBackupsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListBackupsRequest.Unmarshal(m, b)
}
func (m *ListBackupsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListBackupsRequest.Marshal(b, m, deterministic)
}
func (dst *ListBackupsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListBackupsRequest.Merge(dst, src)
}
func (m *ListBackupsRequest) XXX_Size() int {
return xxx_messageInfo_ListBackupsRequest.Size(m)
}
func (m *ListBackupsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ListBackupsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ListBackupsRequest proto.InternalMessageInfo
func (m *ListBackupsRequest) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *ListBackupsRequest) GetPageSize() int64 {
if m != nil {
return m.PageSize
}
return 0
}
func (m *ListBackupsRequest) GetPageToken() string {
if m != nil {
return m.PageToken
}
return ""
}
type ListBackupsResponse struct {
// Requested list of backups.
Backups []*Backup `protobuf:"bytes,1,rep,name=backups,proto3" json:"backups,omitempty"`
// This token allows you to get the next page of results for list requests. If the number of results
// is larger than [ListBackupsRequest.page_size], use the [next_page_token] as the value
// for the [ListBackupsRequest.page_token] parameter in the next list request. Each subsequent
// list request will have its own [next_page_token] to continue paging through the results.
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListBackupsResponse) Reset() { *m = ListBackupsResponse{} }
func (m *ListBackupsResponse) String() string { return proto.CompactTextString(m) }
func (*ListBackupsResponse) ProtoMessage() {}
func (*ListBackupsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_backup_service_fa97172451e1ee31, []int{2}
}
func (m *ListBackupsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListBackupsResponse.Unmarshal(m, b)
}
func (m *ListBackupsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ListBackupsResponse.Marshal(b, m, deterministic)
}
func (dst *ListBackupsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListBackupsResponse.Merge(dst, src)
}
func (m *ListBackupsResponse) XXX_Size() int {
return xxx_messageInfo_ListBackupsResponse.Size(m)
}
func (m *ListBackupsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListBackupsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListBackupsResponse proto.InternalMessageInfo
func (m *ListBackupsResponse) GetBackups() []*Backup {
if m != nil {
return m.Backups
}
return nil
}
func (m *ListBackupsResponse) GetNextPageToken() string {
if m != nil {
return m.NextPageToken
}
return ""
}
func init() {
proto.RegisterType((*GetBackupRequest)(nil), "yandex.cloud.mdb.redis.v1alpha.GetBackupRequest")
proto.RegisterType((*ListBackupsRequest)(nil), "yandex.cloud.mdb.redis.v1alpha.ListBackupsRequest")
proto.RegisterType((*ListBackupsResponse)(nil), "yandex.cloud.mdb.redis.v1alpha.ListBackupsResponse")
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// BackupServiceClient is the client API for BackupService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type BackupServiceClient interface {
// Returns the specified Redis backup.
//
// To get the list of available Redis backups, make a [List] request.
Get(ctx context.Context, in *GetBackupRequest, opts ...grpc.CallOption) (*Backup, error)
// Retrieves the list of Redis backups available for the specified folder.
List(ctx context.Context, in *ListBackupsRequest, opts ...grpc.CallOption) (*ListBackupsResponse, error)
}
type backupServiceClient struct {
cc *grpc.ClientConn
}
func NewBackupServiceClient(cc *grpc.ClientConn) BackupServiceClient {
return &backupServiceClient{cc}
}
func (c *backupServiceClient) Get(ctx context.Context, in *GetBackupRequest, opts ...grpc.CallOption) (*Backup, error) {
out := new(Backup)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.redis.v1alpha.BackupService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *backupServiceClient) List(ctx context.Context, in *ListBackupsRequest, opts ...grpc.CallOption) (*ListBackupsResponse, error) {
out := new(ListBackupsResponse)
err := c.cc.Invoke(ctx, "/yandex.cloud.mdb.redis.v1alpha.BackupService/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// BackupServiceServer is the server API for BackupService service.
type BackupServiceServer interface {
// Returns the specified Redis backup.
//
// To get the list of available Redis backups, make a [List] request.
Get(context.Context, *GetBackupRequest) (*Backup, error)
// Retrieves the list of Redis backups available for the specified folder.
List(context.Context, *ListBackupsRequest) (*ListBackupsResponse, error)
}
func RegisterBackupServiceServer(s *grpc.Server, srv BackupServiceServer) {
s.RegisterService(&_BackupService_serviceDesc, srv)
}
func _BackupService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetBackupRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BackupServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.redis.v1alpha.BackupService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BackupServiceServer).Get(ctx, req.(*GetBackupRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BackupService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListBackupsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BackupServiceServer).List(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/yandex.cloud.mdb.redis.v1alpha.BackupService/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BackupServiceServer).List(ctx, req.(*ListBackupsRequest))
}
return interceptor(ctx, in, info, handler)
}
var _BackupService_serviceDesc = grpc.ServiceDesc{
ServiceName: "yandex.cloud.mdb.redis.v1alpha.BackupService",
HandlerType: (*BackupServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _BackupService_Get_Handler,
},
{
MethodName: "List",
Handler: _BackupService_List_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "yandex/cloud/mdb/redis/v1alpha/backup_service.proto",
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/redis/v1alpha/backup_service.proto", fileDescriptor_backup_service_fa97172451e1ee31)
}
var fileDescriptor_backup_service_fa97172451e1ee31 = []byte{
// 460 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x92, 0x41, 0x6f, 0xd3, 0x30,
0x14, 0x80, 0x95, 0xb6, 0x8c, 0xc6, 0x30, 0x81, 0xcc, 0xa5, 0x8a, 0x06, 0x2a, 0x39, 0x94, 0x20,
0x54, 0x3b, 0x69, 0xb5, 0x13, 0x9b, 0x84, 0x7a, 0x19, 0x43, 0x1c, 0x50, 0xc6, 0x89, 0x4b, 0xe5,
0xd4, 0x8f, 0xcc, 0x5a, 0x6a, 0x87, 0xda, 0xad, 0xc6, 0x10, 0x42, 0xe2, 0xb8, 0x0b, 0x12, 0xfb,
0x31, 0xfc, 0x84, 0xed, 0xce, 0x5f, 0xe0, 0xc0, 0x6f, 0xe0, 0x84, 0x62, 0xa7, 0xc0, 0x40, 0xdb,
0xca, 0xd1, 0xef, 0xbd, 0xcf, 0xef, 0xd3, 0x7b, 0x0f, 0x0d, 0xdf, 0x32, 0xc9, 0xe1, 0x90, 0x4e,
0x0a, 0x35, 0xe7, 0x74, 0xca, 0x33, 0x3a, 0x03, 0x2e, 0x34, 0x5d, 0x24, 0xac, 0x28, 0xf7, 0x19,
0xcd, 0xd8, 0xe4, 0x60, 0x5e, 0x8e, 0x35, 0xcc, 0x16, 0x62, 0x02, 0xa4, 0x9c, 0x29, 0xa3, 0xf0,
0x3d, 0x07, 0x11, 0x0b, 0x91, 0x29, 0xcf, 0x88, 0x85, 0x48, 0x0d, 0x05, 0x1b, 0xb9, 0x52, 0x79,
0x01, 0x94, 0x95, 0x82, 0x32, 0x29, 0x95, 0x61, 0x46, 0x28, 0xa9, 0x1d, 0x1d, 0xdc, 0x3d, 0xd7,
0x72, 0xc1, 0x0a, 0xc1, 0x6d, 0xbe, 0x4e, 0x3f, 0x5a, 0xc9, 0xc8, 0x15, 0x87, 0x9b, 0xe8, 0xf6,
0x0e, 0x98, 0x91, 0x0d, 0xa5, 0xf0, 0x66, 0x0e, 0xda, 0xe0, 0xfb, 0xc8, 0xaf, 0xad, 0x05, 0xef,
0x78, 0x5d, 0x2f, 0xf2, 0x47, 0xad, 0xef, 0xa7, 0x89, 0x97, 0xb6, 0x5d, 0x78, 0x97, 0x87, 0x9f,
0x3d, 0x84, 0x9f, 0x0b, 0x5d, 0x83, 0x7a, 0x49, 0x3e, 0x44, 0xfe, 0x6b, 0x55, 0x70, 0x98, 0xfd,
0x26, 0x6f, 0x56, 0xe4, 0xf1, 0x59, 0xd2, 0xda, 0xda, 0xde, 0x8c, 0xd3, 0xb6, 0x4b, 0xef, 0x72,
0xfc, 0x00, 0xf9, 0x25, 0xcb, 0x61, 0xac, 0xc5, 0x11, 0x74, 0x1a, 0x5d, 0x2f, 0x6a, 0x8e, 0xd0,
0x8f, 0xd3, 0x64, 0x2d, 0xee, 0x27, 0x71, 0x1c, 0xa7, 0xed, 0x2a, 0xb9, 0x27, 0x8e, 0x00, 0x47,
0x08, 0xd9, 0x42, 0xa3, 0x0e, 0x40, 0x76, 0x9a, 0xf6, 0x53, 0xff, 0xf8, 0x2c, 0xb9, 0xb6, 0xb5,
0x9d, 0xc4, 0x71, 0x6a, 0x7f, 0x79, 0x59, 0xe5, 0xc2, 0x0f, 0xe8, 0xce, 0x39, 0x27, 0x5d, 0x2a,
0xa9, 0x01, 0x3f, 0x41, 0xd7, 0x9d, 0xb7, 0xee, 0x78, 0xdd, 0x66, 0x74, 0x63, 0xd0, 0x23, 0x97,
0x8f, 0x9f, 0xd4, 0xe3, 0x58, 0x62, 0xb8, 0x87, 0x6e, 0x49, 0x38, 0x34, 0xe3, 0x3f, 0x3c, 0x2a,
0x63, 0x3f, 0x5d, 0xaf, 0xc2, 0x2f, 0x96, 0x02, 0x83, 0x2f, 0x0d, 0xb4, 0xee, 0xd8, 0x3d, 0xb7,
0x6e, 0xfc, 0xc9, 0x43, 0xcd, 0x1d, 0x30, 0x38, 0xbe, 0xaa, 0xe5, 0xdf, 0x4b, 0x08, 0x56, 0x94,
0x0c, 0xc9, 0xc7, 0xaf, 0xdf, 0x4e, 0x1a, 0x11, 0xee, 0x5d, 0xb8, 0x69, 0x4d, 0xdf, 0xfd, 0x5a,
0xe7, 0x7b, 0x7c, 0xe2, 0xa1, 0x56, 0x35, 0x25, 0x3c, 0xb8, 0xaa, 0xc1, 0xbf, 0xfb, 0x0d, 0x86,
0xff, 0xc5, 0xb8, 0xf9, 0x87, 0xa1, 0x35, 0xdc, 0xc0, 0xc1, 0xc5, 0x86, 0xa3, 0x67, 0xaf, 0x9e,
0xe6, 0xc2, 0xec, 0xcf, 0x33, 0x32, 0x51, 0x53, 0xea, 0x9a, 0xf4, 0xdd, 0x01, 0xe7, 0xaa, 0x9f,
0x83, 0xb4, 0xd7, 0x4a, 0x2f, 0xbf, 0xec, 0xc7, 0xf6, 0x95, 0xad, 0xd9, 0xda, 0xe1, 0xcf, 0x00,
0x00, 0x00, 0xff, 0xff, 0x9d, 0x9c, 0x2e, 0x16, 0x9a, 0x03, 0x00, 0x00,
}

874
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1alpha/cluster.pb.go generated vendored Normal file
View File

@ -0,0 +1,874 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/redis/v1alpha/cluster.proto
package redis // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1alpha"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
import config "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1alpha/config"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type Cluster_Environment int32
const (
Cluster_ENVIRONMENT_UNSPECIFIED Cluster_Environment = 0
// Stable environment with a conservative update policy:
// only hotfixes are applied during regular maintenance.
Cluster_PRODUCTION Cluster_Environment = 1
// Environment with more aggressive update policy: new versions
// are rolled out irrespective of backward compatibility.
Cluster_PRESTABLE Cluster_Environment = 2
)
var Cluster_Environment_name = map[int32]string{
0: "ENVIRONMENT_UNSPECIFIED",
1: "PRODUCTION",
2: "PRESTABLE",
}
var Cluster_Environment_value = map[string]int32{
"ENVIRONMENT_UNSPECIFIED": 0,
"PRODUCTION": 1,
"PRESTABLE": 2,
}
func (x Cluster_Environment) String() string {
return proto.EnumName(Cluster_Environment_name, int32(x))
}
func (Cluster_Environment) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_cluster_4cd4fa078a636ae8, []int{0, 0}
}
type Cluster_Health int32
const (
// Cluster is in unknown state (we have no data)
Cluster_HEALTH_UNKNOWN Cluster_Health = 0
// Cluster is alive and well (all hosts are alive)
Cluster_ALIVE Cluster_Health = 1
// Cluster is inoperable (it cannot perform any of its essential functions)
Cluster_DEAD Cluster_Health = 2
// Cluster is partially alive (it can perform some of its essential functions)
Cluster_DEGRADED Cluster_Health = 3
)
var Cluster_Health_name = map[int32]string{
0: "HEALTH_UNKNOWN",
1: "ALIVE",
2: "DEAD",
3: "DEGRADED",
}
var Cluster_Health_value = map[string]int32{
"HEALTH_UNKNOWN": 0,
"ALIVE": 1,
"DEAD": 2,
"DEGRADED": 3,
}
func (x Cluster_Health) String() string {
return proto.EnumName(Cluster_Health_name, int32(x))
}
func (Cluster_Health) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_cluster_4cd4fa078a636ae8, []int{0, 1}
}
type Cluster_Status int32
const (
// Cluster status is unknown
Cluster_STATUS_UNKNOWN Cluster_Status = 0
// Cluster is being created
Cluster_CREATING Cluster_Status = 1
// Cluster is running
Cluster_RUNNING Cluster_Status = 2
// Cluster failed
Cluster_ERROR Cluster_Status = 3
// Cluster is being updated.
Cluster_UPDATING Cluster_Status = 4
// Cluster is stopping.
Cluster_STOPPING Cluster_Status = 5
// Cluster stopped.
Cluster_STOPPED Cluster_Status = 6
// Cluster is starting.
Cluster_STARTING Cluster_Status = 7
)
var Cluster_Status_name = map[int32]string{
0: "STATUS_UNKNOWN",
1: "CREATING",
2: "RUNNING",
3: "ERROR",
4: "UPDATING",
5: "STOPPING",
6: "STOPPED",
7: "STARTING",
}
var Cluster_Status_value = map[string]int32{
"STATUS_UNKNOWN": 0,
"CREATING": 1,
"RUNNING": 2,
"ERROR": 3,
"UPDATING": 4,
"STOPPING": 5,
"STOPPED": 6,
"STARTING": 7,
}
func (x Cluster_Status) String() string {
return proto.EnumName(Cluster_Status_name, int32(x))
}
func (Cluster_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_cluster_4cd4fa078a636ae8, []int{0, 2}
}
type Host_Role int32
const (
// Role of the host in the cluster is unknown.
Host_ROLE_UNKNOWN Host_Role = 0
// Host is the master Redis server in the cluster.
Host_MASTER Host_Role = 1
// Host is a replica (standby) Redis server in the cluster.
Host_REPLICA Host_Role = 2
)
var Host_Role_name = map[int32]string{
0: "ROLE_UNKNOWN",
1: "MASTER",
2: "REPLICA",
}
var Host_Role_value = map[string]int32{
"ROLE_UNKNOWN": 0,
"MASTER": 1,
"REPLICA": 2,
}
func (x Host_Role) String() string {
return proto.EnumName(Host_Role_name, int32(x))
}
func (Host_Role) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_cluster_4cd4fa078a636ae8, []int{3, 0}
}
type Host_Health int32
const (
// Health of the host is unknown.
Host_HEALTH_UNKNOWN Host_Health = 0
// The host is performing all its functions normally.
Host_ALIVE Host_Health = 1
// The host is inoperable, and cannot perform any of its essential functions.
Host_DEAD Host_Health = 2
// The host is degraded, and can perform only some of its essential functions.
Host_DEGRADED Host_Health = 3
)
var Host_Health_name = map[int32]string{
0: "HEALTH_UNKNOWN",
1: "ALIVE",
2: "DEAD",
3: "DEGRADED",
}
var Host_Health_value = map[string]int32{
"HEALTH_UNKNOWN": 0,
"ALIVE": 1,
"DEAD": 2,
"DEGRADED": 3,
}
func (x Host_Health) String() string {
return proto.EnumName(Host_Health_name, int32(x))
}
func (Host_Health) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_cluster_4cd4fa078a636ae8, []int{3, 1}
}
type Service_Type int32
const (
Service_TYPE_UNSPECIFIED Service_Type = 0
// The host is a Redis server.
Service_REDIS Service_Type = 1
// The host provides a Sentinel service.
Service_SENTINEL Service_Type = 2
)
var Service_Type_name = map[int32]string{
0: "TYPE_UNSPECIFIED",
1: "REDIS",
2: "SENTINEL",
}
var Service_Type_value = map[string]int32{
"TYPE_UNSPECIFIED": 0,
"REDIS": 1,
"SENTINEL": 2,
}
func (x Service_Type) String() string {
return proto.EnumName(Service_Type_name, int32(x))
}
func (Service_Type) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_cluster_4cd4fa078a636ae8, []int{4, 0}
}
type Service_Health int32
const (
// Health of the server is unknown.
Service_HEALTH_UNKNOWN Service_Health = 0
// The server is working normally.
Service_ALIVE Service_Health = 1
// The server is dead or unresponsive.
Service_DEAD Service_Health = 2
)
var Service_Health_name = map[int32]string{
0: "HEALTH_UNKNOWN",
1: "ALIVE",
2: "DEAD",
}
var Service_Health_value = map[string]int32{
"HEALTH_UNKNOWN": 0,
"ALIVE": 1,
"DEAD": 2,
}
func (x Service_Health) String() string {
return proto.EnumName(Service_Health_name, int32(x))
}
func (Service_Health) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_cluster_4cd4fa078a636ae8, []int{4, 1}
}
// Description of a Redis cluster. For more information, see
// the Managed Service for Redis [documentation](/docs/managed-redis/concepts/).
type Cluster struct {
// ID of the Redis cluster.
// This ID is assigned by MDB at creation time.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// ID of the folder that the Redis cluster belongs to.
FolderId string `protobuf:"bytes,2,opt,name=folder_id,json=folderId,proto3" json:"folder_id,omitempty"`
// Creation timestamp in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
CreatedAt *timestamp.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// Name of the Redis cluster.
// The name is unique within the folder. 3-63 characters long.
Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
// Description of the Redis cluster. 0-256 characters long.
Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
// Custom labels for the Redis cluster as `key:value` pairs.
// Maximum 64 per cluster.
Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Deployment environment of the Redis cluster.
Environment Cluster_Environment `protobuf:"varint,7,opt,name=environment,proto3,enum=yandex.cloud.mdb.redis.v1alpha.Cluster_Environment" json:"environment,omitempty"`
// Description of monitoring systems relevant to the Redis cluster.
Monitoring []*Monitoring `protobuf:"bytes,8,rep,name=monitoring,proto3" json:"monitoring,omitempty"`
// Configuration of the Redis cluster.
Config *ClusterConfig `protobuf:"bytes,9,opt,name=config,proto3" json:"config,omitempty"`
NetworkId string `protobuf:"bytes,10,opt,name=network_id,json=networkId,proto3" json:"network_id,omitempty"`
// Aggregated cluster health
Health Cluster_Health `protobuf:"varint,11,opt,name=health,proto3,enum=yandex.cloud.mdb.redis.v1alpha.Cluster_Health" json:"health,omitempty"`
// Cluster status
Status Cluster_Status `protobuf:"varint,12,opt,name=status,proto3,enum=yandex.cloud.mdb.redis.v1alpha.Cluster_Status" json:"status,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Cluster) Reset() { *m = Cluster{} }
func (m *Cluster) String() string { return proto.CompactTextString(m) }
func (*Cluster) ProtoMessage() {}
func (*Cluster) Descriptor() ([]byte, []int) {
return fileDescriptor_cluster_4cd4fa078a636ae8, []int{0}
}
func (m *Cluster) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Cluster.Unmarshal(m, b)
}
func (m *Cluster) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Cluster.Marshal(b, m, deterministic)
}
func (dst *Cluster) XXX_Merge(src proto.Message) {
xxx_messageInfo_Cluster.Merge(dst, src)
}
func (m *Cluster) XXX_Size() int {
return xxx_messageInfo_Cluster.Size(m)
}
func (m *Cluster) XXX_DiscardUnknown() {
xxx_messageInfo_Cluster.DiscardUnknown(m)
}
var xxx_messageInfo_Cluster proto.InternalMessageInfo
func (m *Cluster) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func (m *Cluster) GetFolderId() string {
if m != nil {
return m.FolderId
}
return ""
}
func (m *Cluster) GetCreatedAt() *timestamp.Timestamp {
if m != nil {
return m.CreatedAt
}
return nil
}
func (m *Cluster) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Cluster) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Cluster) GetLabels() map[string]string {
if m != nil {
return m.Labels
}
return nil
}
func (m *Cluster) GetEnvironment() Cluster_Environment {
if m != nil {
return m.Environment
}
return Cluster_ENVIRONMENT_UNSPECIFIED
}
func (m *Cluster) GetMonitoring() []*Monitoring {
if m != nil {
return m.Monitoring
}
return nil
}
func (m *Cluster) GetConfig() *ClusterConfig {
if m != nil {
return m.Config
}
return nil
}
func (m *Cluster) GetNetworkId() string {
if m != nil {
return m.NetworkId
}
return ""
}
func (m *Cluster) GetHealth() Cluster_Health {
if m != nil {
return m.Health
}
return Cluster_HEALTH_UNKNOWN
}
func (m *Cluster) GetStatus() Cluster_Status {
if m != nil {
return m.Status
}
return Cluster_STATUS_UNKNOWN
}
type Monitoring struct {
// Name of the monitoring system.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Description of the monitoring system.
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
// Link to the monitoring system charts for the Redis cluster.
Link string `protobuf:"bytes,3,opt,name=link,proto3" json:"link,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Monitoring) Reset() { *m = Monitoring{} }
func (m *Monitoring) String() string { return proto.CompactTextString(m) }
func (*Monitoring) ProtoMessage() {}
func (*Monitoring) Descriptor() ([]byte, []int) {
return fileDescriptor_cluster_4cd4fa078a636ae8, []int{1}
}
func (m *Monitoring) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Monitoring.Unmarshal(m, b)
}
func (m *Monitoring) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Monitoring.Marshal(b, m, deterministic)
}
func (dst *Monitoring) XXX_Merge(src proto.Message) {
xxx_messageInfo_Monitoring.Merge(dst, src)
}
func (m *Monitoring) XXX_Size() int {
return xxx_messageInfo_Monitoring.Size(m)
}
func (m *Monitoring) XXX_DiscardUnknown() {
xxx_messageInfo_Monitoring.DiscardUnknown(m)
}
var xxx_messageInfo_Monitoring proto.InternalMessageInfo
func (m *Monitoring) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Monitoring) GetDescription() string {
if m != nil {
return m.Description
}
return ""
}
func (m *Monitoring) GetLink() string {
if m != nil {
return m.Link
}
return ""
}
type ClusterConfig struct {
// Version of Redis server software.
Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
// Configuration for Redis servers in the cluster.
//
// Types that are valid to be assigned to RedisConfig:
// *ClusterConfig_RedisConfig_5_0
RedisConfig isClusterConfig_RedisConfig `protobuf_oneof:"redis_config"`
// Resources allocated to Redis hosts.
Resources *Resources `protobuf:"bytes,3,opt,name=resources,proto3" json:"resources,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ClusterConfig) Reset() { *m = ClusterConfig{} }
func (m *ClusterConfig) String() string { return proto.CompactTextString(m) }
func (*ClusterConfig) ProtoMessage() {}
func (*ClusterConfig) Descriptor() ([]byte, []int) {
return fileDescriptor_cluster_4cd4fa078a636ae8, []int{2}
}
func (m *ClusterConfig) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ClusterConfig.Unmarshal(m, b)
}
func (m *ClusterConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ClusterConfig.Marshal(b, m, deterministic)
}
func (dst *ClusterConfig) XXX_Merge(src proto.Message) {
xxx_messageInfo_ClusterConfig.Merge(dst, src)
}
func (m *ClusterConfig) XXX_Size() int {
return xxx_messageInfo_ClusterConfig.Size(m)
}
func (m *ClusterConfig) XXX_DiscardUnknown() {
xxx_messageInfo_ClusterConfig.DiscardUnknown(m)
}
var xxx_messageInfo_ClusterConfig proto.InternalMessageInfo
func (m *ClusterConfig) GetVersion() string {
if m != nil {
return m.Version
}
return ""
}
type isClusterConfig_RedisConfig interface {
isClusterConfig_RedisConfig()
}
type ClusterConfig_RedisConfig_5_0 struct {
RedisConfig_5_0 *config.RedisConfigSet5_0 `protobuf:"bytes,2,opt,name=redis_config_5_0,json=redisConfig50,proto3,oneof"`
}
func (*ClusterConfig_RedisConfig_5_0) isClusterConfig_RedisConfig() {}
func (m *ClusterConfig) GetRedisConfig() isClusterConfig_RedisConfig {
if m != nil {
return m.RedisConfig
}
return nil
}
func (m *ClusterConfig) GetRedisConfig_5_0() *config.RedisConfigSet5_0 {
if x, ok := m.GetRedisConfig().(*ClusterConfig_RedisConfig_5_0); ok {
return x.RedisConfig_5_0
}
return nil
}
func (m *ClusterConfig) GetResources() *Resources {
if m != nil {
return m.Resources
}
return nil
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*ClusterConfig) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _ClusterConfig_OneofMarshaler, _ClusterConfig_OneofUnmarshaler, _ClusterConfig_OneofSizer, []interface{}{
(*ClusterConfig_RedisConfig_5_0)(nil),
}
}
func _ClusterConfig_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*ClusterConfig)
// redis_config
switch x := m.RedisConfig.(type) {
case *ClusterConfig_RedisConfig_5_0:
b.EncodeVarint(2<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.RedisConfig_5_0); err != nil {
return err
}
case nil:
default:
return fmt.Errorf("ClusterConfig.RedisConfig has unexpected type %T", x)
}
return nil
}
func _ClusterConfig_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*ClusterConfig)
switch tag {
case 2: // redis_config.redis_config_5_0
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(config.RedisConfigSet5_0)
err := b.DecodeMessage(msg)
m.RedisConfig = &ClusterConfig_RedisConfig_5_0{msg}
return true, err
default:
return false, nil
}
}
func _ClusterConfig_OneofSizer(msg proto.Message) (n int) {
m := msg.(*ClusterConfig)
// redis_config
switch x := m.RedisConfig.(type) {
case *ClusterConfig_RedisConfig_5_0:
s := proto.Size(x.RedisConfig_5_0)
n += 1 // tag and wire
n += proto.SizeVarint(uint64(s))
n += s
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
type Host struct {
// Name of the Redis host. The host name is assigned by MDB at creation time, and cannot be changed.
// 1-63 characters long.
//
// The name is unique across all existing MDB hosts in Yandex.Cloud, as it defines the FQDN of the host.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// ID of the Redis host. The ID is assigned by MDB at creation time.
ClusterId string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
// ID of the availability zone where the Redis host resides.
ZoneId string `protobuf:"bytes,3,opt,name=zone_id,json=zoneId,proto3" json:"zone_id,omitempty"`
// ID of the subnet that the host belongs to.
SubnetId string `protobuf:"bytes,4,opt,name=subnet_id,json=subnetId,proto3" json:"subnet_id,omitempty"`
// Resources allocated to the Redis host.
Resources *Resources `protobuf:"bytes,5,opt,name=resources,proto3" json:"resources,omitempty"`
// Role of the host in the cluster.
Role Host_Role `protobuf:"varint,6,opt,name=role,proto3,enum=yandex.cloud.mdb.redis.v1alpha.Host_Role" json:"role,omitempty"`
// Status code of the aggregated health of the host.
Health Host_Health `protobuf:"varint,7,opt,name=health,proto3,enum=yandex.cloud.mdb.redis.v1alpha.Host_Health" json:"health,omitempty"`
// Services provided by the host.
Services []*Service `protobuf:"bytes,8,rep,name=services,proto3" json:"services,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Host) Reset() { *m = Host{} }
func (m *Host) String() string { return proto.CompactTextString(m) }
func (*Host) ProtoMessage() {}
func (*Host) Descriptor() ([]byte, []int) {
return fileDescriptor_cluster_4cd4fa078a636ae8, []int{3}
}
func (m *Host) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Host.Unmarshal(m, b)
}
func (m *Host) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Host.Marshal(b, m, deterministic)
}
func (dst *Host) XXX_Merge(src proto.Message) {
xxx_messageInfo_Host.Merge(dst, src)
}
func (m *Host) XXX_Size() int {
return xxx_messageInfo_Host.Size(m)
}
func (m *Host) XXX_DiscardUnknown() {
xxx_messageInfo_Host.DiscardUnknown(m)
}
var xxx_messageInfo_Host proto.InternalMessageInfo
func (m *Host) GetName() string {
if m != nil {
return m.Name
}
return ""
}
func (m *Host) GetClusterId() string {
if m != nil {
return m.ClusterId
}
return ""
}
func (m *Host) GetZoneId() string {
if m != nil {
return m.ZoneId
}
return ""
}
func (m *Host) GetSubnetId() string {
if m != nil {
return m.SubnetId
}
return ""
}
func (m *Host) GetResources() *Resources {
if m != nil {
return m.Resources
}
return nil
}
func (m *Host) GetRole() Host_Role {
if m != nil {
return m.Role
}
return Host_ROLE_UNKNOWN
}
func (m *Host) GetHealth() Host_Health {
if m != nil {
return m.Health
}
return Host_HEALTH_UNKNOWN
}
func (m *Host) GetServices() []*Service {
if m != nil {
return m.Services
}
return nil
}
type Service struct {
// Type of the service provided by the host.
Type Service_Type `protobuf:"varint,1,opt,name=type,proto3,enum=yandex.cloud.mdb.redis.v1alpha.Service_Type" json:"type,omitempty"`
// Status code of server availability.
Health Service_Health `protobuf:"varint,2,opt,name=health,proto3,enum=yandex.cloud.mdb.redis.v1alpha.Service_Health" json:"health,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Service) Reset() { *m = Service{} }
func (m *Service) String() string { return proto.CompactTextString(m) }
func (*Service) ProtoMessage() {}
func (*Service) Descriptor() ([]byte, []int) {
return fileDescriptor_cluster_4cd4fa078a636ae8, []int{4}
}
func (m *Service) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Service.Unmarshal(m, b)
}
func (m *Service) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Service.Marshal(b, m, deterministic)
}
func (dst *Service) XXX_Merge(src proto.Message) {
xxx_messageInfo_Service.Merge(dst, src)
}
func (m *Service) XXX_Size() int {
return xxx_messageInfo_Service.Size(m)
}
func (m *Service) XXX_DiscardUnknown() {
xxx_messageInfo_Service.DiscardUnknown(m)
}
var xxx_messageInfo_Service proto.InternalMessageInfo
func (m *Service) GetType() Service_Type {
if m != nil {
return m.Type
}
return Service_TYPE_UNSPECIFIED
}
func (m *Service) GetHealth() Service_Health {
if m != nil {
return m.Health
}
return Service_HEALTH_UNKNOWN
}
type Resources struct {
// ID of the preset for computational resources available to a host (CPU, memory etc.).
// All available presets are listed in the [documentation](/docs/managed-redis/concepts/instance-types).
ResourcePresetId string `protobuf:"bytes,1,opt,name=resource_preset_id,json=resourcePresetId,proto3" json:"resource_preset_id,omitempty"`
// Volume of the storage available to a host, in bytes.
DiskSize int64 `protobuf:"varint,2,opt,name=disk_size,json=diskSize,proto3" json:"disk_size,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Resources) Reset() { *m = Resources{} }
func (m *Resources) String() string { return proto.CompactTextString(m) }
func (*Resources) ProtoMessage() {}
func (*Resources) Descriptor() ([]byte, []int) {
return fileDescriptor_cluster_4cd4fa078a636ae8, []int{5}
}
func (m *Resources) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Resources.Unmarshal(m, b)
}
func (m *Resources) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Resources.Marshal(b, m, deterministic)
}
func (dst *Resources) XXX_Merge(src proto.Message) {
xxx_messageInfo_Resources.Merge(dst, src)
}
func (m *Resources) XXX_Size() int {
return xxx_messageInfo_Resources.Size(m)
}
func (m *Resources) XXX_DiscardUnknown() {
xxx_messageInfo_Resources.DiscardUnknown(m)
}
var xxx_messageInfo_Resources proto.InternalMessageInfo
func (m *Resources) GetResourcePresetId() string {
if m != nil {
return m.ResourcePresetId
}
return ""
}
func (m *Resources) GetDiskSize() int64 {
if m != nil {
return m.DiskSize
}
return 0
}
func init() {
proto.RegisterType((*Cluster)(nil), "yandex.cloud.mdb.redis.v1alpha.Cluster")
proto.RegisterMapType((map[string]string)(nil), "yandex.cloud.mdb.redis.v1alpha.Cluster.LabelsEntry")
proto.RegisterType((*Monitoring)(nil), "yandex.cloud.mdb.redis.v1alpha.Monitoring")
proto.RegisterType((*ClusterConfig)(nil), "yandex.cloud.mdb.redis.v1alpha.ClusterConfig")
proto.RegisterType((*Host)(nil), "yandex.cloud.mdb.redis.v1alpha.Host")
proto.RegisterType((*Service)(nil), "yandex.cloud.mdb.redis.v1alpha.Service")
proto.RegisterType((*Resources)(nil), "yandex.cloud.mdb.redis.v1alpha.Resources")
proto.RegisterEnum("yandex.cloud.mdb.redis.v1alpha.Cluster_Environment", Cluster_Environment_name, Cluster_Environment_value)
proto.RegisterEnum("yandex.cloud.mdb.redis.v1alpha.Cluster_Health", Cluster_Health_name, Cluster_Health_value)
proto.RegisterEnum("yandex.cloud.mdb.redis.v1alpha.Cluster_Status", Cluster_Status_name, Cluster_Status_value)
proto.RegisterEnum("yandex.cloud.mdb.redis.v1alpha.Host_Role", Host_Role_name, Host_Role_value)
proto.RegisterEnum("yandex.cloud.mdb.redis.v1alpha.Host_Health", Host_Health_name, Host_Health_value)
proto.RegisterEnum("yandex.cloud.mdb.redis.v1alpha.Service_Type", Service_Type_name, Service_Type_value)
proto.RegisterEnum("yandex.cloud.mdb.redis.v1alpha.Service_Health", Service_Health_name, Service_Health_value)
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/redis/v1alpha/cluster.proto", fileDescriptor_cluster_4cd4fa078a636ae8)
}
var fileDescriptor_cluster_4cd4fa078a636ae8 = []byte{
// 1014 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xdd, 0x6e, 0xdb, 0x46,
0x13, 0x35, 0xf5, 0x43, 0x89, 0x23, 0x5b, 0x20, 0x16, 0x01, 0x42, 0x38, 0xc8, 0xf7, 0x19, 0xbc,
0xa9, 0xdb, 0xda, 0x94, 0xed, 0xd4, 0x40, 0xd2, 0xa2, 0x68, 0x69, 0x69, 0x63, 0x31, 0x91, 0x29,
0x61, 0x49, 0xb9, 0x68, 0x6f, 0x08, 0x4a, 0x5c, 0xcb, 0x84, 0x29, 0x52, 0x20, 0x29, 0xb7, 0xf2,
0x4b, 0xf6, 0x31, 0xfa, 0x04, 0xbd, 0x2c, 0x50, 0xec, 0x2e, 0x65, 0xc9, 0x69, 0x1b, 0x29, 0x45,
0xef, 0x38, 0xb3, 0x73, 0x0e, 0x67, 0x66, 0x67, 0x0e, 0x16, 0x8e, 0x16, 0x7e, 0x1c, 0xd0, 0x5f,
0x5a, 0xe3, 0x28, 0x99, 0x07, 0xad, 0x69, 0x30, 0x6a, 0xa5, 0x34, 0x08, 0xb3, 0xd6, 0xfd, 0xa9,
0x1f, 0xcd, 0x6e, 0xfd, 0xd6, 0x38, 0x9a, 0x67, 0x39, 0x4d, 0x8d, 0x59, 0x9a, 0xe4, 0x09, 0xfa,
0x9f, 0x88, 0x36, 0x78, 0xb4, 0x31, 0x0d, 0x46, 0x06, 0x8f, 0x36, 0x8a, 0xe8, 0xfd, 0xff, 0x4f,
0x92, 0x64, 0x12, 0xd1, 0x16, 0x8f, 0x1e, 0xcd, 0x6f, 0x5a, 0x79, 0x38, 0xa5, 0x59, 0xee, 0x4f,
0x67, 0x82, 0x60, 0xff, 0xab, 0x4d, 0xbf, 0x4b, 0xe2, 0x9b, 0x70, 0x22, 0x9c, 0xe7, 0xde, 0x89,
0x40, 0xe9, 0xbf, 0xd6, 0xa0, 0xd6, 0x16, 0x89, 0xa0, 0x26, 0x94, 0xc2, 0x40, 0x93, 0x0e, 0xa4,
0x43, 0x85, 0x94, 0xc2, 0x00, 0xbd, 0x00, 0xe5, 0x26, 0x89, 0x02, 0x9a, 0x7a, 0x61, 0xa0, 0x95,
0xb8, 0xbb, 0x2e, 0x1c, 0x56, 0x80, 0xde, 0x00, 0x8c, 0x53, 0xea, 0xe7, 0x34, 0xf0, 0xfc, 0x5c,
0x2b, 0x1f, 0x48, 0x87, 0x8d, 0xb3, 0x7d, 0x43, 0x24, 0x69, 0x2c, 0x93, 0x34, 0xdc, 0x65, 0x92,
0x44, 0x29, 0xa2, 0xcd, 0x1c, 0x21, 0xa8, 0xc4, 0xfe, 0x94, 0x6a, 0x15, 0x4e, 0xc9, 0xbf, 0xd1,
0x01, 0x34, 0x02, 0x9a, 0x8d, 0xd3, 0x70, 0x96, 0x87, 0x49, 0xac, 0x55, 0xf9, 0xd1, 0xba, 0x0b,
0xbd, 0x07, 0x39, 0xf2, 0x47, 0x34, 0xca, 0x34, 0xf9, 0xa0, 0x7c, 0xd8, 0x38, 0x7b, 0x65, 0x7c,
0xbc, 0x63, 0x46, 0x51, 0x96, 0xd1, 0xe3, 0x28, 0x1c, 0xe7, 0xe9, 0x82, 0x14, 0x14, 0x68, 0x08,
0x0d, 0x1a, 0xdf, 0x87, 0x69, 0x12, 0x4f, 0x69, 0x9c, 0x6b, 0xb5, 0x03, 0xe9, 0xb0, 0xb9, 0x3d,
0x23, 0x5e, 0x41, 0xc9, 0x3a, 0x0f, 0x7a, 0x07, 0x30, 0x4d, 0xe2, 0x30, 0x4f, 0xd2, 0x30, 0x9e,
0x68, 0x75, 0x9e, 0xe7, 0x17, 0x9b, 0x58, 0xaf, 0x1e, 0x11, 0x64, 0x0d, 0x8d, 0x30, 0xc8, 0xe2,
0xca, 0x34, 0x85, 0x37, 0xf7, 0x78, 0xcb, 0xec, 0xda, 0x1c, 0x44, 0x0a, 0x30, 0x7a, 0x09, 0x10,
0xd3, 0xfc, 0xe7, 0x24, 0xbd, 0x63, 0xb7, 0x08, 0xbc, 0xaf, 0x4a, 0xe1, 0xb1, 0x02, 0xf4, 0x16,
0xe4, 0x5b, 0xea, 0x47, 0xf9, 0xad, 0xd6, 0xe0, 0x3d, 0x30, 0xb6, 0xed, 0x41, 0x97, 0xa3, 0x48,
0x81, 0x66, 0x3c, 0x59, 0xee, 0xe7, 0xf3, 0x4c, 0xdb, 0xfd, 0x34, 0x1e, 0x87, 0xa3, 0x48, 0x81,
0xde, 0x7f, 0x03, 0x8d, 0xb5, 0xfb, 0x42, 0x2a, 0x94, 0xef, 0xe8, 0xa2, 0x98, 0x49, 0xf6, 0x89,
0x9e, 0x41, 0xf5, 0xde, 0x8f, 0xe6, 0xb4, 0x18, 0x48, 0x61, 0x7c, 0x5d, 0x7a, 0x2d, 0xe9, 0x16,
0x34, 0xd6, 0x2e, 0x06, 0xbd, 0x80, 0xe7, 0xd8, 0xbe, 0xb6, 0x48, 0xdf, 0xbe, 0xc2, 0xb6, 0xeb,
0x0d, 0x6d, 0x67, 0x80, 0xdb, 0xd6, 0x5b, 0x0b, 0x77, 0xd4, 0x1d, 0xd4, 0x04, 0x18, 0x90, 0x7e,
0x67, 0xd8, 0x76, 0xad, 0xbe, 0xad, 0x4a, 0x68, 0x0f, 0x94, 0x01, 0xc1, 0x8e, 0x6b, 0x5e, 0xf4,
0xb0, 0x5a, 0xd2, 0xbf, 0x03, 0x59, 0xd4, 0x87, 0x10, 0x34, 0xbb, 0xd8, 0xec, 0xb9, 0x5d, 0x6f,
0x68, 0xbf, 0xb7, 0xfb, 0x3f, 0xd8, 0xea, 0x0e, 0x52, 0xa0, 0x6a, 0xf6, 0xac, 0x6b, 0xac, 0x4a,
0xa8, 0x0e, 0x95, 0x0e, 0x36, 0x3b, 0x6a, 0x09, 0xed, 0x42, 0xbd, 0x83, 0x2f, 0x89, 0xd9, 0xc1,
0x1d, 0xb5, 0xac, 0x2f, 0x40, 0x16, 0x85, 0x31, 0x02, 0xc7, 0x35, 0xdd, 0xa1, 0xb3, 0x46, 0xb0,
0x0b, 0xf5, 0x36, 0xc1, 0xa6, 0x6b, 0xd9, 0x97, 0xaa, 0x84, 0x1a, 0x50, 0x23, 0x43, 0xdb, 0x66,
0x46, 0x89, 0x71, 0x63, 0x42, 0xfa, 0x44, 0x2d, 0xb3, 0xa8, 0xe1, 0xa0, 0x23, 0xa2, 0x2a, 0xcc,
0x72, 0xdc, 0xfe, 0x60, 0xc0, 0xac, 0x2a, 0xc3, 0x70, 0x0b, 0x77, 0x54, 0x59, 0x1c, 0x99, 0x84,
0x07, 0xd6, 0xf4, 0x6b, 0x80, 0xd5, 0x44, 0x3d, 0xee, 0x9a, 0xf4, 0xcf, 0xbb, 0x56, 0xfa, 0xeb,
0xae, 0x21, 0xa8, 0x44, 0x61, 0x7c, 0xc7, 0xd7, 0x5a, 0x21, 0xfc, 0x5b, 0xff, 0x4d, 0x82, 0xbd,
0x27, 0x23, 0x86, 0x34, 0xa8, 0xdd, 0xd3, 0x34, 0x63, 0x1c, 0x82, 0x7e, 0x69, 0xa2, 0x31, 0xa8,
0xfc, 0xb6, 0x3d, 0x31, 0x84, 0xde, 0xb9, 0x77, 0xc2, 0x7f, 0xd3, 0x38, 0x7b, 0xbd, 0x69, 0x2e,
0x04, 0xc2, 0x20, 0xcc, 0x29, 0xfe, 0xe3, 0xd0, 0xfc, 0xdc, 0x3b, 0xe9, 0xee, 0x90, 0xbd, 0x74,
0xe5, 0x3c, 0x3f, 0x41, 0x97, 0xa0, 0xa4, 0x34, 0x4b, 0xe6, 0xe9, 0x98, 0x66, 0x85, 0x00, 0x7d,
0xbe, 0x89, 0x9d, 0x2c, 0x01, 0x64, 0x85, 0xbd, 0x68, 0xc2, 0xee, 0x7a, 0xb6, 0xfa, 0xef, 0x65,
0xa8, 0x74, 0x93, 0x2c, 0xff, 0xdb, 0xe6, 0xbd, 0x04, 0x28, 0x84, 0x7b, 0xa5, 0x8a, 0x4a, 0xe1,
0xb1, 0x02, 0xf4, 0x1c, 0x6a, 0x0f, 0x49, 0x4c, 0xd9, 0x99, 0x68, 0x9e, 0xcc, 0x4c, 0x8b, 0x8b,
0x69, 0x36, 0x1f, 0xc5, 0x34, 0x67, 0x47, 0x42, 0xf9, 0xea, 0xc2, 0x61, 0x05, 0x4f, 0x4b, 0xa9,
0xfe, 0xfb, 0x52, 0xd0, 0xb7, 0x50, 0x49, 0x93, 0x88, 0x6a, 0x32, 0x5f, 0xc2, 0x8d, 0x1c, 0xac,
0x4a, 0x83, 0x24, 0x11, 0x25, 0x1c, 0x86, 0xda, 0x8f, 0x6a, 0x20, 0x14, 0xf1, 0xcb, 0xad, 0x08,
0x3e, 0x90, 0x82, 0x36, 0xd4, 0x33, 0x9a, 0xde, 0x87, 0xac, 0x16, 0x21, 0x81, 0x9f, 0x6d, 0xa2,
0x71, 0x44, 0x3c, 0x79, 0x04, 0xea, 0xa7, 0x50, 0x61, 0x79, 0x21, 0x15, 0x76, 0x49, 0xbf, 0x87,
0xd7, 0x96, 0x07, 0x40, 0xbe, 0x32, 0x1d, 0x17, 0x93, 0x62, 0x75, 0xf0, 0xa0, 0x67, 0xb5, 0xcd,
0xff, 0x62, 0x69, 0xff, 0x90, 0xa0, 0x56, 0x64, 0x82, 0xbe, 0x87, 0x4a, 0xbe, 0x98, 0x89, 0xab,
0x6f, 0x9e, 0x1d, 0x6d, 0x59, 0x80, 0xe1, 0x2e, 0x66, 0x94, 0x70, 0xe4, 0x9a, 0xb2, 0x96, 0xb6,
0x53, 0xc4, 0x25, 0xc7, 0xd3, 0x76, 0xea, 0xe7, 0x50, 0x61, 0xac, 0xe8, 0x19, 0xa8, 0xee, 0x8f,
0x03, 0xfc, 0x81, 0x90, 0x29, 0x50, 0x25, 0xb8, 0x63, 0x39, 0xaa, 0xc4, 0x65, 0x00, 0xdb, 0xae,
0x65, 0xe3, 0x9e, 0x5a, 0xd2, 0x4f, 0x3f, 0xb9, 0x1b, 0xfa, 0x35, 0x28, 0x8f, 0x43, 0x85, 0x8e,
0x00, 0x2d, 0xc7, 0xca, 0x9b, 0xa5, 0x34, 0x13, 0x83, 0x2b, 0x36, 0x41, 0x5d, 0x9e, 0x0c, 0xf8,
0x81, 0x98, 0xee, 0x20, 0xcc, 0xee, 0xbc, 0x2c, 0x7c, 0x10, 0xca, 0x5c, 0x26, 0x75, 0xe6, 0x70,
0xc2, 0x07, 0x7a, 0xf1, 0xee, 0xa7, 0xee, 0x24, 0xcc, 0x6f, 0xe7, 0x23, 0x63, 0x9c, 0x4c, 0x5b,
0xa2, 0x0b, 0xc7, 0xe2, 0x99, 0x32, 0x49, 0x8e, 0x27, 0x34, 0xe6, 0xcf, 0x85, 0xd6, 0xc7, 0xdf,
0x2f, 0xdf, 0x70, 0x6b, 0x24, 0xf3, 0xd8, 0x57, 0x7f, 0x06, 0x00, 0x00, 0xff, 0xff, 0xf6, 0x5e,
0x5c, 0x3f, 0x5d, 0x09, 0x00, 0x00,
}

2615
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1alpha/cluster_service.pb.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

240
vendor/github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1alpha/config/redis5_0.pb.go generated vendored Normal file
View File

@ -0,0 +1,240 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: yandex/cloud/mdb/redis/v1alpha/config/redis5_0.proto
package redis // import "github.com/yandex-cloud/go-genproto/yandex/cloud/mdb/redis/v1alpha/config"
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import wrappers "github.com/golang/protobuf/ptypes/wrappers"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type RedisConfig5_0_MaxmemoryPolicy int32
const (
RedisConfig5_0_MAXMEMORY_POLICY_UNSPECIFIED RedisConfig5_0_MaxmemoryPolicy = 0
// Try to remove less recently used (LRU) keys with `expire set`.
RedisConfig5_0_VOLATILE_LRU RedisConfig5_0_MaxmemoryPolicy = 1
// Remove less recently used (LRU) keys.
RedisConfig5_0_ALLKEYS_LRU RedisConfig5_0_MaxmemoryPolicy = 2
// Try to remove least frequently used (LFU) keys with `expire set`.
RedisConfig5_0_VOLATILE_LFU RedisConfig5_0_MaxmemoryPolicy = 3
// Remove least frequently used (LFU) keys.
RedisConfig5_0_ALLKEYS_LFU RedisConfig5_0_MaxmemoryPolicy = 4
// Try to remove keys with `expire set` randomly.
RedisConfig5_0_VOLATILE_RANDOM RedisConfig5_0_MaxmemoryPolicy = 5
// Remove keys randomly.
RedisConfig5_0_ALLKEYS_RANDOM RedisConfig5_0_MaxmemoryPolicy = 6
// Try to remove less recently used (LRU) keys with `expire set`
// and shorter TTL first.
RedisConfig5_0_VOLATILE_TTL RedisConfig5_0_MaxmemoryPolicy = 7
// Return errors when memory limit was reached and commands could require
// more memory to be used.
RedisConfig5_0_NOEVICTION RedisConfig5_0_MaxmemoryPolicy = 8
)
var RedisConfig5_0_MaxmemoryPolicy_name = map[int32]string{
0: "MAXMEMORY_POLICY_UNSPECIFIED",
1: "VOLATILE_LRU",
2: "ALLKEYS_LRU",
3: "VOLATILE_LFU",
4: "ALLKEYS_LFU",
5: "VOLATILE_RANDOM",
6: "ALLKEYS_RANDOM",
7: "VOLATILE_TTL",
8: "NOEVICTION",
}
var RedisConfig5_0_MaxmemoryPolicy_value = map[string]int32{
"MAXMEMORY_POLICY_UNSPECIFIED": 0,
"VOLATILE_LRU": 1,
"ALLKEYS_LRU": 2,
"VOLATILE_LFU": 3,
"ALLKEYS_LFU": 4,
"VOLATILE_RANDOM": 5,
"ALLKEYS_RANDOM": 6,
"VOLATILE_TTL": 7,
"NOEVICTION": 8,
}
func (x RedisConfig5_0_MaxmemoryPolicy) String() string {
return proto.EnumName(RedisConfig5_0_MaxmemoryPolicy_name, int32(x))
}
func (RedisConfig5_0_MaxmemoryPolicy) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_redis5_0_e003f487f83590f3, []int{0, 0}
}
// Fields and structure of `RedisConfig` reflects Redis configuration file
// parameters.
type RedisConfig5_0 struct {
// Redis key eviction policy for a dataset that reaches maximum memory,
// available to the host. Redis maxmemory setting depends on Managed
// Service for Redis [host class](/docs/managed-redis/concepts/instance-types).
//
// All policies are described in detail in [Redis documentation](https://redis.io/topics/lru-cache).
MaxmemoryPolicy RedisConfig5_0_MaxmemoryPolicy `protobuf:"varint,1,opt,name=maxmemory_policy,json=maxmemoryPolicy,proto3,enum=yandex.cloud.mdb.redis.v1alpha.config.RedisConfig5_0_MaxmemoryPolicy" json:"maxmemory_policy,omitempty"`
// Time that Redis keeps the connection open while the client is idle.
// If no new command is sent during that time, the connection is closed.
Timeout *wrappers.Int64Value `protobuf:"bytes,2,opt,name=timeout,proto3" json:"timeout,omitempty"`
// Authentication password.
Password string `protobuf:"bytes,3,opt,name=password,proto3" json:"password,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RedisConfig5_0) Reset() { *m = RedisConfig5_0{} }
func (m *RedisConfig5_0) String() string { return proto.CompactTextString(m) }
func (*RedisConfig5_0) ProtoMessage() {}
func (*RedisConfig5_0) Descriptor() ([]byte, []int) {
return fileDescriptor_redis5_0_e003f487f83590f3, []int{0}
}
func (m *RedisConfig5_0) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RedisConfig5_0.Unmarshal(m, b)
}
func (m *RedisConfig5_0) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RedisConfig5_0.Marshal(b, m, deterministic)
}
func (dst *RedisConfig5_0) XXX_Merge(src proto.Message) {
xxx_messageInfo_RedisConfig5_0.Merge(dst, src)
}
func (m *RedisConfig5_0) XXX_Size() int {
return xxx_messageInfo_RedisConfig5_0.Size(m)
}
func (m *RedisConfig5_0) XXX_DiscardUnknown() {
xxx_messageInfo_RedisConfig5_0.DiscardUnknown(m)
}
var xxx_messageInfo_RedisConfig5_0 proto.InternalMessageInfo
func (m *RedisConfig5_0) GetMaxmemoryPolicy() RedisConfig5_0_MaxmemoryPolicy {
if m != nil {
return m.MaxmemoryPolicy
}
return RedisConfig5_0_MAXMEMORY_POLICY_UNSPECIFIED
}
func (m *RedisConfig5_0) GetTimeout() *wrappers.Int64Value {
if m != nil {
return m.Timeout
}
return nil
}
func (m *RedisConfig5_0) GetPassword() string {
if m != nil {
return m.Password
}
return ""
}
type RedisConfigSet5_0 struct {
// Effective settings for a Redis 5.0 cluster (a combination of settings
// defined in [user_config] and [default_config]).
EffectiveConfig *RedisConfig5_0 `protobuf:"bytes,1,opt,name=effective_config,json=effectiveConfig,proto3" json:"effective_config,omitempty"`
// User-defined settings for a Redis 5.0 cluster.
UserConfig *RedisConfig5_0 `protobuf:"bytes,2,opt,name=user_config,json=userConfig,proto3" json:"user_config,omitempty"`
// Default configuration for a Redis 5.0 cluster.
DefaultConfig *RedisConfig5_0 `protobuf:"bytes,3,opt,name=default_config,json=defaultConfig,proto3" json:"default_config,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RedisConfigSet5_0) Reset() { *m = RedisConfigSet5_0{} }
func (m *RedisConfigSet5_0) String() string { return proto.CompactTextString(m) }
func (*RedisConfigSet5_0) ProtoMessage() {}
func (*RedisConfigSet5_0) Descriptor() ([]byte, []int) {
return fileDescriptor_redis5_0_e003f487f83590f3, []int{1}
}
func (m *RedisConfigSet5_0) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RedisConfigSet5_0.Unmarshal(m, b)
}
func (m *RedisConfigSet5_0) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RedisConfigSet5_0.Marshal(b, m, deterministic)
}
func (dst *RedisConfigSet5_0) XXX_Merge(src proto.Message) {
xxx_messageInfo_RedisConfigSet5_0.Merge(dst, src)
}
func (m *RedisConfigSet5_0) XXX_Size() int {
return xxx_messageInfo_RedisConfigSet5_0.Size(m)
}
func (m *RedisConfigSet5_0) XXX_DiscardUnknown() {
xxx_messageInfo_RedisConfigSet5_0.DiscardUnknown(m)
}
var xxx_messageInfo_RedisConfigSet5_0 proto.InternalMessageInfo
func (m *RedisConfigSet5_0) GetEffectiveConfig() *RedisConfig5_0 {
if m != nil {
return m.EffectiveConfig
}
return nil
}
func (m *RedisConfigSet5_0) GetUserConfig() *RedisConfig5_0 {
if m != nil {
return m.UserConfig
}
return nil
}
func (m *RedisConfigSet5_0) GetDefaultConfig() *RedisConfig5_0 {
if m != nil {
return m.DefaultConfig
}
return nil
}
func init() {
proto.RegisterType((*RedisConfig5_0)(nil), "yandex.cloud.mdb.redis.v1alpha.config.RedisConfig5_0")
proto.RegisterType((*RedisConfigSet5_0)(nil), "yandex.cloud.mdb.redis.v1alpha.config.RedisConfigSet5_0")
proto.RegisterEnum("yandex.cloud.mdb.redis.v1alpha.config.RedisConfig5_0_MaxmemoryPolicy", RedisConfig5_0_MaxmemoryPolicy_name, RedisConfig5_0_MaxmemoryPolicy_value)
}
func init() {
proto.RegisterFile("yandex/cloud/mdb/redis/v1alpha/config/redis5_0.proto", fileDescriptor_redis5_0_e003f487f83590f3)
}
var fileDescriptor_redis5_0_e003f487f83590f3 = []byte{
// 469 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x93, 0xcb, 0x6e, 0xd3, 0x40,
0x14, 0x86, 0x71, 0x02, 0x6d, 0x39, 0x01, 0x7b, 0x18, 0x36, 0x55, 0x41, 0x28, 0x8a, 0x84, 0x94,
0x4d, 0xc7, 0x25, 0x34, 0x6c, 0x58, 0x85, 0xd4, 0x91, 0x2c, 0xec, 0x38, 0x38, 0x17, 0x11, 0x84,
0x64, 0x7c, 0x19, 0xbb, 0x96, 0xec, 0x8c, 0xe5, 0x4b, 0xdb, 0xbc, 0x0b, 0x6f, 0xc0, 0x6b, 0xf0,
0x60, 0x28, 0x33, 0x71, 0x84, 0x59, 0x55, 0x74, 0x39, 0xbf, 0xfe, 0xff, 0x3b, 0x47, 0xe7, 0xcc,
0x81, 0xcb, 0xad, 0xbb, 0x09, 0xe8, 0x9d, 0xea, 0x27, 0xac, 0x0a, 0xd4, 0x34, 0xf0, 0xd4, 0x9c,
0x06, 0x71, 0xa1, 0xde, 0xbc, 0x73, 0x93, 0xec, 0xda, 0x55, 0x7d, 0xb6, 0x09, 0xe3, 0x48, 0x88,
0x43, 0xe7, 0x82, 0x64, 0x39, 0x2b, 0x19, 0x7e, 0x2b, 0x52, 0x84, 0xa7, 0x48, 0x1a, 0x78, 0x84,
0x1b, 0xc8, 0x3e, 0x45, 0x44, 0xea, 0xec, 0x4d, 0xc4, 0x58, 0x94, 0x50, 0x95, 0x87, 0xbc, 0x2a,
0x54, 0x6f, 0x73, 0x37, 0xcb, 0x68, 0x5e, 0x08, 0x4c, 0xef, 0x67, 0x1b, 0x64, 0x7b, 0x17, 0x1c,
0x73, 0xff, 0xd0, 0xb9, 0xc0, 0x19, 0xa0, 0xd4, 0xbd, 0x4b, 0x69, 0xca, 0xf2, 0xad, 0x93, 0xb1,
0x24, 0xf6, 0xb7, 0xa7, 0x52, 0x57, 0xea, 0xcb, 0x03, 0x8d, 0xdc, 0xab, 0x28, 0x69, 0x02, 0x89,
0x59, 0xd3, 0x66, 0x1c, 0x66, 0x2b, 0x69, 0x53, 0xc0, 0x43, 0x38, 0x2e, 0xe3, 0x94, 0xb2, 0xaa,
0x3c, 0x6d, 0x75, 0xa5, 0x7e, 0x67, 0xf0, 0x8a, 0x88, 0xb6, 0x49, 0xdd, 0x36, 0xd1, 0x37, 0xe5,
0x87, 0xcb, 0x95, 0x9b, 0x54, 0xd4, 0xae, 0xbd, 0xf8, 0x0c, 0x4e, 0x32, 0xb7, 0x28, 0x6e, 0x59,
0x1e, 0x9c, 0xb6, 0xbb, 0x52, 0xff, 0xa9, 0x7d, 0x78, 0xf7, 0x7e, 0x4b, 0xa0, 0xfc, 0x53, 0x17,
0x77, 0xe1, 0xb5, 0x39, 0xfa, 0x6a, 0x6a, 0xa6, 0x65, 0xaf, 0x9d, 0x99, 0x65, 0xe8, 0xe3, 0xb5,
0xb3, 0x9c, 0xce, 0x67, 0xda, 0x58, 0x9f, 0xe8, 0xda, 0x15, 0x7a, 0x84, 0x11, 0x3c, 0x5b, 0x59,
0xc6, 0x68, 0xa1, 0x1b, 0x9a, 0x63, 0xd8, 0x4b, 0x24, 0x61, 0x05, 0x3a, 0x23, 0xc3, 0xf8, 0xac,
0xad, 0xe7, 0x5c, 0x68, 0x35, 0x2d, 0x93, 0x25, 0x6a, 0x37, 0x2c, 0x93, 0x25, 0x7a, 0x8c, 0x5f,
0x82, 0x72, 0xb0, 0xd8, 0xa3, 0xe9, 0x95, 0x65, 0xa2, 0x27, 0x18, 0x83, 0x5c, 0xbb, 0xf6, 0xda,
0x51, 0x83, 0xb5, 0x58, 0x18, 0xe8, 0x18, 0xcb, 0x00, 0x53, 0x4b, 0x5b, 0xe9, 0xe3, 0x85, 0x6e,
0x4d, 0xd1, 0x49, 0xef, 0x57, 0x0b, 0x5e, 0xfc, 0x35, 0xcd, 0x39, 0x2d, 0x77, 0x1b, 0xfa, 0x01,
0x88, 0x86, 0x21, 0xf5, 0xcb, 0xf8, 0x86, 0x3a, 0x62, 0xe6, 0x7c, 0x43, 0x9d, 0xc1, 0xf0, 0xbf,
0x36, 0x64, 0x2b, 0x07, 0x9c, 0xd0, 0xf0, 0x0a, 0x3a, 0x55, 0x41, 0xf3, 0x1a, 0xde, 0x7a, 0x08,
0x1c, 0x76, 0xa4, 0x3d, 0xf7, 0x3b, 0xc8, 0x01, 0x0d, 0xdd, 0x2a, 0x29, 0x6b, 0x74, 0xfb, 0x21,
0xe8, 0xe7, 0x7b, 0x98, 0x50, 0x3e, 0x7d, 0xf9, 0x66, 0x45, 0x71, 0x79, 0x5d, 0x79, 0xc4, 0x67,
0xa9, 0x2a, 0x88, 0xe7, 0xe2, 0xac, 0x22, 0x76, 0x1e, 0xd1, 0x0d, 0xff, 0x4e, 0xea, 0xbd, 0xee,
0xed, 0x23, 0x17, 0xbd, 0x23, 0x1e, 0x79, 0xff, 0x27, 0x00, 0x00, 0xff, 0xff, 0xd1, 0x43, 0x88,
0xaf, 0xa5, 0x03, 0x00, 0x00,
}

Some files were not shown because too many files have changed in this diff Show More