dendrite_config.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: dendrite_config.proto

package dendrite_config

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	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

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_13fca59719c8e89a, []int{0}
}

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

type RegisterTrustedKeyCommand struct {
	PublicKey            *PublicKey `protobuf:"bytes,1,opt,name=publicKey,proto3" json:"publicKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *RegisterTrustedKeyCommand) Reset()         { *m = RegisterTrustedKeyCommand{} }
func (m *RegisterTrustedKeyCommand) String() string { return proto.CompactTextString(m) }
func (*RegisterTrustedKeyCommand) ProtoMessage()    {}
func (*RegisterTrustedKeyCommand) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{1}
}

func (m *RegisterTrustedKeyCommand) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RegisterTrustedKeyCommand.Unmarshal(m, b)
}
func (m *RegisterTrustedKeyCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RegisterTrustedKeyCommand.Marshal(b, m, deterministic)
}
func (m *RegisterTrustedKeyCommand) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterTrustedKeyCommand.Merge(m, src)
}
func (m *RegisterTrustedKeyCommand) XXX_Size() int {
	return xxx_messageInfo_RegisterTrustedKeyCommand.Size(m)
}
func (m *RegisterTrustedKeyCommand) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterTrustedKeyCommand.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterTrustedKeyCommand proto.InternalMessageInfo

func (m *RegisterTrustedKeyCommand) GetPublicKey() *PublicKey {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

type RegisterKeyManagerCommand struct {
	PublicKey            *PublicKey `protobuf:"bytes,1,opt,name=publicKey,proto3" json:"publicKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *RegisterKeyManagerCommand) Reset()         { *m = RegisterKeyManagerCommand{} }
func (m *RegisterKeyManagerCommand) String() string { return proto.CompactTextString(m) }
func (*RegisterKeyManagerCommand) ProtoMessage()    {}
func (*RegisterKeyManagerCommand) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{2}
}

func (m *RegisterKeyManagerCommand) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RegisterKeyManagerCommand.Unmarshal(m, b)
}
func (m *RegisterKeyManagerCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RegisterKeyManagerCommand.Marshal(b, m, deterministic)
}
func (m *RegisterKeyManagerCommand) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterKeyManagerCommand.Merge(m, src)
}
func (m *RegisterKeyManagerCommand) XXX_Size() int {
	return xxx_messageInfo_RegisterKeyManagerCommand.Size(m)
}
func (m *RegisterKeyManagerCommand) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterKeyManagerCommand.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterKeyManagerCommand proto.InternalMessageInfo

func (m *RegisterKeyManagerCommand) GetPublicKey() *PublicKey {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

type RegisterCredentialsCommand struct {
	Credentials          *Credentials `protobuf:"bytes,1,opt,name=credentials,proto3" json:"credentials,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *RegisterCredentialsCommand) Reset()         { *m = RegisterCredentialsCommand{} }
func (m *RegisterCredentialsCommand) String() string { return proto.CompactTextString(m) }
func (*RegisterCredentialsCommand) ProtoMessage()    {}
func (*RegisterCredentialsCommand) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{3}
}

func (m *RegisterCredentialsCommand) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RegisterCredentialsCommand.Unmarshal(m, b)
}
func (m *RegisterCredentialsCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RegisterCredentialsCommand.Marshal(b, m, deterministic)
}
func (m *RegisterCredentialsCommand) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterCredentialsCommand.Merge(m, src)
}
func (m *RegisterCredentialsCommand) XXX_Size() int {
	return xxx_messageInfo_RegisterCredentialsCommand.Size(m)
}
func (m *RegisterCredentialsCommand) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterCredentialsCommand.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterCredentialsCommand proto.InternalMessageInfo

func (m *RegisterCredentialsCommand) GetCredentials() *Credentials {
	if m != nil {
		return m.Credentials
	}
	return nil
}

type RegisterUnencryptedCredentialsCommand struct {
	Credentials          *Credentials `protobuf:"bytes,1,opt,name=credentials,proto3" json:"credentials,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *RegisterUnencryptedCredentialsCommand) Reset()         { *m = RegisterUnencryptedCredentialsCommand{} }
func (m *RegisterUnencryptedCredentialsCommand) String() string { return proto.CompactTextString(m) }
func (*RegisterUnencryptedCredentialsCommand) ProtoMessage()    {}
func (*RegisterUnencryptedCredentialsCommand) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{4}
}

func (m *RegisterUnencryptedCredentialsCommand) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RegisterUnencryptedCredentialsCommand.Unmarshal(m, b)
}
func (m *RegisterUnencryptedCredentialsCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RegisterUnencryptedCredentialsCommand.Marshal(b, m, deterministic)
}
func (m *RegisterUnencryptedCredentialsCommand) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterUnencryptedCredentialsCommand.Merge(m, src)
}
func (m *RegisterUnencryptedCredentialsCommand) XXX_Size() int {
	return xxx_messageInfo_RegisterUnencryptedCredentialsCommand.Size(m)
}
func (m *RegisterUnencryptedCredentialsCommand) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterUnencryptedCredentialsCommand.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterUnencryptedCredentialsCommand proto.InternalMessageInfo

func (m *RegisterUnencryptedCredentialsCommand) GetCredentials() *Credentials {
	if m != nil {
		return m.Credentials
	}
	return nil
}

