kubernetes/vendor/google.golang.org/protobuf/types/known/structpb/struct.pb.go

type NullValue

const NullValue_NULL_VALUE

var NullValue_name

var NullValue_value

func (x NullValue) Enum() *NullValue {}

func (x NullValue) String() string {}

func (NullValue) Descriptor() protoreflect.EnumDescriptor {}

func (NullValue) Type() protoreflect.EnumType {}

func (x NullValue) Number() protoreflect.EnumNumber {}

// Deprecated: Use NullValue.Descriptor instead.
func (NullValue) EnumDescriptor() ([]byte, []int) {}

type Struct

// NewStruct constructs a Struct from a general-purpose Go map.
// The map keys must be valid UTF-8.
// The map values are converted using NewValue.
func NewStruct(v map[string]any) (*Struct, error) {}

// AsMap converts x to a general-purpose Go map.
// The map values are converted by calling Value.AsInterface.
func (x *Struct) AsMap() map[string]any {}

func (x *Struct) MarshalJSON() ([]byte, error) {}

func (x *Struct) UnmarshalJSON(b []byte) error {}

func (x *Struct) Reset() {}

func (x *Struct) String() string {}

func (*Struct) ProtoMessage() {}

func (x *Struct) ProtoReflect() protoreflect.Message {}

// Deprecated: Use Struct.ProtoReflect.Descriptor instead.
func (*Struct) Descriptor() ([]byte, []int) {}

func (x *Struct) GetFields() map[string]*Value {}

type Value

// NewValue constructs a Value from a general-purpose Go interface.
//
//	╔════════════════════════╤════════════════════════════════════════════╗
//	║ Go type                │ Conversion                                 ║
//	╠════════════════════════╪════════════════════════════════════════════╣
//	║ nil                    │ stored as NullValue                        ║
//	║ bool                   │ stored as BoolValue                        ║
//	║ int, int32, int64      │ stored as NumberValue                      ║
//	║ uint, uint32, uint64   │ stored as NumberValue                      ║
//	║ float32, float64       │ stored as NumberValue                      ║
//	║ string                 │ stored as StringValue; must be valid UTF-8 ║
//	║ []byte                 │ stored as StringValue; base64-encoded      ║
//	║ map[string]any         │ stored as StructValue                      ║
//	║ []any                  │ stored as ListValue                        ║
//	╚════════════════════════╧════════════════════════════════════════════╝
//
// When converting an int64 or uint64 to a NumberValue, numeric precision loss
// is possible since they are stored as a float64.
func NewValue(v any) (*Value, error) {}

// NewNullValue constructs a new null Value.
func NewNullValue() *Value {}

// NewBoolValue constructs a new boolean Value.
func NewBoolValue(v bool) *Value {}

// NewNumberValue constructs a new number Value.
func NewNumberValue(v float64) *Value {}

// NewStringValue constructs a new string Value.
func NewStringValue(v string) *Value {}

// NewStructValue constructs a new struct Value.
func NewStructValue(v *Struct) *Value {}

// NewListValue constructs a new list Value.
func NewListValue(v *ListValue) *Value {}

// AsInterface converts x to a general-purpose Go interface.
//
// Calling Value.MarshalJSON and "encoding/json".Marshal on this output produce
// semantically equivalent JSON (assuming no errors occur).
//
// Floating-point values (i.e., "NaN", "Infinity", and "-Infinity") are
// converted as strings to remain compatible with MarshalJSON.
func (x *Value) AsInterface() any {}

func (x *Value) MarshalJSON() ([]byte, error) {}

func (x *Value) UnmarshalJSON(b []byte) error {}

func (x *Value) Reset() {}

func (x *Value) String() string {}

func (*Value) ProtoMessage() {}

func (x *Value) ProtoReflect() protoreflect.Message {}

// Deprecated: Use Value.ProtoReflect.Descriptor instead.
func (*Value) Descriptor() ([]byte, []int) {}

func (m *Value) GetKind() isValue_Kind {}

func (x *Value) GetNullValue() NullValue {}

func (x *Value) GetNumberValue() float64 {}

func (x *Value) GetStringValue() string {}

func (x *Value) GetBoolValue() bool {}

func (x *Value) GetStructValue() *Struct {}

func (x *Value) GetListValue() *ListValue {}

type isValue_Kind

type Value_NullValue

type Value_NumberValue

type Value_StringValue

type Value_BoolValue

type Value_StructValue

type Value_ListValue

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() {}

type ListValue

// NewList constructs a ListValue from a general-purpose Go slice.
// The slice elements are converted using NewValue.
func NewList(v []any) (*ListValue, error) {}

// AsSlice converts x to a general-purpose Go slice.
// The slice elements are converted by calling Value.AsInterface.
func (x *ListValue) AsSlice() []any {}

func (x *ListValue) MarshalJSON() ([]byte, error) {}

func (x *ListValue) UnmarshalJSON(b []byte) error {}

func (x *ListValue) Reset() {}

func (x *ListValue) String() string {}

func (*ListValue) ProtoMessage() {}

func (x *ListValue) ProtoReflect() protoreflect.Message {}

// Deprecated: Use ListValue.ProtoReflect.Descriptor instead.
func (*ListValue) Descriptor() ([]byte, []int) {}

func (x *ListValue) GetValues() []*Value {}

var File_google_protobuf_struct_proto

var file_google_protobuf_struct_proto_rawDesc

var file_google_protobuf_struct_proto_rawDescOnce

var file_google_protobuf_struct_proto_rawDescData

func file_google_protobuf_struct_proto_rawDescGZIP() []byte {}

var file_google_protobuf_struct_proto_enumTypes

var file_google_protobuf_struct_proto_msgTypes

var file_google_protobuf_struct_proto_goTypes

var file_google_protobuf_struct_proto_depIdxs

func init() {}

func file_google_protobuf_struct_proto_init() {}