text:
package api

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

const (
	Cmd_Privmsg Cmd_Kind = 0
	Cmd_Notice  Cmd_Kind = 1
	Cmd_AnyKind Cmd_Kind = 2
)

var Cmd_Kind_name = map[int32]string{
	0: "Privmsg",
	1: "Notice",
	2: "AnyKind",
}

var Cmd_Kind_value = map[string]int32{
	"Privmsg": 0,
	"Notice":  1,
	"AnyKind": 2,
}

func (x Cmd_Kind) String() string {
	return proto.EnumName(Cmd_Kind_name, int32(x))
}

func (Cmd_Kind) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{25, 0}
}

type Cmd_Scope int32

const (
	Cmd_Private  Cmd_Scope = 0
	Cmd_Public   Cmd_Scope = 1
	Cmd_AnyScope Cmd_Scope = 2
)

var Cmd_Scope_name = map[int32]string{
	0: "Private",
	1: "Public",
	2: "AnyScope",
}

var Cmd_Scope_value = map[string]int32{
	"Private":  0,
	"Public":   1,
	"AnyScope": 2,
}

func (x Cmd_Scope) String() string {
	return proto.EnumName(Cmd_Scope_name, int32(x))
}

func (Cmd_Scope) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{25, 1}
}

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_dd1789c19b148ca6, []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 Result struct {
	Ok                   bool     `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Result proto.InternalMessageInfo

func (m *Result) GetOk() bool {
	if m != nil {
		return m.Ok
	}
	return false
}

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

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

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

var xxx_messageInfo_Query proto.InternalMessageInfo

func (m *Query) GetQuery() string {
	if m != nil {
		return m.Query
	}
	return ""
}

type ListResponse struct {
	List                 []string `protobuf:"bytes,1,rep,name=list,proto3" json:"list,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ListResponse proto.InternalMessageInfo

func (m *ListResponse) GetList() []string {
	if m != nil {
		return m.List
	}
	return nil
}

type CountResponse struct {
	Count                int32    `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CountResponse proto.InternalMessageInfo

func (m *CountResponse) GetCount() int32 {
	if m != nil {
		return m.Count
	}
	return 0
}

type Access struct {
	Level                uint32   `protobuf:"varint,1,opt,name=level,proto3" json:"level,omitempty"`
	Flags                uint64   `protobuf:"varint,2,opt,name=flags,proto3" json:"flags,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Access proto.InternalMessageInfo

func (m *Access) GetLevel() uint32 {
	if m != nil {
		return m.Level
	}
	return 0
}

func (m *Access) GetFlags() uint64 {
	if m != nil {
		return m.Flags
	}
	return 0
}

type ChannelModes struct {
	Modes                map[string]bool                      `protobuf:"bytes,1,rep,name=modes,proto3" json:"modes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	ArgModes             map[string]string                    `protobuf:"bytes,2,rep,name=arg_modes,json=argModes,proto3" json:"arg_modes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	AddressModes         map[string]*ChannelModes_AddressMode `protobuf:"bytes,3,rep,name=address_modes,json=addressModes,proto3" json:"address_modes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Addresses            int32                                `protobuf:"varint,4,opt,name=addresses,proto3" json:"addresses,omitempty"`
	Kinds                *ModeKinds                           `protobuf:"bytes,5,opt,name=kinds,proto3" json:"kinds,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                             `json:"-"`
	XXX_unrecognized     []byte                               `json:"-"`
	XXX_sizecache        int32                                `json:"-"`
}

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

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

var xxx_messageInfo_ChannelModes proto.InternalMessageInfo

func (m *ChannelModes) GetModes() map[string]bool {
	if m != nil {
		return m.Modes
	}
	return nil
}

func (m *ChannelModes) GetArgModes() map[string]string {
	if m != nil {
		return m.ArgModes
	}
	return nil
}

func (m *ChannelModes) GetAddressModes() map[string]*ChannelModes_AddressMode {
	if m != nil {
		return m.AddressModes
	}
	return nil
}

func (m *ChannelModes) GetAddresses() int32 {
	if m != nil {
		return m.Addresses
	}
	return 0
}

func (m *ChannelModes) GetKinds() *ModeKinds {
	if m != nil {
		return m.Kinds
	}
	return nil
}

type ChannelModes_AddressMode struct {
	ModeAddresses        []string `protobuf:"bytes,1,rep,name=mode_addresses,json=modeAddresses,proto3" json:"mode_addresses,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ChannelModes_AddressMode proto.InternalMessageInfo

func (m *ChannelModes_AddressMode) GetModeAddresses() []string {
	if m != nil {
		return m.ModeAddresses
	}
	return nil
}

type StateUser struct {
	Host                 string   `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"`
	Realname             string   `protobuf:"bytes,2,opt,name=realname,proto3" json:"realname,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StateUser) Reset()         { *m = StateUser{} }
func (m *StateUser) String() string { return proto.CompactTextString(m) }
func (*StateUser) ProtoMessage()    {}
func (*StateUser) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{7}
}

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

var xxx_messageInfo_StateUser proto.InternalMessageInfo

func (m *StateUser) GetHost() string {
	if m != nil {
		return m.Host
	}
	return ""
}

func (m *StateUser) GetRealname() string {
	if m != nil {
		return m.Realname
	}
	return ""
}

type StateChannel struct {
	Name                 string        `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Topic                string        `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"`
	Modes                *ChannelModes `protobuf:"bytes,3,opt,name=modes,proto3" json:"modes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_StateChannel proto.InternalMessageInfo

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

func (m *StateChannel) GetTopic() string {
	if m != nil {
		return m.Topic
	}
	return ""
}

func (m *StateChannel) GetModes() *ChannelModes {
	if m != nil {
		return m.Modes
	}
	return nil
}

type UserModes struct {
	Kinds                *ModeKinds `protobuf:"bytes,1,opt,name=kinds,proto3" json:"kinds,omitempty"`
	Modes                int32      `protobuf:"varint,2,opt,name=modes,proto3" json:"modes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *UserModes) Reset()         { *m = UserModes{} }
func (m *UserModes) String() string { return proto.CompactTextString(m) }
func (*UserModes) ProtoMessage()    {}
func (*UserModes) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{9}
}

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

var xxx_messageInfo_UserModes proto.InternalMessageInfo

func (m *UserModes) GetKinds() *ModeKinds {
	if m != nil {
		return m.Kinds
	}
	return nil
}

func (m *UserModes) GetModes() int32 {
	if m != nil {
		return m.Modes
	}
	return 0
}

type ModeKinds struct {
	UserPrefixes         []*ModeKinds_UserPrefix `protobuf:"bytes,1,rep,name=user_prefixes,json=userPrefixes,proto3" json:"user_prefixes,omitempty"`
	ChannelModes         map[string]int32        `protobuf:"bytes,2,rep,name=channel_modes,json=channelModes,proto3" json:"channel_modes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_ModeKinds proto.InternalMessageInfo

func (m *ModeKinds) GetUserPrefixes() []*ModeKinds_UserPrefix {
	if m != nil {
		return m.UserPrefixes
	}
	return nil
}

func (m *ModeKinds) GetChannelModes() map[string]int32 {
	if m != nil {
		return m.ChannelModes
	}
	return nil
}

type ModeKinds_UserPrefix struct {
	Symbol               string   `protobuf:"bytes,1,opt,name=symbol,proto3" json:"symbol,omitempty"`
	Char                 string   `protobuf:"bytes,2,opt,name=char,proto3" json:"char,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ModeKinds_UserPrefix proto.InternalMessageInfo

func (m *ModeKinds_UserPrefix) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

func (m *ModeKinds_UserPrefix) GetChar() string {
	if m != nil {
		return m.Char
	}
	return ""
}

type NetworkInfo struct {
	ServerName           string            `protobuf:"bytes,1,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
	IrcdVersion          string            `protobuf:"bytes,2,opt,name=ircd_version,json=ircdVersion,proto3" json:"ircd_version,omitempty"`
	Usermodes            string            `protobuf:"bytes,3,opt,name=usermodes,proto3" json:"usermodes,omitempty"`
	Lchanmodes           string            `protobuf:"bytes,4,opt,name=lchanmodes,proto3" json:"lchanmodes,omitempty"`
	Rfc                  string            `protobuf:"bytes,5,opt,name=rfc,proto3" json:"rfc,omitempty"`
	Ircd                 string            `protobuf:"bytes,6,opt,name=ircd,proto3" json:"ircd,omitempty"`
	Casemapping          string            `protobuf:"bytes,7,opt,name=casemapping,proto3" json:"casemapping,omitempty"`
	Prefix               string            `protobuf:"bytes,8,opt,name=prefix,proto3" json:"prefix,omitempty"`
	Chantypes            string            `protobuf:"bytes,9,opt,name=chantypes,proto3" json:"chantypes,omitempty"`
	Chanmodes            string            `protobuf:"bytes,10,opt,name=chanmodes,proto3" json:"chanmodes,omitempty"`
	Chanlimit            int32             `protobuf:"varint,11,opt,name=chanlimit,proto3" json:"chanlimit,omitempty"`
	Channellen           int32             `protobuf:"varint,12,opt,name=channellen,proto3" json:"channellen,omitempty"`
	Nicklen              int32             `protobuf:"varint,13,opt,name=nicklen,proto3" json:"nicklen,omitempty"`
	Topiclen             int32             `protobuf:"varint,14,opt,name=topiclen,proto3" json:"topiclen,omitempty"`
	Awaylen              int32             `protobuf:"varint,15,opt,name=awaylen,proto3" json:"awaylen,omitempty"`
	Kicklen              int32             `protobuf:"varint,16,opt,name=kicklen,proto3" json:"kicklen,omitempty"`
	Modes                int32             `protobuf:"varint,17,opt,name=modes,proto3" json:"modes,omitempty"`
	Extras               map[string]string `protobuf:"bytes,18,rep,name=extras,proto3" json:"extras,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 *NetworkInfo) Reset()         { *m = NetworkInfo{} }
func (m *NetworkInfo) String() string { return proto.CompactTextString(m) }
func (*NetworkInfo) ProtoMessage()    {}
func (*NetworkInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{11}
}

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

var xxx_messageInfo_NetworkInfo proto.InternalMessageInfo

func (m *NetworkInfo) GetServerName() string {
	if m != nil {
		return m.ServerName
	}
	return ""
}

func (m *NetworkInfo) GetIrcdVersion() string {
	if m != nil {
		return m.IrcdVersion
	}
	return ""
}

func (m *NetworkInfo) GetUsermodes() string {
	if m != nil {
		return m.Usermodes
	}
	return ""
}

func (m *NetworkInfo) GetLchanmodes() string {
	if m != nil {
		return m.Lchanmodes
	}
	return ""
}

func (m *NetworkInfo) GetRfc() string {
	if m != nil {
		return m.Rfc
	}
	return ""
}

func (m *NetworkInfo) GetIrcd() string {
	if m != nil {
		return m.Ircd
	}
	return ""
}

func (m *NetworkInfo) GetCasemapping() string {
	if m != nil {
		return m.Casemapping
	}
	return ""
}

func (m *NetworkInfo) GetPrefix() string {
	if m != nil {
		return m.Prefix
	}
	return ""
}

func (m *NetworkInfo) GetChantypes() string {
	if m != nil {
		return m.Chantypes
	}
	return ""
}

func (m *NetworkInfo) GetChanmodes() string {
	if m != nil {
		return m.Chanmodes
	}
	return ""
}

func (m *NetworkInfo) GetChanlimit() int32 {
	if m != nil {
		return m.Chanlimit
	}
	return 0
}

func (m *NetworkInfo) GetChannellen() int32 {
	if m != nil {
		return m.Channellen
	}
	return 0
}

func (m *NetworkInfo) GetNicklen() int32 {
	if m != nil {
		return m.Nicklen
	}
	return 0
}

func (m *NetworkInfo) GetTopiclen() int32 {
	if m != nil {
		return m.Topiclen
	}
	return 0
}

func (m *NetworkInfo) GetAwaylen() int32 {
	if m != nil {
		return m.Awaylen
	}
	return 0
}

func (m *NetworkInfo) GetKicklen() int32 {
	if m != nil {
		return m.Kicklen
	}
	return 0
}

func (m *NetworkInfo) GetModes() int32 {
	if m != nil {
		return m.Modes
	}
	return 0
}

func (m *NetworkInfo) GetExtras() map[string]string {
	if m != nil {
		return m.Extras
	}
	return nil
}

type StoredUser struct {
	Username             string             `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"`
	Password             []byte             `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
	Masks                []string           `protobuf:"bytes,3,rep,name=masks,proto3" json:"masks,omitempty"`
	Access               map[string]*Access `protobuf:"bytes,4,rep,name=access,proto3" json:"access,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Data                 map[string]string  `protobuf:"bytes,5,rep,name=data,proto3" json:"data,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 *StoredUser) Reset()         { *m = StoredUser{} }
func (m *StoredUser) String() string { return proto.CompactTextString(m) }
func (*StoredUser) ProtoMessage()    {}
func (*StoredUser) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{12}
}

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

var xxx_messageInfo_StoredUser proto.InternalMessageInfo

func (m *StoredUser) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

func (m *StoredUser) GetPassword() []byte {
	if m != nil {
		return m.Password
	}
	return nil
}

func (m *StoredUser) GetMasks() []string {
	if m != nil {
		return m.Masks
	}
	return nil
}

func (m *StoredUser) GetAccess() map[string]*Access {
	if m != nil {
		return m.Access
	}
	return nil
}

func (m *StoredUser) GetData() map[string]string {
	if m != nil {
		return m.Data
	}
	return nil
}

type StoredChannel struct {
	Net                  string            `protobuf:"bytes,1,opt,name=net,proto3" json:"net,omitempty"`
	Name                 string            `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Data                 map[string]string `protobuf:"bytes,3,rep,name=data,proto3" json:"data,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 *StoredChannel) Reset()         { *m = StoredChannel{} }
func (m *StoredChannel) String() string { return proto.CompactTextString(m) }
func (*StoredChannel) ProtoMessage()    {}
func (*StoredChannel) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{13}
}

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

var xxx_messageInfo_StoredChannel proto.InternalMessageInfo

func (m *StoredChannel) GetNet() string {
	if m != nil {
		return m.Net
	}
	return ""
}

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

func (m *StoredChannel) GetData() map[string]string {
	if m != nil {
		return m.Data
	}
	return nil
}

type SelfResponse struct {
	User                 *StateUser    `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
	Modes                *ChannelModes `protobuf:"bytes,2,opt,name=modes,proto3" json:"modes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_SelfResponse proto.InternalMessageInfo

func (m *SelfResponse) GetUser() *StateUser {
	if m != nil {
		return m.User
	}
	return nil
}

func (m *SelfResponse) GetModes() *ChannelModes {
	if m != nil {
		return m.Modes
	}
	return nil
}

type NetworkQuery struct {
	Net                  string   `protobuf:"bytes,1,opt,name=net,proto3" json:"net,omitempty"`
	Query                string   `protobuf:"bytes,2,opt,name=query,proto3" json:"query,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_NetworkQuery proto.InternalMessageInfo

func (m *NetworkQuery) GetNet() string {
	if m != nil {
		return m.Net
	}
	return ""
}

func (m *NetworkQuery) GetQuery() string {
	if m != nil {
		return m.Query
	}
	return ""
}

type ChannelQuery struct {
	Net                  string   `protobuf:"bytes,1,opt,name=net,proto3" json:"net,omitempty"`
	Channel              string   `protobuf:"bytes,2,opt,name=channel,proto3" json:"channel,omitempty"`
	Query                string   `protobuf:"bytes,3,opt,name=query,proto3" json:"query,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ChannelQuery proto.InternalMessageInfo

func (m *ChannelQuery) GetNet() string {
	if m != nil {
		return m.Net
	}
	return ""
}

func (m *ChannelQuery) GetChannel() string {
	if m != nil {
		return m.Channel
	}
	return ""
}

func (m *ChannelQuery) GetQuery() string {
	if m != nil {
		return m.Query
	}
	return ""
}

type AuthUserRequest struct {
	Net                  string   `protobuf:"bytes,1,opt,name=net,proto3" json:"net,omitempty"`
	Host                 string   `protobuf:"bytes,2,opt,name=host,proto3" json:"host,omitempty"`
	Username             string   `protobuf:"bytes,3,opt,name=username,proto3" json:"username,omitempty"`
	Password             string   `protobuf:"bytes,4,opt,name=password,proto3" json:"password,omitempty"`
	Permanent            bool     `protobuf:"varint,5,opt,name=permanent,proto3" json:"permanent,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_AuthUserRequest proto.InternalMessageInfo

func (m *AuthUserRequest) GetNet() string {
	if m != nil {
		return m.Net
	}
	return ""
}

func (m *AuthUserRequest) GetHost() string {
	if m != nil {
		return m.Host
	}
	return ""
}

func (m *AuthUserRequest) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

func (m *AuthUserRequest) GetPassword() string {
	if m != nil {
		return m.Password
	}
	return ""
}

func (m *AuthUserRequest) GetPermanent() bool {
	if m != nil {
		return m.Permanent
	}
	return false
}

type UserResponse struct {
	Self                 *StateUser `protobuf:"bytes,1,opt,name=self,proto3" json:"self,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

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

var xxx_messageInfo_UserResponse proto.InternalMessageInfo

func (m *UserResponse) GetSelf() *StateUser {
	if m != nil {
		return m.Self
	}
	return nil
}

type UserModesResponse struct {
	Modes                *ChannelModes `protobuf:"bytes,1,opt,name=modes,proto3" json:"modes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_UserModesResponse proto.InternalMessageInfo

func (m *UserModesResponse) GetModes() *ChannelModes {
	if m != nil {
		return m.Modes
	}
	return nil
}

type ChannelResponse struct {
	Name                 string        `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Topic                string        `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"`
	Modes                *ChannelModes `protobuf:"bytes,3,opt,name=modes,proto3" json:"modes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_ChannelResponse proto.InternalMessageInfo

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

func (m *ChannelResponse) GetTopic() string {
	if m != nil {
		return m.Topic
	}
	return ""
}

func (m *ChannelResponse) GetModes() *ChannelModes {
	if m != nil {
		return m.Modes
	}
	return nil
}

type StoredUsersResponse struct {
	Users                []*StoredUser `protobuf:"bytes,1,rep,name=users,proto3" json:"users,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_StoredUsersResponse proto.InternalMessageInfo

func (m *StoredUsersResponse) GetUsers() []*StoredUser {
	if m != nil {
		return m.Users
	}
	return nil
}

type StoredChannelsResponse struct {
	Channels             []*StoredChannel `protobuf:"bytes,1,rep,name=channels,proto3" json:"channels,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *StoredChannelsResponse) Reset()         { *m = StoredChannelsResponse{} }
func (m *StoredChannelsResponse) String() string { return proto.CompactTextString(m) }
func (*StoredChannelsResponse) ProtoMessage()    {}
func (*StoredChannelsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{22}
}

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

var xxx_messageInfo_StoredChannelsResponse proto.InternalMessageInfo

func (m *StoredChannelsResponse) GetChannels() []*StoredChannel {
	if m != nil {
		return m.Channels
	}
	return nil
}

type LogoutRequest struct {
	// Types that are valid to be assigned to Query:
	//	*LogoutRequest_HostUser_
	//	*LogoutRequest_Username
	Query                isLogoutRequest_Query `protobuf_oneof:"query"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *LogoutRequest) Reset()         { *m = LogoutRequest{} }
func (m *LogoutRequest) String() string { return proto.CompactTextString(m) }
func (*LogoutRequest) ProtoMessage()    {}
func (*LogoutRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{23}
}

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

var xxx_messageInfo_LogoutRequest proto.InternalMessageInfo

type isLogoutRequest_Query interface {
	isLogoutRequest_Query()
}

type LogoutRequest_HostUser_ struct {
	HostUser *LogoutRequest_HostUser `protobuf:"bytes,1,opt,name=host_user,json=hostUser,proto3,oneof"`
}

type LogoutRequest_Username struct {
	Username string `protobuf:"bytes,2,opt,name=username,proto3,oneof"`
}

func (*LogoutRequest_HostUser_) isLogoutRequest_Query() {}

func (*LogoutRequest_Username) isLogoutRequest_Query() {}

func (m *LogoutRequest) GetQuery() isLogoutRequest_Query {
	if m != nil {
		return m.Query
	}
	return nil
}

func (m *LogoutRequest) GetHostUser() *LogoutRequest_HostUser {
	if x, ok := m.GetQuery().(*LogoutRequest_HostUser_); ok {
		return x.HostUser
	}
	return nil
}

func (m *LogoutRequest) GetUsername() string {
	if x, ok := m.GetQuery().(*LogoutRequest_Username); ok {
		return x.Username
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*LogoutRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*LogoutRequest_HostUser_)(nil),
		(*LogoutRequest_Username)(nil),
	}
}

type LogoutRequest_HostUser struct {
	Net                  string   `protobuf:"bytes,1,opt,name=net,proto3" json:"net,omitempty"`
	Host                 string   `protobuf:"bytes,2,opt,name=host,proto3" json:"host,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LogoutRequest_HostUser) Reset()         { *m = LogoutRequest_HostUser{} }
func (m *LogoutRequest_HostUser) String() string { return proto.CompactTextString(m) }
func (*LogoutRequest_HostUser) ProtoMessage()    {}
func (*LogoutRequest_HostUser) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{23, 0}
}

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

var xxx_messageInfo_LogoutRequest_HostUser proto.InternalMessageInfo

func (m *LogoutRequest_HostUser) GetNet() string {
	if m != nil {
		return m.Net
	}
	return ""
}

func (m *LogoutRequest_HostUser) GetHost() string {
	if m != nil {
		return m.Host
	}
	return ""
}

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

func (m *NetworkInfoRequest) Reset()         { *m = NetworkInfoRequest{} }
func (m *NetworkInfoRequest) String() string { return proto.CompactTextString(m) }
func (*NetworkInfoRequest) ProtoMessage()    {}
func (*NetworkInfoRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{24}
}

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

var xxx_messageInfo_NetworkInfoRequest proto.InternalMessageInfo

func (m *NetworkInfoRequest) GetNet() string {
	if m != nil {
		return m.Net
	}
	return ""
}

type Cmd struct {
	Ext                  string    `protobuf:"bytes,1,opt,name=ext,proto3" json:"ext,omitempty"`
	Name                 string    `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Desc                 string    `protobuf:"bytes,3,opt,name=desc,proto3" json:"desc,omitempty"`
	Kind                 Cmd_Kind  `protobuf:"varint,4,opt,name=kind,proto3,enum=api.Cmd_Kind" json:"kind,omitempty"`
	Scope                Cmd_Scope `protobuf:"varint,5,opt,name=scope,proto3,enum=api.Cmd_Scope" json:"scope,omitempty"`
	Args                 []string  `protobuf:"bytes,6,rep,name=args,proto3" json:"args,omitempty"`
	RequireAuth          bool      `protobuf:"varint,7,opt,name=require_auth,json=requireAuth,proto3" json:"require_auth,omitempty"`
	ReqLevel             int32     `protobuf:"varint,8,opt,name=req_level,json=reqLevel,proto3" json:"req_level,omitempty"`
	ReqFlags             string    `protobuf:"bytes,9,opt,name=req_flags,json=reqFlags,proto3" json:"req_flags,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *Cmd) Reset()         { *m = Cmd{} }
func (m *Cmd) String() string { return proto.CompactTextString(m) }
func (*Cmd) ProtoMessage()    {}
func (*Cmd) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{25}
}

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

var xxx_messageInfo_Cmd proto.InternalMessageInfo

func (m *Cmd) GetExt() string {
	if m != nil {
		return m.Ext
	}
	return ""
}

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

func (m *Cmd) GetDesc() string {
	if m != nil {
		return m.Desc
	}
	return ""
}

func (m *Cmd) GetKind() Cmd_Kind {
	if m != nil {
		return m.Kind
	}
	return Cmd_Privmsg
}

func (m *Cmd) GetScope() Cmd_Scope {
	if m != nil {
		return m.Scope
	}
	return Cmd_Private
}

func (m *Cmd) GetArgs() []string {
	if m != nil {
		return m.Args
	}
	return nil
}

func (m *Cmd) GetRequireAuth() bool {
	if m != nil {
		return m.RequireAuth
	}
	return false
}

func (m *Cmd) GetReqLevel() int32 {
	if m != nil {
		return m.ReqLevel
	}
	return 0
}

func (m *Cmd) GetReqFlags() string {
	if m != nil {
		return m.ReqFlags
	}
	return ""
}

type CmdEvent struct {
	IrcEvent                  *IRCEvent              `protobuf:"bytes,1,opt,name=ircEvent,proto3" json:"ircEvent,omitempty"`
	User                      *StateUser             `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
	StoredUser                *StoredUser            `protobuf:"bytes,3,opt,name=storedUser,proto3" json:"storedUser,omitempty"`
	UserChanModes             *UserModes             `protobuf:"bytes,4,opt,name=userChanModes,proto3" json:"userChanModes,omitempty"`
	Channel                   *StateChannel          `protobuf:"bytes,5,opt,name=channel,proto3" json:"channel,omitempty"`
	TargetChannel             *StateChannel          `protobuf:"bytes,6,opt,name=targetChannel,proto3" json:"targetChannel,omitempty"`
	TargetUsers               map[string]*StateUser  `protobuf:"bytes,7,rep,name=targetUsers,proto3" json:"targetUsers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	TargetStoredUsers         map[string]*StoredUser `protobuf:"bytes,8,rep,name=targetStoredUsers,proto3" json:"targetStoredUsers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	TargetVariadicUsers       []*StateUser           `protobuf:"bytes,9,rep,name=targetVariadicUsers,proto3" json:"targetVariadicUsers,omitempty"`
	TargetVariadicStoredUsers []*StoredUser          `protobuf:"bytes,10,rep,name=targetVariadicStoredUsers,proto3" json:"targetVariadicStoredUsers,omitempty"`
	Args                      map[string]string      `protobuf:"bytes,11,rep,name=args,proto3" json:"args,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 *CmdEvent) Reset()         { *m = CmdEvent{} }
func (m *CmdEvent) String() string { return proto.CompactTextString(m) }
func (*CmdEvent) ProtoMessage()    {}
func (*CmdEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{26}
}

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

var xxx_messageInfo_CmdEvent proto.InternalMessageInfo

func (m *CmdEvent) GetIrcEvent() *IRCEvent {
	if m != nil {
		return m.IrcEvent
	}
	return nil
}

func (m *CmdEvent) GetUser() *StateUser {
	if m != nil {
		return m.User
	}
	return nil
}

func (m *CmdEvent) GetStoredUser() *StoredUser {
	if m != nil {
		return m.StoredUser
	}
	return nil
}

func (m *CmdEvent) GetUserChanModes() *UserModes {
	if m != nil {
		return m.UserChanModes
	}
	return nil
}

func (m *CmdEvent) GetChannel() *StateChannel {
	if m != nil {
		return m.Channel
	}
	return nil
}

func (m *CmdEvent) GetTargetChannel() *StateChannel {
	if m != nil {
		return m.TargetChannel
	}
	return nil
}

func (m *CmdEvent) GetTargetUsers() map[string]*StateUser {
	if m != nil {
		return m.TargetUsers
	}
	return nil
}

func (m *CmdEvent) GetTargetStoredUsers() map[string]*StoredUser {
	if m != nil {
		return m.TargetStoredUsers
	}
	return nil
}

func (m *CmdEvent) GetTargetVariadicUsers() []*StateUser {
	if m != nil {
		return m.TargetVariadicUsers
	}
	return nil
}

func (m *CmdEvent) GetTargetVariadicStoredUsers() []*StoredUser {
	if m != nil {
		return m.TargetVariadicStoredUsers
	}
	return nil
}

func (m *CmdEvent) GetArgs() map[string]string {
	if m != nil {
		return m.Args
	}
	return nil
}

type CmdEventResponse struct {
	Id                   uint64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name                 string    `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Event                *CmdEvent `protobuf:"bytes,3,opt,name=event,proto3" json:"event,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *CmdEventResponse) Reset()         { *m = CmdEventResponse{} }
func (m *CmdEventResponse) String() string { return proto.CompactTextString(m) }
func (*CmdEventResponse) ProtoMessage()    {}
func (*CmdEventResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{27}
}

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

var xxx_messageInfo_CmdEventResponse proto.InternalMessageInfo

func (m *CmdEventResponse) GetId() uint64 {
	if m != nil {
		return m.Id
	}
	return 0
}

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

func (m *CmdEventResponse) GetEvent() *CmdEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type IRCEventResponse struct {
	Id                   uint64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Event                *IRCEvent `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *IRCEventResponse) Reset()         { *m = IRCEventResponse{} }
func (m *IRCEventResponse) String() string { return proto.CompactTextString(m) }
func (*IRCEventResponse) ProtoMessage()    {}
func (*IRCEventResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{28}
}

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

var xxx_messageInfo_IRCEventResponse proto.InternalMessageInfo

func (m *IRCEventResponse) GetId() uint64 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *IRCEventResponse) GetEvent() *IRCEvent {
	if m != nil {
		return m.Event
	}
	return nil
}

type IRCEvent struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Sender               string   `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty"`
	Args                 []string `protobuf:"bytes,3,rep,name=args,proto3" json:"args,omitempty"`
	Time                 int64    `protobuf:"varint,4,opt,name=time,proto3" json:"time,omitempty"`
	Net                  string   `protobuf:"bytes,5,opt,name=net,proto3" json:"net,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *IRCEvent) Reset()         { *m = IRCEvent{} }
func (m *IRCEvent) String() string { return proto.CompactTextString(m) }
func (*IRCEvent) ProtoMessage()    {}
func (*IRCEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{29}
}

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

var xxx_messageInfo_IRCEvent proto.InternalMessageInfo

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

func (m *IRCEvent) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *IRCEvent) GetArgs() []string {
	if m != nil {
		return m.Args
	}
	return nil
}

func (m *IRCEvent) GetTime() int64 {
	if m != nil {
		return m.Time
	}
	return 0
}

func (m *IRCEvent) GetNet() string {
	if m != nil {
		return m.Net
	}
	return ""
}

type RegisterCmdRequest struct {
	Ext                  string   `protobuf:"bytes,1,opt,name=ext,proto3" json:"ext,omitempty"`
	Network              string   `protobuf:"bytes,2,opt,name=network,proto3" json:"network,omitempty"`
	Channel              string   `protobuf:"bytes,3,opt,name=channel,proto3" json:"channel,omitempty"`
	Cmd                  *Cmd     `protobuf:"bytes,4,opt,name=cmd,proto3" json:"cmd,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RegisterCmdRequest) Reset()         { *m = RegisterCmdRequest{} }
func (m *RegisterCmdRequest) String() string { return proto.CompactTextString(m) }
func (*RegisterCmdRequest) ProtoMessage()    {}
func (*RegisterCmdRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{30}
}

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

var xxx_messageInfo_RegisterCmdRequest proto.InternalMessageInfo

func (m *RegisterCmdRequest) GetExt() string {
	if m != nil {
		return m.Ext
	}
	return ""
}

func (m *RegisterCmdRequest) GetNetwork() string {
	if m != nil {
		return m.Network
	}
	return ""
}

func (m *RegisterCmdRequest) GetChannel() string {
	if m != nil {
		return m.Channel
	}
	return ""
}

func (m *RegisterCmdRequest) GetCmd() *Cmd {
	if m != nil {
		return m.Cmd
	}
	return nil
}

type RegisterRequest struct {
	Ext                  string   `protobuf:"bytes,1,opt,name=ext,proto3" json:"ext,omitempty"`
	Network              string   `protobuf:"bytes,2,opt,name=network,proto3" json:"network,omitempty"`
	Channel              string   `protobuf:"bytes,3,opt,name=channel,proto3" json:"channel,omitempty"`
	Event                string   `protobuf:"bytes,4,opt,name=event,proto3" json:"event,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RegisterRequest) Reset()         { *m = RegisterRequest{} }
func (m *RegisterRequest) String() string { return proto.CompactTextString(m) }
func (*RegisterRequest) ProtoMessage()    {}
func (*RegisterRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{31}
}

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

var xxx_messageInfo_RegisterRequest proto.InternalMessageInfo

func (m *RegisterRequest) GetExt() string {
	if m != nil {
		return m.Ext
	}
	return ""
}

func (m *RegisterRequest) GetNetwork() string {
	if m != nil {
		return m.Network
	}
	return ""
}

func (m *RegisterRequest) GetChannel() string {
	if m != nil {
		return m.Channel
	}
	return ""
}

func (m *RegisterRequest) GetEvent() string {
	if m != nil {
		return m.Event
	}
	return ""
}

type RegisterResponse struct {
	Id                   uint64   `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RegisterResponse) Reset()         { *m = RegisterResponse{} }
func (m *RegisterResponse) String() string { return proto.CompactTextString(m) }
func (*RegisterResponse) ProtoMessage()    {}
func (*RegisterResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{32}
}

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

var xxx_messageInfo_RegisterResponse proto.InternalMessageInfo

func (m *RegisterResponse) GetId() uint64 {
	if m != nil {
		return m.Id
	}
	return 0
}

type SubscriptionRequest struct {
	// The extension name that
	Ext string `protobuf:"bytes,1,opt,name=ext,proto3" json:"ext,omitempty"`
	// The event or command ids to receive in this subscription, may be omitted
	// to recieve all events registered to the extension named by ext.
	Ids                  []uint64 `protobuf:"varint,2,rep,packed,name=ids,proto3" json:"ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SubscriptionRequest) Reset()         { *m = SubscriptionRequest{} }
func (m *SubscriptionRequest) String() string { return proto.CompactTextString(m) }
func (*SubscriptionRequest) ProtoMessage()    {}
func (*SubscriptionRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{33}
}

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

var xxx_messageInfo_SubscriptionRequest proto.InternalMessageInfo

func (m *SubscriptionRequest) GetExt() string {
	if m != nil {
		return m.Ext
	}
	return ""
}

func (m *SubscriptionRequest) GetIds() []uint64 {
	if m != nil {
		return m.Ids
	}
	return nil
}

type UnregisterRequest struct {
	Ext                  string   `protobuf:"bytes,1,opt,name=ext,proto3" json:"ext,omitempty"`
	Id                   uint64   `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UnregisterRequest) Reset()         { *m = UnregisterRequest{} }
func (m *UnregisterRequest) String() string { return proto.CompactTextString(m) }
func (*UnregisterRequest) ProtoMessage()    {}
func (*UnregisterRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{34}
}

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

var xxx_messageInfo_UnregisterRequest proto.InternalMessageInfo

func (m *UnregisterRequest) GetExt() string {
	if m != nil {
		return m.Ext
	}
	return ""
}

func (m *UnregisterRequest) GetId() uint64 {
	if m != nil {
		return m.Id
	}
	return 0
}

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

func (m *UnregisterAllRequest) Reset()         { *m = UnregisterAllRequest{} }
func (m *UnregisterAllRequest) String() string { return proto.CompactTextString(m) }
func (*UnregisterAllRequest) ProtoMessage()    {}
func (*UnregisterAllRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{35}
}

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

var xxx_messageInfo_UnregisterAllRequest proto.InternalMessageInfo

func (m *UnregisterAllRequest) GetExt() string {
	if m != nil {
		return m.Ext
	}
	return ""
}

// Write raw irc data directly to a network
type WriteRequest struct {
	Ext                  string   `protobuf:"bytes,1,opt,name=ext,proto3" json:"ext,omitempty"`
	Net                  string   `protobuf:"bytes,2,opt,name=net,proto3" json:"net,omitempty"`
	Msg                  []byte   `protobuf:"bytes,3,opt,name=msg,proto3" json:"msg,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *WriteRequest) Reset()         { *m = WriteRequest{} }
func (m *WriteRequest) String() string { return proto.CompactTextString(m) }
func (*WriteRequest) ProtoMessage()    {}
func (*WriteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_dd1789c19b148ca6, []int{36}
}

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

var xxx_messageInfo_WriteRequest proto.InternalMessageInfo

func (m *WriteRequest) GetExt() string {
	if m != nil {
		return m.Ext
	}
	return ""
}

func (m *WriteRequest) GetNet() string {
	if m != nil {
		return m.Net
	}
	return ""
}

func (m *WriteRequest) GetMsg() []byte {
	if m != nil {
		return m.Msg
	}
	return nil
}

func init() {
	proto.RegisterEnum("api.Cmd_Kind", Cmd_Kind_name, Cmd_Kind_value)
	proto.RegisterEnum("api.Cmd_Scope", Cmd_Scope_name, Cmd_Scope_value)
	proto.RegisterType((*Empty)(nil), "api.Empty")
	proto.RegisterType((*Result)(nil), "api.Result")
	proto.RegisterType((*Query)(nil), "api.Query")
	proto.RegisterType((*ListResponse)(nil), "api.ListResponse")
	proto.RegisterType((*CountResponse)(nil), "api.CountResponse")
	proto.RegisterType((*Access)(nil), "api.Access")
	proto.RegisterType((*ChannelModes)(nil), "api.ChannelModes")
	proto.RegisterMapType((map[string]*ChannelModes_AddressMode)(nil), "api.ChannelModes.AddressModesEntry")
	proto.RegisterMapType((map[string]string)(nil), "api.ChannelModes.ArgModesEntry")
	proto.RegisterMapType((map[string]bool)(nil), "api.ChannelModes.ModesEntry")
	proto.RegisterType((*ChannelModes_AddressMode)(nil), "api.ChannelModes.AddressMode")
	proto.RegisterType((*StateUser)(nil), "api.StateUser")
	proto.RegisterType((*StateChannel)(nil), "api.StateChannel")
	proto.RegisterType((*UserModes)(nil), "api.UserModes")
	proto.RegisterType((*ModeKinds)(nil), "api.ModeKinds")
	proto.RegisterMapType((map[string]int32)(nil), "api.ModeKinds.ChannelModesEntry")
	proto.RegisterType((*ModeKinds_UserPrefix)(nil), "api.ModeKinds.UserPrefix")
	proto.RegisterType((*NetworkInfo)(nil), "api.NetworkInfo")
	proto.RegisterMapType((map[string]string)(nil), "api.NetworkInfo.ExtrasEntry")
	proto.RegisterType((*StoredUser)(nil), "api.StoredUser")
	proto.RegisterMapType((map[string]*Access)(nil), "api.StoredUser.AccessEntry")
	proto.RegisterMapType((map[string]string)(nil), "api.StoredUser.DataEntry")
	proto.RegisterType((*StoredChannel)(nil), "api.StoredChannel")
	proto.RegisterMapType((map[string]string)(nil), "api.StoredChannel.DataEntry")
	proto.RegisterType((*SelfResponse)(nil), "api.SelfResponse")
	proto.RegisterType((*NetworkQuery)(nil), "api.NetworkQuery")
	proto.RegisterType((*ChannelQuery)(nil), "api.ChannelQuery")
	proto.RegisterType((*AuthUserRequest)(nil), "api.AuthUserRequest")
	proto.RegisterType((*UserResponse)(nil), "api.UserResponse")
	proto.RegisterType((*UserModesResponse)(nil), "api.UserModesResponse")
	proto.RegisterType((*ChannelResponse)(nil), "api.ChannelResponse")
	proto.RegisterType((*StoredUsersResponse)(nil), "api.StoredUsersResponse")
	proto.RegisterType((*StoredChannelsResponse)(nil), "api.StoredChannelsResponse")
	proto.RegisterType((*LogoutRequest)(nil), "api.LogoutRequest")
	proto.RegisterType((*LogoutRequest_HostUser)(nil), "api.LogoutRequest.HostUser")
	proto.RegisterType((*NetworkInfoRequest)(nil), "api.NetworkInfoRequest")
	proto.RegisterType((*Cmd)(nil), "api.Cmd")
	proto.RegisterType((*CmdEvent)(nil), "api.CmdEvent")
	proto.RegisterMapType((map[string]string)(nil), "api.CmdEvent.ArgsEntry")
	proto.RegisterMapType((map[string]*StoredUser)(nil), "api.CmdEvent.TargetStoredUsersEntry")
	proto.RegisterMapType((map[string]*StateUser)(nil), "api.CmdEvent.TargetUsersEntry")
	proto.RegisterType((*CmdEventResponse)(nil), "api.CmdEventResponse")
	proto.RegisterType((*IRCEventResponse)(nil), "api.IRCEventResponse")
	proto.RegisterType((*IRCEvent)(nil), "api.IRCEvent")
	proto.RegisterType((*RegisterCmdRequest)(nil), "api.RegisterCmdRequest")
	proto.RegisterType((*RegisterRequest)(nil), "api.RegisterRequest")
	proto.RegisterType((*RegisterResponse)(nil), "api.RegisterResponse")
	proto.RegisterType((*SubscriptionRequest)(nil), "api.SubscriptionRequest")
	proto.RegisterType((*UnregisterRequest)(nil), "api.UnregisterRequest")
	proto.RegisterType((*UnregisterAllRequest)(nil), "api.UnregisterAllRequest")
	proto.RegisterType((*WriteRequest)(nil), "api.WriteRequest")
}

func init() { proto.RegisterFile("ultimateq.proto", fileDescriptor_dd1789c19b148ca6) }

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

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

// ExtClient is the client API for Ext service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ExtClient interface {
	// Events subscribes a client to a specified (or all) events for a given
	// extension. A client can optionally include the ids returned from
	// Register* rpc calls to create a filtered list that will not collide
	// with another extension even of the same name.
	Events(ctx context.Context, in *SubscriptionRequest, opts ...grpc.CallOption) (Ext_EventsClient, error)
	// Commands is the same as Events above but for Commands.
	Commands(ctx context.Context, in *SubscriptionRequest, opts ...grpc.CallOption) (Ext_CommandsClient, error)
	Write(ctx context.Context, in *WriteRequest, opts ...grpc.CallOption) (*Empty, error)
	Register(ctx context.Context, in *RegisterRequest, opts ...grpc.CallOption) (*RegisterResponse, error)
	RegisterCmd(ctx context.Context, in *RegisterCmdRequest, opts ...grpc.CallOption) (*RegisterResponse, error)
	Unregister(ctx context.Context, in *UnregisterRequest, opts ...grpc.CallOption) (*Result, error)
	UnregisterCmd(ctx context.Context, in *UnregisterRequest, opts ...grpc.CallOption) (*Result, error)
	UnregisterAll(ctx context.Context, in *UnregisterAllRequest, opts ...grpc.CallOption) (*Empty, error)
	//==================================
	//Data methods
	//==================================
	NetworkInformation(ctx context.Context, in *NetworkInfoRequest, opts ...grpc.CallOption) (*NetworkInfo, error)
	StateSelf(ctx context.Context, in *Query, opts ...grpc.CallOption) (*SelfResponse, error)
	StateUsers(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*StateUser, error)
	StateUsersByChan(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*ListResponse, error)
	StateUsersByChanCount(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*CountResponse, error)
	StateUserModes(ctx context.Context, in *ChannelQuery, opts ...grpc.CallOption) (*UserModes, error)
	StateChannel(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*ChannelResponse, error)
	StateChannels(ctx context.Context, in *Query, opts ...grpc.CallOption) (*ListResponse, error)
	StateChannelCount(ctx context.Context, in *Query, opts ...grpc.CallOption) (*CountResponse, error)
	StateIsOn(ctx context.Context, in *ChannelQuery, opts ...grpc.CallOption) (*Result, error)
	StoreAuthUser(ctx context.Context, in *AuthUserRequest, opts ...grpc.CallOption) (*Result, error)
	StoreAuthedUser(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*StoredUser, error)
	StoreUser(ctx context.Context, in *Query, opts ...grpc.CallOption) (*StoredUser, error)
	StoreUsers(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*StoredUsersResponse, error)
	StoreUsersByNetwork(ctx context.Context, in *Query, opts ...grpc.CallOption) (*StoredUsersResponse, error)
	StoreUsersByChannel(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*StoredUsersResponse, error)
	StoreChannel(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*StoredChannel, error)
	StoreChannels(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*StoredChannelsResponse, error)
	StorePutUser(ctx context.Context, in *StoredUser, opts ...grpc.CallOption) (*Empty, error)
	StorePutChannel(ctx context.Context, in *StoredChannel, opts ...grpc.CallOption) (*Empty, error)
	StoreDeleteUser(ctx context.Context, in *Query, opts ...grpc.CallOption) (*Empty, error)
	StoreDeleteChannel(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*Empty, error)
	StoreLogout(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*Empty, error)
	StoreLogoutByUser(ctx context.Context, in *Query, opts ...grpc.CallOption) (*Empty, error)
}

type extClient struct {
	cc *grpc.ClientConn
}

func NewExtClient(cc *grpc.ClientConn) ExtClient {
	return &extClient{cc}
}

func (c *extClient) Events(ctx context.Context, in *SubscriptionRequest, opts ...grpc.CallOption) (Ext_EventsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Ext_serviceDesc.Streams[0], "/api.Ext/Events", opts...)
	if err != nil {
		return nil, err
	}
	x := &extEventsClient{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 Ext_EventsClient interface {
	Recv() (*IRCEventResponse, error)
	grpc.ClientStream
}

type extEventsClient struct {
	grpc.ClientStream
}

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

func (c *extClient) Commands(ctx context.Context, in *SubscriptionRequest, opts ...grpc.CallOption) (Ext_CommandsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Ext_serviceDesc.Streams[1], "/api.Ext/Commands", opts...)
	if err != nil {
		return nil, err
	}
	x := &extCommandsClient{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 Ext_CommandsClient interface {
	Recv() (*CmdEventResponse, error)
	grpc.ClientStream
}

type extCommandsClient struct {
	grpc.ClientStream
}

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

func (c *extClient) Write(ctx context.Context, in *WriteRequest, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/api.Ext/Write", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) Register(ctx context.Context, in *RegisterRequest, opts ...grpc.CallOption) (*RegisterResponse, error) {
	out := new(RegisterResponse)
	err := c.cc.Invoke(ctx, "/api.Ext/Register", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) RegisterCmd(ctx context.Context, in *RegisterCmdRequest, opts ...grpc.CallOption) (*RegisterResponse, error) {
	out := new(RegisterResponse)
	err := c.cc.Invoke(ctx, "/api.Ext/RegisterCmd", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) Unregister(ctx context.Context, in *UnregisterRequest, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/api.Ext/Unregister", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) UnregisterCmd(ctx context.Context, in *UnregisterRequest, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/api.Ext/UnregisterCmd", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) UnregisterAll(ctx context.Context, in *UnregisterAllRequest, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/api.Ext/UnregisterAll", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) NetworkInformation(ctx context.Context, in *NetworkInfoRequest, opts ...grpc.CallOption) (*NetworkInfo, error) {
	out := new(NetworkInfo)
	err := c.cc.Invoke(ctx, "/api.Ext/NetworkInformation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StateSelf(ctx context.Context, in *Query, opts ...grpc.CallOption) (*SelfResponse, error) {
	out := new(SelfResponse)
	err := c.cc.Invoke(ctx, "/api.Ext/StateSelf", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StateUsers(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*StateUser, error) {
	out := new(StateUser)
	err := c.cc.Invoke(ctx, "/api.Ext/StateUsers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StateUsersByChan(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*ListResponse, error) {
	out := new(ListResponse)
	err := c.cc.Invoke(ctx, "/api.Ext/StateUsersByChan", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StateUsersByChanCount(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*CountResponse, error) {
	out := new(CountResponse)
	err := c.cc.Invoke(ctx, "/api.Ext/StateUsersByChanCount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StateUserModes(ctx context.Context, in *ChannelQuery, opts ...grpc.CallOption) (*UserModes, error) {
	out := new(UserModes)
	err := c.cc.Invoke(ctx, "/api.Ext/StateUserModes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StateChannel(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*ChannelResponse, error) {
	out := new(ChannelResponse)
	err := c.cc.Invoke(ctx, "/api.Ext/StateChannel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StateChannels(ctx context.Context, in *Query, opts ...grpc.CallOption) (*ListResponse, error) {
	out := new(ListResponse)
	err := c.cc.Invoke(ctx, "/api.Ext/StateChannels", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StateChannelCount(ctx context.Context, in *Query, opts ...grpc.CallOption) (*CountResponse, error) {
	out := new(CountResponse)
	err := c.cc.Invoke(ctx, "/api.Ext/StateChannelCount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StateIsOn(ctx context.Context, in *ChannelQuery, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/api.Ext/StateIsOn", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StoreAuthUser(ctx context.Context, in *AuthUserRequest, opts ...grpc.CallOption) (*Result, error) {
	out := new(Result)
	err := c.cc.Invoke(ctx, "/api.Ext/StoreAuthUser", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StoreAuthedUser(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*StoredUser, error) {
	out := new(StoredUser)
	err := c.cc.Invoke(ctx, "/api.Ext/StoreAuthedUser", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StoreUser(ctx context.Context, in *Query, opts ...grpc.CallOption) (*StoredUser, error) {
	out := new(StoredUser)
	err := c.cc.Invoke(ctx, "/api.Ext/StoreUser", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StoreUsers(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*StoredUsersResponse, error) {
	out := new(StoredUsersResponse)
	err := c.cc.Invoke(ctx, "/api.Ext/StoreUsers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StoreUsersByNetwork(ctx context.Context, in *Query, opts ...grpc.CallOption) (*StoredUsersResponse, error) {
	out := new(StoredUsersResponse)
	err := c.cc.Invoke(ctx, "/api.Ext/StoreUsersByNetwork", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StoreUsersByChannel(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*StoredUsersResponse, error) {
	out := new(StoredUsersResponse)
	err := c.cc.Invoke(ctx, "/api.Ext/StoreUsersByChannel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StoreChannel(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*StoredChannel, error) {
	out := new(StoredChannel)
	err := c.cc.Invoke(ctx, "/api.Ext/StoreChannel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StoreChannels(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*StoredChannelsResponse, error) {
	out := new(StoredChannelsResponse)
	err := c.cc.Invoke(ctx, "/api.Ext/StoreChannels", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StorePutUser(ctx context.Context, in *StoredUser, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/api.Ext/StorePutUser", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StorePutChannel(ctx context.Context, in *StoredChannel, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/api.Ext/StorePutChannel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StoreDeleteUser(ctx context.Context, in *Query, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/api.Ext/StoreDeleteUser", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StoreDeleteChannel(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/api.Ext/StoreDeleteChannel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StoreLogout(ctx context.Context, in *NetworkQuery, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/api.Ext/StoreLogout", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *extClient) StoreLogoutByUser(ctx context.Context, in *Query, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/api.Ext/StoreLogoutByUser", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ExtServer is the server API for Ext service.
type ExtServer interface {
	// Events subscribes a client to a specified (or all) events for a given
	// extension. A client can optionally include the ids returned from
	// Register* rpc calls to create a filtered list that will not collide
	// with another extension even of the same name.
	Events(*SubscriptionRequest, Ext_EventsServer) error
	// Commands is the same as Events above but for Commands.
	Commands(*SubscriptionRequest, Ext_CommandsServer) error
	Write(context.Context, *WriteRequest) (*Empty, error)
	Register(context.Context, *RegisterRequest) (*RegisterResponse, error)
	RegisterCmd(context.Context, *RegisterCmdRequest) (*RegisterResponse, error)
	Unregister(context.Context, *UnregisterRequest) (*Result, error)
	UnregisterCmd(context.Context, *UnregisterRequest) (*Result, error)
	UnregisterAll(context.Context, *UnregisterAllRequest) (*Empty, error)
	//==================================
	//Data methods
	//==================================
	NetworkInformation(context.Context, *NetworkInfoRequest) (*NetworkInfo, error)
	StateSelf(context.Context, *Query) (*SelfResponse, error)
	StateUsers(context.Context, *NetworkQuery) (*StateUser, error)
	StateUsersByChan(context.Context, *NetworkQuery) (*ListResponse, error)
	StateUsersByChanCount(context.Context, *NetworkQuery) (*CountResponse, error)
	StateUserModes(context.Context, *ChannelQuery) (*UserModes, error)
	StateChannel(context.Context, *NetworkQuery) (*ChannelResponse, error)
	StateChannels(context.Context, *Query) (*ListResponse, error)
	StateChannelCount(context.Context, *Query) (*CountResponse, error)
	StateIsOn(context.Context, *ChannelQuery) (*Result, error)
	StoreAuthUser(context.Context, *AuthUserRequest) (*Result, error)
	StoreAuthedUser(context.Context, *NetworkQuery) (*StoredUser, error)
	StoreUser(context.Context, *Query) (*StoredUser, error)
	StoreUsers(context.Context, *Empty) (*StoredUsersResponse, error)
	StoreUsersByNetwork(context.Context, *Query) (*StoredUsersResponse, error)
	StoreUsersByChannel(context.Context, *NetworkQuery) (*StoredUsersResponse, error)
	StoreChannel(context.Context, *NetworkQuery) (*StoredChannel, error)
	StoreChannels(context.Context, *Empty) (*StoredChannelsResponse, error)
	StorePutUser(context.Context, *StoredUser) (*Empty, error)
	StorePutChannel(context.Context, *StoredChannel) (*Empty, error)
	StoreDeleteUser(context.Context, *Query) (*Empty, error)
	StoreDeleteChannel(context.Context, *NetworkQuery) (*Empty, error)
	StoreLogout(context.Context, *NetworkQuery) (*Empty, error)
	StoreLogoutByUser(context.Context, *Query) (*Empty, error)
}

func RegisterExtServer(s *grpc.Server, srv ExtServer) {
	s.RegisterService(&_Ext_serviceDesc, srv)
}

func _Ext_Events_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscriptionRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ExtServer).Events(m, &extEventsServer{stream})
}

type Ext_EventsServer interface {
	Send(*IRCEventResponse) error
	grpc.ServerStream
}

type extEventsServer struct {
	grpc.ServerStream
}

func (x *extEventsServer) Send(m *IRCEventResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Ext_Commands_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscriptionRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ExtServer).Commands(m, &extCommandsServer{stream})
}

type Ext_CommandsServer interface {
	Send(*CmdEventResponse) error
	grpc.ServerStream
}

type extCommandsServer struct {
	grpc.ServerStream
}

func (x *extCommandsServer) Send(m *CmdEventResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Ext_Write_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WriteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).Write(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/Write",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).Write(ctx, req.(*WriteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_Register_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegisterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).Register(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/Register",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).Register(ctx, req.(*RegisterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_RegisterCmd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegisterCmdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).RegisterCmd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/RegisterCmd",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).RegisterCmd(ctx, req.(*RegisterCmdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_Unregister_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnregisterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).Unregister(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/Unregister",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).Unregister(ctx, req.(*UnregisterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_UnregisterCmd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnregisterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).UnregisterCmd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/UnregisterCmd",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).UnregisterCmd(ctx, req.(*UnregisterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_UnregisterAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnregisterAllRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).UnregisterAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/UnregisterAll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).UnregisterAll(ctx, req.(*UnregisterAllRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_NetworkInformation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NetworkInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).NetworkInformation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/NetworkInformation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).NetworkInformation(ctx, req.(*NetworkInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StateSelf_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Query)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StateSelf(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StateSelf",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StateSelf(ctx, req.(*Query))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StateUsers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NetworkQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StateUsers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StateUsers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StateUsers(ctx, req.(*NetworkQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StateUsersByChan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NetworkQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StateUsersByChan(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StateUsersByChan",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StateUsersByChan(ctx, req.(*NetworkQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StateUsersByChanCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NetworkQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StateUsersByChanCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StateUsersByChanCount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StateUsersByChanCount(ctx, req.(*NetworkQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StateUserModes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChannelQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StateUserModes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StateUserModes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StateUserModes(ctx, req.(*ChannelQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StateChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NetworkQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StateChannel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StateChannel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StateChannel(ctx, req.(*NetworkQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StateChannels_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Query)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StateChannels(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StateChannels",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StateChannels(ctx, req.(*Query))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StateChannelCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Query)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StateChannelCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StateChannelCount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StateChannelCount(ctx, req.(*Query))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StateIsOn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChannelQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StateIsOn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StateIsOn",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StateIsOn(ctx, req.(*ChannelQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StoreAuthUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AuthUserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StoreAuthUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StoreAuthUser",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StoreAuthUser(ctx, req.(*AuthUserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StoreAuthedUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NetworkQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StoreAuthedUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StoreAuthedUser",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StoreAuthedUser(ctx, req.(*NetworkQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StoreUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Query)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StoreUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StoreUser",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StoreUser(ctx, req.(*Query))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StoreUsers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StoreUsers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StoreUsers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StoreUsers(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StoreUsersByNetwork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Query)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StoreUsersByNetwork(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StoreUsersByNetwork",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StoreUsersByNetwork(ctx, req.(*Query))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StoreUsersByChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NetworkQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StoreUsersByChannel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StoreUsersByChannel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StoreUsersByChannel(ctx, req.(*NetworkQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StoreChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NetworkQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StoreChannel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StoreChannel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StoreChannel(ctx, req.(*NetworkQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StoreChannels_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StoreChannels(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StoreChannels",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StoreChannels(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StorePutUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StoredUser)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StorePutUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StorePutUser",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StorePutUser(ctx, req.(*StoredUser))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StorePutChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StoredChannel)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StorePutChannel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StorePutChannel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StorePutChannel(ctx, req.(*StoredChannel))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StoreDeleteUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Query)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StoreDeleteUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StoreDeleteUser",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StoreDeleteUser(ctx, req.(*Query))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StoreDeleteChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NetworkQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StoreDeleteChannel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StoreDeleteChannel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StoreDeleteChannel(ctx, req.(*NetworkQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StoreLogout_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NetworkQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StoreLogout(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StoreLogout",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StoreLogout(ctx, req.(*NetworkQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _Ext_StoreLogoutByUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Query)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExtServer).StoreLogoutByUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Ext/StoreLogoutByUser",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExtServer).StoreLogoutByUser(ctx, req.(*Query))
	}
	return interceptor(ctx, in, info, handler)
}

var _Ext_serviceDesc = grpc.ServiceDesc{
	ServiceName: "api.Ext",
	HandlerType: (*ExtServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Write",
			Handler:    _Ext_Write_Handler,
		},
		{
			MethodName: "Register",
			Handler:    _Ext_Register_Handler,
		},
		{
			MethodName: "RegisterCmd",
			Handler:    _Ext_RegisterCmd_Handler,
		},
		{
			MethodName: "Unregister",
			Handler:    _Ext_Unregister_Handler,
		},
		{
			MethodName: "UnregisterCmd",
			Handler:    _Ext_UnregisterCmd_Handler,
		},
		{
			MethodName: "UnregisterAll",
			Handler:    _Ext_UnregisterAll_Handler,
		},
		{
			MethodName: "NetworkInformation",
			Handler:    _Ext_NetworkInformation_Handler,
		},
		{
			MethodName: "StateSelf",
			Handler:    _Ext_StateSelf_Handler,
		},
		{
			MethodName: "StateUsers",
			Handler:    _Ext_StateUsers_Handler,
		},
		{
			MethodName: "StateUsersByChan",
			Handler:    _Ext_StateUsersByChan_Handler,
		},
		{
			MethodName: "StateUsersByChanCount",
			Handler:    _Ext_StateUsersByChanCount_Handler,
		},
		{
			MethodName: "StateUserModes",
			Handler:    _Ext_StateUserModes_Handler,
		},
		{
			MethodName: "StateChannel",
			Handler:    _Ext_StateChannel_Handler,
		},
		{
			MethodName: "StateChannels",
			Handler:    _Ext_StateChannels_Handler,
		},
		{
			MethodName: "StateChannelCount",
			Handler:    _Ext_StateChannelCount_Handler,
		},
		{
			MethodName: "StateIsOn",
			Handler:    _Ext_StateIsOn_Handler,
		},
		{
			MethodName: "StoreAuthUser",
			Handler:    _Ext_StoreAuthUser_Handler,
		},
		{
			MethodName: "StoreAuthedUser",
			Handler:    _Ext_StoreAuthedUser_Handler,
		},
		{
			MethodName: "StoreUser",
			Handler:    _Ext_StoreUser_Handler,
		},
		{
			MethodName: "StoreUsers",
			Handler:    _Ext_StoreUsers_Handler,
		},
		{
			MethodName: "StoreUsersByNetwork",
			Handler:    _Ext_StoreUsersByNetwork_Handler,
		},
		{
			MethodName: "StoreUsersByChannel",
			Handler:    _Ext_StoreUsersByChannel_Handler,
		},
		{
			MethodName: "StoreChannel",
			Handler:    _Ext_StoreChannel_Handler,
		},
		{
			MethodName: "StoreChannels",
			Handler:    _Ext_StoreChannels_Handler,
		},
		{
			MethodName: "StorePutUser",
			Handler:    _Ext_StorePutUser_Handler,
		},
		{
			MethodName: "StorePutChannel",
			Handler:    _Ext_StorePutChannel_Handler,
		},
		{
			MethodName: "StoreDeleteUser",
			Handler:    _Ext_StoreDeleteUser_Handler,
		},
		{
			MethodName: "StoreDeleteChannel",
			Handler:    _Ext_StoreDeleteChannel_Handler,
		},
		{
			MethodName: "StoreLogout",
			Handler:    _Ext_StoreLogout_Handler,
		},
		{
			MethodName: "StoreLogoutByUser",
			Handler:    _Ext_StoreLogoutByUser_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Events",
			Handler:       _Ext_Events_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Commands",
			Handler:       _Ext_Commands_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "ultimateq.proto",
}