type ChangePropertyCommand struct {
	Property             *KeyValue `protobuf:"bytes,1,opt,name=property,proto3" json:"property,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *ChangePropertyCommand) Reset()         { *m = ChangePropertyCommand{} }
func (m *ChangePropertyCommand) String() string { return proto.CompactTextString(m) }
func (*ChangePropertyCommand) ProtoMessage()    {}
func (*ChangePropertyCommand) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{5}
}

func (m *ChangePropertyCommand) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChangePropertyCommand.Unmarshal(m, b)
}
func (m *ChangePropertyCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChangePropertyCommand.Marshal(b, m, deterministic)
}
func (m *ChangePropertyCommand) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChangePropertyCommand.Merge(m, src)
}
func (m *ChangePropertyCommand) XXX_Size() int {
	return xxx_messageInfo_ChangePropertyCommand.Size(m)
}
func (m *ChangePropertyCommand) XXX_DiscardUnknown() {
	xxx_messageInfo_ChangePropertyCommand.DiscardUnknown(m)
}

var xxx_messageInfo_ChangePropertyCommand proto.InternalMessageInfo

func (m *ChangePropertyCommand) GetProperty() *KeyValue {
	if m != nil {
		return m.Property
	}
	return nil
}

type TrustedKeyAddedEvent struct {
	PublicKey            *PublicKey `protobuf:"bytes,1,opt,name=publicKey,proto3" json:"publicKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *TrustedKeyAddedEvent) Reset()         { *m = TrustedKeyAddedEvent{} }
func (m *TrustedKeyAddedEvent) String() string { return proto.CompactTextString(m) }
func (*TrustedKeyAddedEvent) ProtoMessage()    {}
func (*TrustedKeyAddedEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{6}
}

func (m *TrustedKeyAddedEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TrustedKeyAddedEvent.Unmarshal(m, b)
}
func (m *TrustedKeyAddedEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TrustedKeyAddedEvent.Marshal(b, m, deterministic)
}
func (m *TrustedKeyAddedEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TrustedKeyAddedEvent.Merge(m, src)
}
func (m *TrustedKeyAddedEvent) XXX_Size() int {
	return xxx_messageInfo_TrustedKeyAddedEvent.Size(m)
}
func (m *TrustedKeyAddedEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_TrustedKeyAddedEvent.DiscardUnknown(m)
}

var xxx_messageInfo_TrustedKeyAddedEvent proto.InternalMessageInfo

func (m *TrustedKeyAddedEvent) GetPublicKey() *PublicKey {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

type TrustedKeyRemovedEvent struct {
	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 *TrustedKeyRemovedEvent) Reset()         { *m = TrustedKeyRemovedEvent{} }
func (m *TrustedKeyRemovedEvent) String() string { return proto.CompactTextString(m) }
func (*TrustedKeyRemovedEvent) ProtoMessage()    {}
func (*TrustedKeyRemovedEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{7}
}

func (m *TrustedKeyRemovedEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TrustedKeyRemovedEvent.Unmarshal(m, b)
}
func (m *TrustedKeyRemovedEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TrustedKeyRemovedEvent.Marshal(b, m, deterministic)
}
func (m *TrustedKeyRemovedEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TrustedKeyRemovedEvent.Merge(m, src)
}
func (m *TrustedKeyRemovedEvent) XXX_Size() int {
	return xxx_messageInfo_TrustedKeyRemovedEvent.Size(m)
}
func (m *TrustedKeyRemovedEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_TrustedKeyRemovedEvent.DiscardUnknown(m)
}

var xxx_messageInfo_TrustedKeyRemovedEvent proto.InternalMessageInfo

func (m *TrustedKeyRemovedEvent) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type KeyManagerAddedEvent struct {
	PublicKey            *PublicKey `protobuf:"bytes,1,opt,name=publicKey,proto3" json:"publicKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *KeyManagerAddedEvent) Reset()         { *m = KeyManagerAddedEvent{} }
func (m *KeyManagerAddedEvent) String() string { return proto.CompactTextString(m) }
func (*KeyManagerAddedEvent) ProtoMessage()    {}
func (*KeyManagerAddedEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{8}
}

func (m *KeyManagerAddedEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KeyManagerAddedEvent.Unmarshal(m, b)
}
func (m *KeyManagerAddedEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KeyManagerAddedEvent.Marshal(b, m, deterministic)
}
func (m *KeyManagerAddedEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeyManagerAddedEvent.Merge(m, src)
}
func (m *KeyManagerAddedEvent) XXX_Size() int {
	return xxx_messageInfo_KeyManagerAddedEvent.Size(m)
}
func (m *KeyManagerAddedEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_KeyManagerAddedEvent.DiscardUnknown(m)
}

var xxx_messageInfo_KeyManagerAddedEvent proto.InternalMessageInfo

func (m *KeyManagerAddedEvent) GetPublicKey() *PublicKey {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

type KeyManagerRemovedEvent struct {
	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 *KeyManagerRemovedEvent) Reset()         { *m = KeyManagerRemovedEvent{} }
func (m *KeyManagerRemovedEvent) String() string { return proto.CompactTextString(m) }
func (*KeyManagerRemovedEvent) ProtoMessage()    {}
func (*KeyManagerRemovedEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{9}
}

func (m *KeyManagerRemovedEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KeyManagerRemovedEvent.Unmarshal(m, b)
}
func (m *KeyManagerRemovedEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KeyManagerRemovedEvent.Marshal(b, m, deterministic)
}
func (m *KeyManagerRemovedEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeyManagerRemovedEvent.Merge(m, src)
}
func (m *KeyManagerRemovedEvent) XXX_Size() int {
	return xxx_messageInfo_KeyManagerRemovedEvent.Size(m)
}
func (m *KeyManagerRemovedEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_KeyManagerRemovedEvent.DiscardUnknown(m)
}

var xxx_messageInfo_KeyManagerRemovedEvent proto.InternalMessageInfo

func (m *KeyManagerRemovedEvent) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type CredentialsAddedEvent struct {
	Credentials          *Credentials `protobuf:"bytes,1,opt,name=credentials,proto3" json:"credentials,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *CredentialsAddedEvent) Reset()         { *m = CredentialsAddedEvent{} }
func (m *CredentialsAddedEvent) String() string { return proto.CompactTextString(m) }
func (*CredentialsAddedEvent) ProtoMessage()    {}
func (*CredentialsAddedEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{10}
}

func (m *CredentialsAddedEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CredentialsAddedEvent.Unmarshal(m, b)
}
func (m *CredentialsAddedEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CredentialsAddedEvent.Marshal(b, m, deterministic)
}
func (m *CredentialsAddedEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CredentialsAddedEvent.Merge(m, src)
}
func (m *CredentialsAddedEvent) XXX_Size() int {
	return xxx_messageInfo_CredentialsAddedEvent.Size(m)
}
func (m *CredentialsAddedEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_CredentialsAddedEvent.DiscardUnknown(m)
}

var xxx_messageInfo_CredentialsAddedEvent proto.InternalMessageInfo

func (m *CredentialsAddedEvent) GetCredentials() *Credentials {
	if m != nil {
		return m.Credentials
	}
	return nil
}

type CredentialsRemovedEvent struct {
	Identifier           string   `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CredentialsRemovedEvent) Reset()         { *m = CredentialsRemovedEvent{} }
func (m *CredentialsRemovedEvent) String() string { return proto.CompactTextString(m) }
func (*CredentialsRemovedEvent) ProtoMessage()    {}
func (*CredentialsRemovedEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{11}
}

func (m *CredentialsRemovedEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CredentialsRemovedEvent.Unmarshal(m, b)
}
func (m *CredentialsRemovedEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CredentialsRemovedEvent.Marshal(b, m, deterministic)
}
func (m *CredentialsRemovedEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CredentialsRemovedEvent.Merge(m, src)
}
func (m *CredentialsRemovedEvent) XXX_Size() int {
	return xxx_messageInfo_CredentialsRemovedEvent.Size(m)
}
func (m *CredentialsRemovedEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_CredentialsRemovedEvent.DiscardUnknown(m)
}

var xxx_messageInfo_CredentialsRemovedEvent proto.InternalMessageInfo

func (m *CredentialsRemovedEvent) GetIdentifier() string {
	if m != nil {
		return m.Identifier
	}
	return ""
}

type PropertyChangedEvent struct {
	Property             *KeyValue `protobuf:"bytes,1,opt,name=property,proto3" json:"property,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *PropertyChangedEvent) Reset()         { *m = PropertyChangedEvent{} }
func (m *PropertyChangedEvent) String() string { return proto.CompactTextString(m) }
func (*PropertyChangedEvent) ProtoMessage()    {}
func (*PropertyChangedEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{12}
}

func (m *PropertyChangedEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PropertyChangedEvent.Unmarshal(m, b)
}
func (m *PropertyChangedEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PropertyChangedEvent.Marshal(b, m, deterministic)
}
func (m *PropertyChangedEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PropertyChangedEvent.Merge(m, src)
}
func (m *PropertyChangedEvent) XXX_Size() int {
	return xxx_messageInfo_PropertyChangedEvent.Size(m)
}
func (m *PropertyChangedEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_PropertyChangedEvent.DiscardUnknown(m)
}

var xxx_messageInfo_PropertyChangedEvent proto.InternalMessageInfo

func (m *PropertyChangedEvent) GetProperty() *KeyValue {
	if m != nil {
		return m.Property
	}
	return nil
}

type PublicKey struct {
	PublicKey            string   `protobuf:"bytes,1,opt,name=publicKey,proto3" json:"publicKey,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PublicKey) Reset()         { *m = PublicKey{} }
func (m *PublicKey) String() string { return proto.CompactTextString(m) }
func (*PublicKey) ProtoMessage()    {}
func (*PublicKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{13}
}

func (m *PublicKey) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PublicKey.Unmarshal(m, b)
}
func (m *PublicKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PublicKey.Marshal(b, m, deterministic)
}
func (m *PublicKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PublicKey.Merge(m, src)
}
func (m *PublicKey) XXX_Size() int {
	return xxx_messageInfo_PublicKey.Size(m)
}
func (m *PublicKey) XXX_DiscardUnknown() {
	xxx_messageInfo_PublicKey.DiscardUnknown(m)
}

var xxx_messageInfo_PublicKey proto.InternalMessageInfo

func (m *PublicKey) GetPublicKey() string {
	if m != nil {
		return m.PublicKey
	}
	return ""
}

func (m *PublicKey) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type PrivateKey struct {
	PrivateKey           string   `protobuf:"bytes,1,opt,name=privateKey,proto3" json:"privateKey,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PrivateKey) Reset()         { *m = PrivateKey{} }
func (m *PrivateKey) String() string { return proto.CompactTextString(m) }
func (*PrivateKey) ProtoMessage()    {}
func (*PrivateKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{14}
}

func (m *PrivateKey) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PrivateKey.Unmarshal(m, b)
}
func (m *PrivateKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PrivateKey.Marshal(b, m, deterministic)
}
func (m *PrivateKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PrivateKey.Merge(m, src)
}
func (m *PrivateKey) XXX_Size() int {
	return xxx_messageInfo_PrivateKey.Size(m)
}
func (m *PrivateKey) XXX_DiscardUnknown() {
	xxx_messageInfo_PrivateKey.DiscardUnknown(m)
}

var xxx_messageInfo_PrivateKey proto.InternalMessageInfo

func (m *PrivateKey) GetPrivateKey() string {
	if m != nil {
		return m.PrivateKey
	}
	return ""
}

func (m *PrivateKey) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type AccessToken struct {
	Jwt                  string   `protobuf:"bytes,1,opt,name=jwt,proto3" json:"jwt,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AccessToken) Reset()         { *m = AccessToken{} }
func (m *AccessToken) String() string { return proto.CompactTextString(m) }
func (*AccessToken) ProtoMessage()    {}
func (*AccessToken) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{15}
}

func (m *AccessToken) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AccessToken.Unmarshal(m, b)
}
func (m *AccessToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AccessToken.Marshal(b, m, deterministic)
}
func (m *AccessToken) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AccessToken.Merge(m, src)
}
func (m *AccessToken) XXX_Size() int {
	return xxx_messageInfo_AccessToken.Size(m)
}
func (m *AccessToken) XXX_DiscardUnknown() {
	xxx_messageInfo_AccessToken.DiscardUnknown(m)
}

var xxx_messageInfo_AccessToken proto.InternalMessageInfo

func (m *AccessToken) GetJwt() string {
	if m != nil {
		return m.Jwt
	}
	return ""
}

type TrustedKeyRequest struct {
	PublicKey            *PublicKey `protobuf:"bytes,1,opt,name=publicKey,proto3" json:"publicKey,omitempty"`
	Nonce                []byte     `protobuf:"bytes,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Signature            *Signature `protobuf:"bytes,4,opt,name=signature,proto3" json:"signature,omitempty"`
	IsKeyManager         bool       `protobuf:"varint,5,opt,name=isKeyManager,proto3" json:"isKeyManager,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *TrustedKeyRequest) Reset()         { *m = TrustedKeyRequest{} }
func (m *TrustedKeyRequest) String() string { return proto.CompactTextString(m) }
func (*TrustedKeyRequest) ProtoMessage()    {}
func (*TrustedKeyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{16}
}

func (m *TrustedKeyRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TrustedKeyRequest.Unmarshal(m, b)
}
func (m *TrustedKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TrustedKeyRequest.Marshal(b, m, deterministic)
}
func (m *TrustedKeyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TrustedKeyRequest.Merge(m, src)
}
func (m *TrustedKeyRequest) XXX_Size() int {
	return xxx_messageInfo_TrustedKeyRequest.Size(m)
}
func (m *TrustedKeyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TrustedKeyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TrustedKeyRequest proto.InternalMessageInfo

func (m *TrustedKeyRequest) GetPublicKey() *PublicKey {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

func (m *TrustedKeyRequest) GetNonce() []byte {
	if m != nil {
		return m.Nonce
	}
	return nil
}

func (m *TrustedKeyRequest) GetSignature() *Signature {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *TrustedKeyRequest) GetIsKeyManager() bool {
	if m != nil {
		return m.IsKeyManager
	}
	return false
}

type TrustedKeyResponse struct {
	Status               *Status  `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	Nonce                []byte   `protobuf:"bytes,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TrustedKeyResponse) Reset()         { *m = TrustedKeyResponse{} }
func (m *TrustedKeyResponse) String() string { return proto.CompactTextString(m) }
func (*TrustedKeyResponse) ProtoMessage()    {}
func (*TrustedKeyResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{17}
}

func (m *TrustedKeyResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TrustedKeyResponse.Unmarshal(m, b)
}
func (m *TrustedKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TrustedKeyResponse.Marshal(b, m, deterministic)
}
func (m *TrustedKeyResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TrustedKeyResponse.Merge(m, src)
}
func (m *TrustedKeyResponse) XXX_Size() int {
	return xxx_messageInfo_TrustedKeyResponse.Size(m)
}
func (m *TrustedKeyResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TrustedKeyResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TrustedKeyResponse proto.InternalMessageInfo

func (m *TrustedKeyResponse) GetStatus() *Status {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *TrustedKeyResponse) GetNonce() []byte {
	if m != nil {
		return m.Nonce
	}
	return nil
}

type Signature struct {
	Format               string   `protobuf:"bytes,1,opt,name=format,proto3" json:"format,omitempty"`
	Blob                 []byte   `protobuf:"bytes,2,opt,name=blob,proto3" json:"blob,omitempty"`
	Rest                 []byte   `protobuf:"bytes,3,opt,name=rest,proto3" json:"rest,omitempty"`
	SignatureName        string   `protobuf:"bytes,4,opt,name=signatureName,proto3" json:"signatureName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Signature) Reset()         { *m = Signature{} }
func (m *Signature) String() string { return proto.CompactTextString(m) }
func (*Signature) ProtoMessage()    {}
func (*Signature) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{18}
}

func (m *Signature) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Signature.Unmarshal(m, b)
}
func (m *Signature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Signature.Marshal(b, m, deterministic)
}
func (m *Signature) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Signature.Merge(m, src)
}
func (m *Signature) XXX_Size() int {
	return xxx_messageInfo_Signature.Size(m)
}
func (m *Signature) XXX_DiscardUnknown() {
	xxx_messageInfo_Signature.DiscardUnknown(m)
}

var xxx_messageInfo_Signature proto.InternalMessageInfo

func (m *Signature) GetFormat() string {
	if m != nil {
		return m.Format
	}
	return ""
}

func (m *Signature) GetBlob() []byte {
	if m != nil {
		return m.Blob
	}
	return nil
}

func (m *Signature) GetRest() []byte {
	if m != nil {
		return m.Rest
	}
	return nil
}

func (m *Signature) GetSignatureName() string {
	if m != nil {
		return m.SignatureName
	}
	return ""
}

type Status struct {
	Code                 int32    `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	Message              string   `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Status) Reset()         { *m = Status{} }
func (m *Status) String() string { return proto.CompactTextString(m) }
func (*Status) ProtoMessage()    {}
func (*Status) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{19}
}

func (m *Status) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Status.Unmarshal(m, b)
}
func (m *Status) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Status.Marshal(b, m, deterministic)
}
func (m *Status) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Status.Merge(m, src)
}
func (m *Status) XXX_Size() int {
	return xxx_messageInfo_Status.Size(m)
}
func (m *Status) XXX_DiscardUnknown() {
	xxx_messageInfo_Status.DiscardUnknown(m)
}

var xxx_messageInfo_Status proto.InternalMessageInfo

func (m *Status) GetCode() int32 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *Status) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type Credentials struct {
	Identifier           string     `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"`
	Secret               string     `protobuf:"bytes,2,opt,name=secret,proto3" json:"secret,omitempty"`
	Signature            *Signature `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *Credentials) Reset()         { *m = Credentials{} }
func (m *Credentials) String() string { return proto.CompactTextString(m) }
func (*Credentials) ProtoMessage()    {}
func (*Credentials) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{20}
}

func (m *Credentials) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Credentials.Unmarshal(m, b)
}
func (m *Credentials) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Credentials.Marshal(b, m, deterministic)
}
func (m *Credentials) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Credentials.Merge(m, src)
}
func (m *Credentials) XXX_Size() int {
	return xxx_messageInfo_Credentials.Size(m)
}
func (m *Credentials) XXX_DiscardUnknown() {
	xxx_messageInfo_Credentials.DiscardUnknown(m)
}

var xxx_messageInfo_Credentials proto.InternalMessageInfo

func (m *Credentials) GetIdentifier() string {
	if m != nil {
		return m.Identifier
	}
	return ""
}

func (m *Credentials) GetSecret() string {
	if m != nil {
		return m.Secret
	}
	return ""
}

func (m *Credentials) GetSignature() *Signature {
	if m != nil {
		return m.Signature
	}
	return nil
}

type KeyValue struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *KeyValue) Reset()         { *m = KeyValue{} }
func (m *KeyValue) String() string { return proto.CompactTextString(m) }
func (*KeyValue) ProtoMessage()    {}
func (*KeyValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_13fca59719c8e89a, []int{21}
}

func (m *KeyValue) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KeyValue.Unmarshal(m, b)
}
func (m *KeyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KeyValue.Marshal(b, m, deterministic)
}
func (m *KeyValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeyValue.Merge(m, src)
}
func (m *KeyValue) XXX_Size() int {
	return xxx_messageInfo_KeyValue.Size(m)
}
func (m *KeyValue) XXX_DiscardUnknown() {
	xxx_messageInfo_KeyValue.DiscardUnknown(m)
}

var xxx_messageInfo_KeyValue proto.InternalMessageInfo

func (m *KeyValue) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *KeyValue) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

func init() {
	proto.RegisterType((*Empty)(nil), "dendrite_config.Empty")
	proto.RegisterType((*RegisterTrustedKeyCommand)(nil), "dendrite_config.RegisterTrustedKeyCommand")
	proto.RegisterType((*RegisterKeyManagerCommand)(nil), "dendrite_config.RegisterKeyManagerCommand")
	proto.RegisterType((*RegisterCredentialsCommand)(nil), "dendrite_config.RegisterCredentialsCommand")
	proto.RegisterType((*RegisterUnencryptedCredentialsCommand)(nil), "dendrite_config.RegisterUnencryptedCredentialsCommand")
	proto.RegisterType((*ChangePropertyCommand)(nil), "dendrite_config.ChangePropertyCommand")
	proto.RegisterType((*TrustedKeyAddedEvent)(nil), "dendrite_config.TrustedKeyAddedEvent")
	proto.RegisterType((*TrustedKeyRemovedEvent)(nil), "dendrite_config.TrustedKeyRemovedEvent")
	proto.RegisterType((*KeyManagerAddedEvent)(nil), "dendrite_config.KeyManagerAddedEvent")
	proto.RegisterType((*KeyManagerRemovedEvent)(nil), "dendrite_config.KeyManagerRemovedEvent")
	proto.RegisterType((*CredentialsAddedEvent)(nil), "dendrite_config.CredentialsAddedEvent")
	proto.RegisterType((*CredentialsRemovedEvent)(nil), "dendrite_config.CredentialsRemovedEvent")
	proto.RegisterType((*PropertyChangedEvent)(nil), "dendrite_config.PropertyChangedEvent")
	proto.RegisterType((*PublicKey)(nil), "dendrite_config.PublicKey")
	proto.RegisterType((*PrivateKey)(nil), "dendrite_config.PrivateKey")
	proto.RegisterType((*AccessToken)(nil), "dendrite_config.AccessToken")
	proto.RegisterType((*TrustedKeyRequest)(nil), "dendrite_config.TrustedKeyRequest")
	proto.RegisterType((*TrustedKeyResponse)(nil), "dendrite_config.TrustedKeyResponse")
	proto.RegisterType((*Signature)(nil), "dendrite_config.Signature")
	proto.RegisterType((*Status)(nil), "dendrite_config.Status")
	proto.RegisterType((*Credentials)(nil), "dendrite_config.Credentials")
	proto.RegisterType((*KeyValue)(nil), "dendrite_config.KeyValue")
}

func init() {
	proto.RegisterFile("dendrite_config.proto", fileDescriptor_13fca59719c8e89a)
}

var fileDescriptor_13fca59719c8e89a = []byte{
	// 739 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x6d, 0x4f, 0x13, 0x4b,
	0x14, 0xee, 0xde, 0xd2, 0x42, 0x4f, 0x21, 0x5c, 0x26, 0x05, 0x4a, 0x2f, 0xe1, 0x92, 0xb9, 0xd7,
	0xa4, 0x1f, 0x0c, 0x25, 0x18, 0x8d, 0x7e, 0xd0, 0x08, 0x0d, 0x26, 0xa4, 0x42, 0x9a, 0x05, 0x34,
	0x51, 0x13, 0xb3, 0xdd, 0x3d, 0x2c, 0x2b, 0xdd, 0xd9, 0x65, 0x66, 0xb6, 0xa6, 0x7e, 0xf1, 0xb7,
	0xf9, 0x7b, 0xfc, 0x13, 0x66, 0xdf, 0x87, 0x2e, 0x85, 0x68, 0xf5, 0xdb, 0x9c, 0xb7, 0xe7, 0x3c,
	0x73, 0x9e, 0x33, 0xdb, 0xc2, 0xaa, 0x85, 0xcc, 0xe2, 0x8e, 0xc4, 0x8f, 0xa6, 0xc7, 0x2e, 0x1c,
	0x7b, 0xc7, 0xe7, 0x9e, 0xf4, 0xc8, 0xf2, 0x84, 0x9b, 0xce, 0x43, 0xe5, 0xd0, 0xf5, 0xe5, 0x98,
	0x9e, 0xc3, 0x86, 0x8e, 0xb6, 0x23, 0x24, 0xf2, 0x33, 0x1e, 0x08, 0x89, 0x56, 0x0f, 0xc7, 0x5d,
	0xcf, 0x75, 0x0d, 0x66, 0x91, 0xa7, 0x50, 0xf3, 0x83, 0xc1, 0xd0, 0x31, 0x7b, 0x38, 0x6e, 0x6a,
	0xdb, 0x5a, 0xbb, 0xbe, 0xd7, 0xda, 0x99, 0xec, 0xd0, 0x4f, 0x33, 0xf4, 0x3c, 0x59, 0x85, 0xed,
	0xe1, 0xf8, 0xd8, 0x60, 0x86, 0x8d, 0x7c, 0x76, 0xd8, 0x0f, 0xd0, 0x4a, 0x61, 0xbb, 0x1c, 0x2d,
	0x64, 0xd2, 0x31, 0x86, 0x22, 0xc5, 0x7d, 0x01, 0x75, 0x33, 0xf7, 0x26, 0xc8, 0x9b, 0x05, 0x64,
	0xa5, 0x52, 0x57, 0x0b, 0xa8, 0x0d, 0x0f, 0x52, 0xf4, 0x73, 0x86, 0xcc, 0xe4, 0x63, 0x5f, 0xa2,
	0xf5, 0x07, 0x1a, 0x9d, 0xc0, 0x6a, 0xf7, 0xd2, 0x60, 0x36, 0xf6, 0xb9, 0xe7, 0x23, 0x97, 0xd9,
	0xc0, 0x1f, 0xc3, 0x82, 0x9f, 0xb8, 0x12, 0xd4, 0x8d, 0x02, 0x6a, 0x0f, 0xc7, 0x6f, 0x8c, 0x61,
	0x80, 0x7a, 0x96, 0x4a, 0xfb, 0xd0, 0xc8, 0xc5, 0xdb, 0xb7, 0x2c, 0xb4, 0x0e, 0x47, 0xc8, 0xe4,
	0x0c, 0x83, 0x7e, 0x08, 0x6b, 0x39, 0xa2, 0x8e, 0xae, 0x37, 0x4a, 0x31, 0x09, 0xcc, 0x31, 0xc3,
	0xc5, 0x08, 0xae, 0xa6, 0x47, 0xe7, 0xb0, 0x7f, 0xae, 0xf2, 0xef, 0xea, 0x9f, 0x23, 0xde, 0xdb,
	0xff, 0x2d, 0xac, 0x2a, 0xb3, 0x56, 0x08, 0xcc, 0x2a, 0xd4, 0x33, 0x58, 0x57, 0x63, 0x2a, 0x8f,
	0x2d, 0x00, 0x27, 0x0a, 0x5c, 0x38, 0xc8, 0x13, 0x36, 0x8a, 0x87, 0x1e, 0x43, 0x23, 0x53, 0x37,
	0xd2, 0x3a, 0xa9, 0xfb, 0x45, 0x89, 0x9f, 0x43, 0x2d, 0x1b, 0x14, 0xd9, 0x9c, 0x9c, 0x6b, 0x4d,
	0x99, 0x5d, 0x36, 0xa1, 0xbf, 0x94, 0x09, 0xbd, 0x04, 0xe8, 0x73, 0x67, 0x64, 0x48, 0x0c, 0x33,
	0xb6, 0x00, 0xfc, 0xcc, 0x4a, 0xb9, 0xe7, 0x9e, 0x5b, 0x11, 0xfe, 0x85, 0xfa, 0xbe, 0x69, 0xa2,
	0x10, 0x67, 0xde, 0x15, 0x32, 0xf2, 0x37, 0x94, 0x3f, 0x7d, 0x96, 0x49, 0x6d, 0x78, 0xa4, 0xdf,
	0x34, 0x58, 0x51, 0x77, 0xe6, 0x3a, 0x40, 0x31, 0xc3, 0x0a, 0x90, 0x06, 0x54, 0x98, 0xc7, 0xcc,
	0x98, 0xc5, 0xa2, 0x1e, 0x1b, 0x21, 0x9e, 0x70, 0x6c, 0x66, 0xc8, 0x80, 0x63, 0x73, 0x6e, 0x0a,
	0xde, 0x69, 0x9a, 0xa1, 0xe7, 0xc9, 0x84, 0xc2, 0xa2, 0x23, 0xf2, 0xa5, 0x6a, 0x56, 0xb6, 0xb5,
	0xf6, 0x82, 0x7e, 0xc3, 0x47, 0xdf, 0x03, 0x51, 0xaf, 0x20, 0x7c, 0x8f, 0x09, 0x24, 0x1d, 0xa8,
	0x0a, 0x69, 0xc8, 0x20, 0x5d, 0xa0, 0xf5, 0x62, 0xc3, 0x28, 0xac, 0x27, 0x69, 0xb7, 0x53, 0xa7,
	0xd7, 0x50, 0xcb, 0x88, 0x91, 0x35, 0xa8, 0x5e, 0x78, 0xdc, 0x35, 0xd2, 0x11, 0x26, 0x56, 0x38,
	0xfa, 0xc1, 0xd0, 0x1b, 0x24, 0x95, 0xd1, 0x39, 0xf4, 0x71, 0x14, 0xb2, 0x59, 0x8e, 0x7d, 0xe1,
	0x99, 0xfc, 0x0f, 0x4b, 0xd9, 0xd5, 0x4e, 0x42, 0xad, 0xe6, 0x22, 0x98, 0x9b, 0x4e, 0xfa, 0x04,
	0xaa, 0x31, 0xb5, 0x10, 0xc3, 0xf4, 0xac, 0xf8, 0xd9, 0x54, 0xf4, 0xe8, 0x4c, 0x9a, 0x30, 0xef,
	0xa2, 0x10, 0x86, 0x9d, 0x2a, 0x9d, 0x9a, 0xf4, 0x2b, 0xd4, 0x95, 0xbd, 0xbf, 0x6f, 0xd7, 0xc3,
	0xcb, 0x08, 0x34, 0x39, 0xca, 0x04, 0x27, 0xb1, 0x6e, 0x8a, 0x55, 0xfe, 0x09, 0xb1, 0xe8, 0x1e,
	0x2c, 0xa4, 0x8f, 0x20, 0x5c, 0xb5, 0xab, 0x6c, 0x4d, 0xc3, 0x63, 0x38, 0xdf, 0x51, 0x18, 0x4a,
	0xda, 0xc5, 0xc6, 0xde, 0xf7, 0x32, 0x34, 0xba, 0x11, 0x66, 0xc0, 0x0d, 0xe9, 0x78, 0xec, 0x14,
	0xf9, 0xc8, 0x31, 0x91, 0x1c, 0xc1, 0xf2, 0x6b, 0x47, 0xc8, 0x5c, 0x59, 0x41, 0xd6, 0x0a, 0x34,
	0xa2, 0x9f, 0xc3, 0xd6, 0x1d, 0xbb, 0x49, 0x4b, 0xbb, 0x1a, 0x19, 0xc0, 0x4a, 0xfc, 0x9a, 0x55,
	0x30, 0x5a, 0x28, 0x2a, 0xbc, 0x83, 0xd6, 0x7f, 0x77, 0xe6, 0xc4, 0x8b, 0x46, 0x4b, 0x6d, 0x6d,
	0x57, 0x23, 0xaf, 0x60, 0xe9, 0x14, 0xa5, 0xf2, 0x5c, 0xff, 0x29, 0x92, 0xca, 0x82, 0xad, 0x29,
	0x37, 0xa1, 0x25, 0x72, 0x9c, 0x72, 0x55, 0xa5, 0xbc, 0xf3, 0xe3, 0x37, 0x1d, 0xac, 0xad, 0x91,
	0x23, 0xa8, 0xed, 0x07, 0xf2, 0xd2, 0xe3, 0xce, 0x17, 0xbc, 0x07, 0xa6, 0x18, 0x55, 0x3e, 0x1d,
	0xb4, 0x44, 0x0e, 0xa0, 0x1e, 0xdd, 0x30, 0xfe, 0xb6, 0x91, 0xe9, 0x1f, 0xc0, 0xe9, 0x84, 0x0e,
	0xb6, 0xde, 0x6d, 0x0a, 0x6e, 0x76, 0xfc, 0x2b, 0xbb, 0x63, 0x73, 0xdf, 0xec, 0x4c, 0xe4, 0x0d,
	0xaa, 0xd1, 0x3f, 0x9f, 0x47, 0x3f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xbc, 0xd3, 0x2b, 0x19, 0x12,
	0x09, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface

// 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.SupportPackageIsVersion6

// ConfigurationServiceClient is the client API for ConfigurationService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ConfigurationServiceClient interface {
	ListTrustedKeys(ctx context.Context, in *Empty, opts ...grpc.CallOption) (ConfigurationService_ListTrustedKeysClient, error)
	ChangeTrustedKeys(ctx context.Context, opts ...grpc.CallOption) (ConfigurationService_ChangeTrustedKeysClient, error)
	SetPrivateKey(ctx context.Context, in *PrivateKey, opts ...grpc.CallOption) (*Empty, error)
	ChangeCredentials(ctx context.Context, opts ...grpc.CallOption) (ConfigurationService_ChangeCredentialsClient, error)
	Authorize(ctx context.Context, in *Credentials, opts ...grpc.CallOption) (*AccessToken, error)
	SetProperty(ctx context.Context, in *KeyValue, opts ...grpc.CallOption) (*Empty, error)
}

type configurationServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewConfigurationServiceClient(cc grpc.ClientConnInterface) ConfigurationServiceClient {
	return &configurationServiceClient{cc}
}

func (c *configurationServiceClient) ListTrustedKeys(ctx context.Context, in *Empty, opts ...grpc.CallOption) (ConfigurationService_ListTrustedKeysClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ConfigurationService_serviceDesc.Streams[0], "/dendrite_config.ConfigurationService/ListTrustedKeys", opts...)
	if err != nil {
		return nil, err
	}
	x := &configurationServiceListTrustedKeysClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ConfigurationService_ListTrustedKeysClient interface {
	Recv() (*PublicKey, error)
	grpc.ClientStream
}

type configurationServiceListTrustedKeysClient struct {
	grpc.ClientStream
}

func (x *configurationServiceListTrustedKeysClient) Recv() (*PublicKey, error) {
	m := new(PublicKey)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *configurationServiceClient) ChangeTrustedKeys(ctx context.Context, opts ...grpc.CallOption) (ConfigurationService_ChangeTrustedKeysClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ConfigurationService_serviceDesc.Streams[1], "/dendrite_config.ConfigurationService/ChangeTrustedKeys", opts...)
	if err != nil {
		return nil, err
	}
	x := &configurationServiceChangeTrustedKeysClient{stream}
	return x, nil
}

type ConfigurationService_ChangeTrustedKeysClient interface {
	Send(*TrustedKeyRequest) error
	Recv() (*TrustedKeyResponse, error)
	grpc.ClientStream
}

type configurationServiceChangeTrustedKeysClient struct {
	grpc.ClientStream
}

func (x *configurationServiceChangeTrustedKeysClient) Send(m *TrustedKeyRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *configurationServiceChangeTrustedKeysClient) Recv() (*TrustedKeyResponse, error) {
	m := new(TrustedKeyResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *configurationServiceClient) SetPrivateKey(ctx context.Context, in *PrivateKey, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/dendrite_config.ConfigurationService/SetPrivateKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *configurationServiceClient) ChangeCredentials(ctx context.Context, opts ...grpc.CallOption) (ConfigurationService_ChangeCredentialsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ConfigurationService_serviceDesc.Streams[2], "/dendrite_config.ConfigurationService/ChangeCredentials", opts...)
	if err != nil {
		return nil, err
	}
	x := &configurationServiceChangeCredentialsClient{stream}
	return x, nil
}

type ConfigurationService_ChangeCredentialsClient interface {
	Send(*Credentials) error
	CloseAndRecv() (*Empty, error)
	grpc.ClientStream
}

type configurationServiceChangeCredentialsClient struct {
	grpc.ClientStream
}

func (x *configurationServiceChangeCredentialsClient) Send(m *Credentials) error {
	return x.ClientStream.SendMsg(m)
}

func (x *configurationServiceChangeCredentialsClient) CloseAndRecv() (*Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *configurationServiceClient) Authorize(ctx context.Context, in *Credentials, opts ...grpc.CallOption) (*AccessToken, error) {
	out := new(AccessToken)
	err := c.cc.Invoke(ctx, "/dendrite_config.ConfigurationService/Authorize", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *configurationServiceClient) SetProperty(ctx context.Context, in *KeyValue, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/dendrite_config.ConfigurationService/SetProperty", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ConfigurationServiceServer is the server API for ConfigurationService service.
type ConfigurationServiceServer interface {
	ListTrustedKeys(*Empty, ConfigurationService_ListTrustedKeysServer) error
	ChangeTrustedKeys(ConfigurationService_ChangeTrustedKeysServer) error
	SetPrivateKey(context.Context, *PrivateKey) (*Empty, error)
	ChangeCredentials(ConfigurationService_ChangeCredentialsServer) error
	Authorize(context.Context, *Credentials) (*AccessToken, error)
	SetProperty(context.Context, *KeyValue) (*Empty, error)
}

// UnimplementedConfigurationServiceServer can be embedded to have forward compatible implementations.
type UnimplementedConfigurationServiceServer struct {
}

func (*UnimplementedConfigurationServiceServer) ListTrustedKeys(req *Empty, srv ConfigurationService_ListTrustedKeysServer) error {
	return status.Errorf(codes.Unimplemented, "method ListTrustedKeys not implemented")
}
func (*UnimplementedConfigurationServiceServer) ChangeTrustedKeys(srv ConfigurationService_ChangeTrustedKeysServer) error {
	return status.Errorf(codes.Unimplemented, "method ChangeTrustedKeys not implemented")
}
func (*UnimplementedConfigurationServiceServer) SetPrivateKey(ctx context.Context, req *PrivateKey) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetPrivateKey not implemented")
}
func (*UnimplementedConfigurationServiceServer) ChangeCredentials(srv ConfigurationService_ChangeCredentialsServer) error {
	return status.Errorf(codes.Unimplemented, "method ChangeCredentials not implemented")
}
func (*UnimplementedConfigurationServiceServer) Authorize(ctx context.Context, req *Credentials) (*AccessToken, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Authorize not implemented")
}
func (*UnimplementedConfigurationServiceServer) SetProperty(ctx context.Context, req *KeyValue) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetProperty not implemented")
}

func RegisterConfigurationServiceServer(s *grpc.Server, srv ConfigurationServiceServer) {
	s.RegisterService(&_ConfigurationService_serviceDesc, srv)
}

func _ConfigurationService_ListTrustedKeys_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ConfigurationServiceServer).ListTrustedKeys(m, &configurationServiceListTrustedKeysServer{stream})
}

type ConfigurationService_ListTrustedKeysServer interface {
	Send(*PublicKey) error
	grpc.ServerStream
}

type configurationServiceListTrustedKeysServer struct {
	grpc.ServerStream
}

func (x *configurationServiceListTrustedKeysServer) Send(m *PublicKey) error {
	return x.ServerStream.SendMsg(m)
}

func _ConfigurationService_ChangeTrustedKeys_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ConfigurationServiceServer).ChangeTrustedKeys(&configurationServiceChangeTrustedKeysServer{stream})
}

type ConfigurationService_ChangeTrustedKeysServer interface {
	Send(*TrustedKeyResponse) error
	Recv() (*TrustedKeyRequest, error)
	grpc.ServerStream
}

type configurationServiceChangeTrustedKeysServer struct {
	grpc.ServerStream
}

func (x *configurationServiceChangeTrustedKeysServer) Send(m *TrustedKeyResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *configurationServiceChangeTrustedKeysServer) Recv() (*TrustedKeyRequest, error) {
	m := new(TrustedKeyRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _ConfigurationService_SetPrivateKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PrivateKey)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConfigurationServiceServer).SetPrivateKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dendrite_config.ConfigurationService/SetPrivateKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConfigurationServiceServer).SetPrivateKey(ctx, req.(*PrivateKey))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConfigurationService_ChangeCredentials_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ConfigurationServiceServer).ChangeCredentials(&configurationServiceChangeCredentialsServer{stream})
}

type ConfigurationService_ChangeCredentialsServer interface {
	SendAndClose(*Empty) error
	Recv() (*Credentials, error)
	grpc.ServerStream
}

type configurationServiceChangeCredentialsServer struct {
	grpc.ServerStream
}

func (x *configurationServiceChangeCredentialsServer) SendAndClose(m *Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *configurationServiceChangeCredentialsServer) Recv() (*Credentials, error) {
	m := new(Credentials)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _ConfigurationService_Authorize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Credentials)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConfigurationServiceServer).Authorize(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dendrite_config.ConfigurationService/Authorize",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConfigurationServiceServer).Authorize(ctx, req.(*Credentials))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConfigurationService_SetProperty_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(KeyValue)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConfigurationServiceServer).SetProperty(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/dendrite_config.ConfigurationService/SetProperty",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConfigurationServiceServer).SetProperty(ctx, req.(*KeyValue))
	}
	return interceptor(ctx, in, info, handler)
}

var _ConfigurationService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "dendrite_config.ConfigurationService",
	HandlerType: (*ConfigurationServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SetPrivateKey",
			Handler:    _ConfigurationService_SetPrivateKey_Handler,
		},
		{
			MethodName: "Authorize",
			Handler:    _ConfigurationService_Authorize_Handler,
		},
		{
			MethodName: "SetProperty",
			Handler:    _ConfigurationService_SetProperty_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ListTrustedKeys",
			Handler:       _ConfigurationService_ListTrustedKeys_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ChangeTrustedKeys",
			Handler:       _ConfigurationService_ChangeTrustedKeys_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "ChangeCredentials",
			Handler:       _ConfigurationService_ChangeCredentials_Handler,
			ClientStreams: true,
		},
	},
	Metadata: "dendrite_config.proto",
}