// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: api/v1/config.proto

package v1

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var _ = time.Kitchen

// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type Config struct {
	Id          int64      `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Label       string     `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty"`
	Name        string     `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Value       string     `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
	Placeholder string     `protobuf:"bytes,5,opt,name=placeholder,proto3" json:"placeholder,omitempty"`
	InputType   string     `protobuf:"bytes,6,opt,name=input_type,json=inputType,proto3" json:"input_type,omitempty"`
	Category    string     `protobuf:"bytes,7,opt,name=category,proto3" json:"category,omitempty"`
	Sort        int32      `protobuf:"varint,8,opt,name=sort,proto3" json:"sort,omitempty"`
	Options     string     `protobuf:"bytes,9,opt,name=options,proto3" json:"options,omitempty"`
	CreatedAt   *time.Time `protobuf:"bytes,10,opt,name=created_at,json=createdAt,proto3,stdtime" json:"created_at,omitempty"`
	UpdatedAt   *time.Time `protobuf:"bytes,11,opt,name=updated_at,json=updatedAt,proto3,stdtime" json:"updated_at,omitempty"`
}

func (m *Config) Reset()         { *m = Config{} }
func (m *Config) String() string { return proto.CompactTextString(m) }
func (*Config) ProtoMessage()    {}
func (*Config) Descriptor() ([]byte, []int) {
	return fileDescriptor_321614cd6c9c1b8a, []int{0}
}
func (m *Config) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Config.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Config) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Config.Merge(m, src)
}
func (m *Config) XXX_Size() int {
	return m.Size()
}
func (m *Config) XXX_DiscardUnknown() {
	xxx_messageInfo_Config.DiscardUnknown(m)
}

var xxx_messageInfo_Config proto.InternalMessageInfo

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

func (m *Config) GetLabel() string {
	if m != nil {
		return m.Label
	}
	return ""
}

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

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

func (m *Config) GetPlaceholder() string {
	if m != nil {
		return m.Placeholder
	}
	return ""
}

func (m *Config) GetInputType() string {
	if m != nil {
		return m.InputType
	}
	return ""
}

func (m *Config) GetCategory() string {
	if m != nil {
		return m.Category
	}
	return ""
}

func (m *Config) GetSort() int32 {
	if m != nil {
		return m.Sort
	}
	return 0
}

func (m *Config) GetOptions() string {
	if m != nil {
		return m.Options
	}
	return ""
}

func (m *Config) GetCreatedAt() *time.Time {
	if m != nil {
		return m.CreatedAt
	}
	return nil
}

func (m *Config) GetUpdatedAt() *time.Time {
	if m != nil {
		return m.UpdatedAt
	}
	return nil
}

type ListConfigRequest struct {
	Category []string `protobuf:"bytes,1,rep,name=category,proto3" json:"category,omitempty"`
}

func (m *ListConfigRequest) Reset()         { *m = ListConfigRequest{} }
func (m *ListConfigRequest) String() string { return proto.CompactTextString(m) }
func (*ListConfigRequest) ProtoMessage()    {}
func (*ListConfigRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_321614cd6c9c1b8a, []int{1}
}
func (m *ListConfigRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ListConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ListConfigRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ListConfigRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListConfigRequest.Merge(m, src)
}
func (m *ListConfigRequest) XXX_Size() int {
	return m.Size()
}
func (m *ListConfigRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListConfigRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListConfigRequest proto.InternalMessageInfo

func (m *ListConfigRequest) GetCategory() []string {
	if m != nil {
		return m.Category
	}
	return nil
}

type Configs struct {
	Config []*Config `protobuf:"bytes,1,rep,name=config,proto3" json:"config,omitempty"`
}

func (m *Configs) Reset()         { *m = Configs{} }
func (m *Configs) String() string { return proto.CompactTextString(m) }
func (*Configs) ProtoMessage()    {}
func (*Configs) Descriptor() ([]byte, []int) {
	return fileDescriptor_321614cd6c9c1b8a, []int{2}
}
func (m *Configs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Configs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Configs.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Configs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Configs.Merge(m, src)
}
func (m *Configs) XXX_Size() int {
	return m.Size()
}
func (m *Configs) XXX_DiscardUnknown() {
	xxx_messageInfo_Configs.DiscardUnknown(m)
}

var xxx_messageInfo_Configs proto.InternalMessageInfo

func (m *Configs) GetConfig() []*Config {
	if m != nil {
		return m.Config
	}
	return nil
}

// 验证码配置
type ConfigCaptcha struct {
	Length int32  `protobuf:"varint,1,opt,name=length,proto3" json:"length,omitempty"`
	Width  int32  `protobuf:"varint,2,opt,name=width,proto3" json:"width,omitempty"`
	Height int32  `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
	Type   string `protobuf:"bytes,4,opt,name=type,proto3" json:"type,omitempty"`
}

func (m *ConfigCaptcha) Reset()         { *m = ConfigCaptcha{} }
func (m *ConfigCaptcha) String() string { return proto.CompactTextString(m) }
func (*ConfigCaptcha) ProtoMessage()    {}
func (*ConfigCaptcha) Descriptor() ([]byte, []int) {
	return fileDescriptor_321614cd6c9c1b8a, []int{3}
}
func (m *ConfigCaptcha) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConfigCaptcha) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConfigCaptcha.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConfigCaptcha) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConfigCaptcha.Merge(m, src)
}
func (m *ConfigCaptcha) XXX_Size() int {
	return m.Size()
}
func (m *ConfigCaptcha) XXX_DiscardUnknown() {
	xxx_messageInfo_ConfigCaptcha.DiscardUnknown(m)
}

var xxx_messageInfo_ConfigCaptcha proto.InternalMessageInfo

func (m *ConfigCaptcha) GetLength() int32 {
	if m != nil {
		return m.Length
	}
	return 0
}

func (m *ConfigCaptcha) GetWidth() int32 {
	if m != nil {
		return m.Width
	}
	return 0
}

func (m *ConfigCaptcha) GetHeight() int32 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *ConfigCaptcha) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

// 系统配置项
type ConfigSystem struct {
	Domain             string   `protobuf:"bytes,1,opt,name=domain,proto3" json:"domain,omitempty"`
	Title              string   `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
	Keywords           string   `protobuf:"bytes,3,opt,name=keywords,proto3" json:"keywords,omitempty"`
	Description        string   `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"`
	Logo               string   `protobuf:"bytes,5,opt,name=logo,proto3" json:"logo,omitempty"`
	Favicon            string   `protobuf:"bytes,6,opt,name=favicon,proto3" json:"favicon,omitempty"`
	Icp                string   `protobuf:"bytes,7,opt,name=icp,proto3" json:"icp,omitempty"`
	Analytics          string   `protobuf:"bytes,8,opt,name=analytics,proto3" json:"analytics,omitempty"`
	Sitename           string   `protobuf:"bytes,9,opt,name=sitename,proto3" json:"sitename,omitempty"`
	CopyrightStartYear string   `protobuf:"bytes,10,opt,name=copyright_start_year,json=copyrightStartYear,proto3" json:"copyright_start_year,omitempty"`
	RegisterBackground string   `protobuf:"bytes,11,opt,name=register_background,json=registerBackground,proto3" json:"register_background,omitempty"`
	LoginBackground    string   `protobuf:"bytes,12,opt,name=login_background,json=loginBackground,proto3" json:"login_background,omitempty"`
	RecommendWords     []string `protobuf:"bytes,13,rep,name=recommend_words,json=recommendWords,proto3" json:"recommend_words,omitempty"`
	Version            string   `protobuf:"bytes,14,opt,name=version,proto3" json:"version,omitempty"`
}

func (m *ConfigSystem) Reset()         { *m = ConfigSystem{} }
func (m *ConfigSystem) String() string { return proto.CompactTextString(m) }
func (*ConfigSystem) ProtoMessage()    {}
func (*ConfigSystem) Descriptor() ([]byte, []int) {
	return fileDescriptor_321614cd6c9c1b8a, []int{4}
}
func (m *ConfigSystem) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConfigSystem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConfigSystem.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConfigSystem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConfigSystem.Merge(m, src)
}
func (m *ConfigSystem) XXX_Size() int {
	return m.Size()
}
func (m *ConfigSystem) XXX_DiscardUnknown() {
	xxx_messageInfo_ConfigSystem.DiscardUnknown(m)
}

var xxx_messageInfo_ConfigSystem proto.InternalMessageInfo

func (m *ConfigSystem) GetDomain() string {
	if m != nil {
		return m.Domain
	}
	return ""
}

func (m *ConfigSystem) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *ConfigSystem) GetKeywords() string {
	if m != nil {
		return m.Keywords
	}
	return ""
}

func (m *ConfigSystem) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *ConfigSystem) GetLogo() string {
	if m != nil {
		return m.Logo
	}
	return ""
}

func (m *ConfigSystem) GetFavicon() string {
	if m != nil {
		return m.Favicon
	}
	return ""
}

func (m *ConfigSystem) GetIcp() string {
	if m != nil {
		return m.Icp
	}
	return ""
}

func (m *ConfigSystem) GetAnalytics() string {
	if m != nil {
		return m.Analytics
	}
	return ""
}

func (m *ConfigSystem) GetSitename() string {
	if m != nil {
		return m.Sitename
	}
	return ""
}

func (m *ConfigSystem) GetCopyrightStartYear() string {
	if m != nil {
		return m.CopyrightStartYear
	}
	return ""
}

func (m *ConfigSystem) GetRegisterBackground() string {
	if m != nil {
		return m.RegisterBackground
	}
	return ""
}

func (m *ConfigSystem) GetLoginBackground() string {
	if m != nil {
		return m.LoginBackground
	}
	return ""
}

func (m *ConfigSystem) GetRecommendWords() []string {
	if m != nil {
		return m.RecommendWords
	}
	return nil
}

func (m *ConfigSystem) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

// 底链配置项
type ConfigFooter struct {
	About     string `protobuf:"bytes,1,opt,name=about,proto3" json:"about,omitempty"`
	Contact   string `protobuf:"bytes,2,opt,name=contact,proto3" json:"contact,omitempty"`
	Agreement string `protobuf:"bytes,3,opt,name=agreement,proto3" json:"agreement,omitempty"`
	Copyright string `protobuf:"bytes,4,opt,name=copyright,proto3" json:"copyright,omitempty"`
	Feedback  string `protobuf:"bytes,5,opt,name=feedback,proto3" json:"feedback,omitempty"`
}

func (m *ConfigFooter) Reset()         { *m = ConfigFooter{} }
func (m *ConfigFooter) String() string { return proto.CompactTextString(m) }
func (*ConfigFooter) ProtoMessage()    {}
func (*ConfigFooter) Descriptor() ([]byte, []int) {
	return fileDescriptor_321614cd6c9c1b8a, []int{5}
}
func (m *ConfigFooter) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConfigFooter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConfigFooter.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConfigFooter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConfigFooter.Merge(m, src)
}
func (m *ConfigFooter) XXX_Size() int {
	return m.Size()
}
func (m *ConfigFooter) XXX_DiscardUnknown() {
	xxx_messageInfo_ConfigFooter.DiscardUnknown(m)
}

var xxx_messageInfo_ConfigFooter proto.InternalMessageInfo

func (m *ConfigFooter) GetAbout() string {
	if m != nil {
		return m.About
	}
	return ""
}

func (m *ConfigFooter) GetContact() string {
	if m != nil {
		return m.Contact
	}
	return ""
}

func (m *ConfigFooter) GetAgreement() string {
	if m != nil {
		return m.Agreement
	}
	return ""
}

func (m *ConfigFooter) GetCopyright() string {
	if m != nil {
		return m.Copyright
	}
	return ""
}

func (m *ConfigFooter) GetFeedback() string {
	if m != nil {
		return m.Feedback
	}
	return ""
}

// 安全配置
type ConfigSecurity struct {
	IsClose                   bool     `protobuf:"varint,1,opt,name=is_close,json=isClose,proto3" json:"is_close,omitempty"`
	CloseStatement            string   `protobuf:"bytes,2,opt,name=close_statement,json=closeStatement,proto3" json:"close_statement,omitempty"`
	EnableRegister            bool     `protobuf:"varint,3,opt,name=enable_register,json=enableRegister,proto3" json:"enable_register,omitempty"`
	EnableCaptchaLogin        bool     `protobuf:"varint,4,opt,name=enable_captcha_login,json=enableCaptchaLogin,proto3" json:"enable_captcha_login,omitempty"`
	EnableCaptchaRegister     bool     `protobuf:"varint,5,opt,name=enable_captcha_register,json=enableCaptchaRegister,proto3" json:"enable_captcha_register,omitempty"`
	EnableCaptchaComment      bool     `protobuf:"varint,6,opt,name=enable_captcha_comment,json=enableCaptchaComment,proto3" json:"enable_captcha_comment,omitempty"`
	EnableCaptchaFindPassword bool     `protobuf:"varint,7,opt,name=enable_captcha_find_password,json=enableCaptchaFindPassword,proto3" json:"enable_captcha_find_password,omitempty"`
	EnableCaptchaUpload       bool     `protobuf:"varint,8,opt,name=enable_captcha_upload,json=enableCaptchaUpload,proto3" json:"enable_captcha_upload,omitempty"`
	MaxDocumentSize           int32    `protobuf:"varint,9,opt,name=max_document_size,json=maxDocumentSize,proto3" json:"max_document_size,omitempty"`
	DocumentAllowedExt        []string `protobuf:"bytes,10,rep,name=document_allowed_ext,json=documentAllowedExt,proto3" json:"document_allowed_ext,omitempty"`
}

func (m *ConfigSecurity) Reset()         { *m = ConfigSecurity{} }
func (m *ConfigSecurity) String() string { return proto.CompactTextString(m) }
func (*ConfigSecurity) ProtoMessage()    {}
func (*ConfigSecurity) Descriptor() ([]byte, []int) {
	return fileDescriptor_321614cd6c9c1b8a, []int{6}
}
func (m *ConfigSecurity) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConfigSecurity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConfigSecurity.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConfigSecurity) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConfigSecurity.Merge(m, src)
}
func (m *ConfigSecurity) XXX_Size() int {
	return m.Size()
}
func (m *ConfigSecurity) XXX_DiscardUnknown() {
	xxx_messageInfo_ConfigSecurity.DiscardUnknown(m)
}

var xxx_messageInfo_ConfigSecurity proto.InternalMessageInfo

func (m *ConfigSecurity) GetIsClose() bool {
	if m != nil {
		return m.IsClose
	}
	return false
}

func (m *ConfigSecurity) GetCloseStatement() string {
	if m != nil {
		return m.CloseStatement
	}
	return ""
}

func (m *ConfigSecurity) GetEnableRegister() bool {
	if m != nil {
		return m.EnableRegister
	}
	return false
}

func (m *ConfigSecurity) GetEnableCaptchaLogin() bool {
	if m != nil {
		return m.EnableCaptchaLogin
	}
	return false
}

func (m *ConfigSecurity) GetEnableCaptchaRegister() bool {
	if m != nil {
		return m.EnableCaptchaRegister
	}
	return false
}

func (m *ConfigSecurity) GetEnableCaptchaComment() bool {
	if m != nil {
		return m.EnableCaptchaComment
	}
	return false
}

func (m *ConfigSecurity) GetEnableCaptchaFindPassword() bool {
	if m != nil {
		return m.EnableCaptchaFindPassword
	}
	return false
}

func (m *ConfigSecurity) GetEnableCaptchaUpload() bool {
	if m != nil {
		return m.EnableCaptchaUpload
	}
	return false
}

func (m *ConfigSecurity) GetMaxDocumentSize() int32 {
	if m != nil {
		return m.MaxDocumentSize
	}
	return 0
}

func (m *ConfigSecurity) GetDocumentAllowedExt() []string {
	if m != nil {
		return m.DocumentAllowedExt
	}
	return nil
}

type Settings struct {
	System   *ConfigSystem   `protobuf:"bytes,1,opt,name=system,proto3" json:"system,omitempty"`
	Footer   *ConfigFooter   `protobuf:"bytes,2,opt,name=footer,proto3" json:"footer,omitempty"`
	Security *ConfigSecurity `protobuf:"bytes,3,opt,name=security,proto3" json:"security,omitempty"`
}

func (m *Settings) Reset()         { *m = Settings{} }
func (m *Settings) String() string { return proto.CompactTextString(m) }
func (*Settings) ProtoMessage()    {}
func (*Settings) Descriptor() ([]byte, []int) {
	return fileDescriptor_321614cd6c9c1b8a, []int{7}
}
func (m *Settings) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Settings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Settings.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Settings) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Settings.Merge(m, src)
}
func (m *Settings) XXX_Size() int {
	return m.Size()
}
func (m *Settings) XXX_DiscardUnknown() {
	xxx_messageInfo_Settings.DiscardUnknown(m)
}

var xxx_messageInfo_Settings proto.InternalMessageInfo

func (m *Settings) GetSystem() *ConfigSystem {
	if m != nil {
		return m.System
	}
	return nil
}

func (m *Settings) GetFooter() *ConfigFooter {
	if m != nil {
		return m.Footer
	}
	return nil
}

func (m *Settings) GetSecurity() *ConfigSecurity {
	if m != nil {
		return m.Security
	}
	return nil
}

type EnvDependent struct {
	Name        string     `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Description string     `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	IsInstalled bool       `protobuf:"varint,3,opt,name=is_installed,json=isInstalled,proto3" json:"is_installed,omitempty"`
	Error       string     `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"`
	CheckedAt   *time.Time `protobuf:"bytes,5,opt,name=checked_at,json=checkedAt,proto3,stdtime" json:"checked_at,omitempty"`
	Cmd         string     `protobuf:"bytes,6,opt,name=cmd,proto3" json:"cmd,omitempty"`
	IsRequired  bool       `protobuf:"varint,7,opt,name=is_required,json=isRequired,proto3" json:"is_required,omitempty"`
}

func (m *EnvDependent) Reset()         { *m = EnvDependent{} }
func (m *EnvDependent) String() string { return proto.CompactTextString(m) }
func (*EnvDependent) ProtoMessage()    {}
func (*EnvDependent) Descriptor() ([]byte, []int) {
	return fileDescriptor_321614cd6c9c1b8a, []int{8}
}
func (m *EnvDependent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EnvDependent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EnvDependent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EnvDependent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EnvDependent.Merge(m, src)
}
func (m *EnvDependent) XXX_Size() int {
	return m.Size()
}
func (m *EnvDependent) XXX_DiscardUnknown() {
	xxx_messageInfo_EnvDependent.DiscardUnknown(m)
}

var xxx_messageInfo_EnvDependent proto.InternalMessageInfo

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

func (m *EnvDependent) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *EnvDependent) GetIsInstalled() bool {
	if m != nil {
		return m.IsInstalled
	}
	return false
}

func (m *EnvDependent) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

func (m *EnvDependent) GetCheckedAt() *time.Time {
	if m != nil {
		return m.CheckedAt
	}
	return nil
}

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

func (m *EnvDependent) GetIsRequired() bool {
	if m != nil {
		return m.IsRequired
	}
	return false
}

type Envs struct {
	Envs []*EnvDependent `protobuf:"bytes,1,rep,name=envs,proto3" json:"envs,omitempty"`
}

func (m *Envs) Reset()         { *m = Envs{} }
func (m *Envs) String() string { return proto.CompactTextString(m) }
func (*Envs) ProtoMessage()    {}
func (*Envs) Descriptor() ([]byte, []int) {
	return fileDescriptor_321614cd6c9c1b8a, []int{9}
}
func (m *Envs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Envs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Envs.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Envs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Envs.Merge(m, src)
}
func (m *Envs) XXX_Size() int {
	return m.Size()
}
func (m *Envs) XXX_DiscardUnknown() {
	xxx_messageInfo_Envs.DiscardUnknown(m)
}

var xxx_messageInfo_Envs proto.InternalMessageInfo

func (m *Envs) GetEnvs() []*EnvDependent {
	if m != nil {
		return m.Envs
	}
	return nil
}

type Stats struct {
	UserCount       int64  `protobuf:"varint,1,opt,name=user_count,json=userCount,proto3" json:"user_count,omitempty"`
	DocumentCount   int64  `protobuf:"varint,2,opt,name=document_count,json=documentCount,proto3" json:"document_count,omitempty"`
	CategoryCount   int64  `protobuf:"varint,3,opt,name=category_count,json=categoryCount,proto3" json:"category_count,omitempty"`
	ArticleCount    int64  `protobuf:"varint,4,opt,name=article_count,json=articleCount,proto3" json:"article_count,omitempty"`
	CommentCount    int64  `protobuf:"varint,5,opt,name=comment_count,json=commentCount,proto3" json:"comment_count,omitempty"`
	BannerCount     int64  `protobuf:"varint,6,opt,name=banner_count,json=bannerCount,proto3" json:"banner_count,omitempty"`
	FriendlinkCount int64  `protobuf:"varint,7,opt,name=friendlink_count,json=friendlinkCount,proto3" json:"friendlink_count,omitempty"`
	Os              string `protobuf:"bytes,8,opt,name=os,proto3" json:"os,omitempty"`
	Version         string `protobuf:"bytes,9,opt,name=version,proto3" json:"version,omitempty"`
	Hash            string `protobuf:"bytes,10,opt,name=hash,proto3" json:"hash,omitempty"`
	BuildAt         string `protobuf:"bytes,11,opt,name=build_at,json=buildAt,proto3" json:"build_at,omitempty"`
	ReportCount     int64  `protobuf:"varint,12,opt,name=report_count,json=reportCount,proto3" json:"report_count,omitempty"`
}

func (m *Stats) Reset()         { *m = Stats{} }
func (m *Stats) String() string { return proto.CompactTextString(m) }
func (*Stats) ProtoMessage()    {}
func (*Stats) Descriptor() ([]byte, []int) {
	return fileDescriptor_321614cd6c9c1b8a, []int{10}
}
func (m *Stats) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Stats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Stats.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Stats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Stats.Merge(m, src)
}
func (m *Stats) XXX_Size() int {
	return m.Size()
}
func (m *Stats) XXX_DiscardUnknown() {
	xxx_messageInfo_Stats.DiscardUnknown(m)
}

var xxx_messageInfo_Stats proto.InternalMessageInfo

func (m *Stats) GetUserCount() int64 {
	if m != nil {
		return m.UserCount
	}
	return 0
}

func (m *Stats) GetDocumentCount() int64 {
	if m != nil {
		return m.DocumentCount
	}
	return 0
}

func (m *Stats) GetCategoryCount() int64 {
	if m != nil {
		return m.CategoryCount
	}
	return 0
}

func (m *Stats) GetArticleCount() int64 {
	if m != nil {
		return m.ArticleCount
	}
	return 0
}

func (m *Stats) GetCommentCount() int64 {
	if m != nil {
		return m.CommentCount
	}
	return 0
}

func (m *Stats) GetBannerCount() int64 {
	if m != nil {
		return m.BannerCount
	}
	return 0
}

func (m *Stats) GetFriendlinkCount() int64 {
	if m != nil {
		return m.FriendlinkCount
	}
	return 0
}

func (m *Stats) GetOs() string {
	if m != nil {
		return m.Os
	}
	return ""
}

func (m *Stats) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *Stats) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

func (m *Stats) GetBuildAt() string {
	if m != nil {
		return m.BuildAt
	}
	return ""
}

func (m *Stats) GetReportCount() int64 {
	if m != nil {
		return m.ReportCount
	}
	return 0
}

func init() {
	proto.RegisterType((*Config)(nil), "api.v1.Config")
	proto.RegisterType((*ListConfigRequest)(nil), "api.v1.ListConfigRequest")
	proto.RegisterType((*Configs)(nil), "api.v1.Configs")
	proto.RegisterType((*ConfigCaptcha)(nil), "api.v1.ConfigCaptcha")
	proto.RegisterType((*ConfigSystem)(nil), "api.v1.ConfigSystem")
	proto.RegisterType((*ConfigFooter)(nil), "api.v1.ConfigFooter")
	proto.RegisterType((*ConfigSecurity)(nil), "api.v1.ConfigSecurity")
	proto.RegisterType((*Settings)(nil), "api.v1.Settings")
	proto.RegisterType((*EnvDependent)(nil), "api.v1.EnvDependent")
	proto.RegisterType((*Envs)(nil), "api.v1.Envs")
	proto.RegisterType((*Stats)(nil), "api.v1.Stats")
}

func init() { proto.RegisterFile("api/v1/config.proto", fileDescriptor_321614cd6c9c1b8a) }

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

// ConfigAPIClient is the client API for ConfigAPI service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ConfigAPIClient interface {
	// 获取系统配置（针对所有用户，只读）
	GetSettings(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*Settings, error)
	// UpdateConfig 更新配置
	UpdateConfig(ctx context.Context, in *Configs, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// ListConfig 查询配置项
	ListConfig(ctx context.Context, in *ListConfigRequest, opts ...grpc.CallOption) (*Configs, error)
	// 获取系统配置
	GetStats(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*Stats, error)
	// 获取系统环境依赖检测
	GetEnvs(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*Envs, error)
	// 更新站点地图
	UpdateSitemap(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type configAPIClient struct {
	cc *grpc.ClientConn
}

func NewConfigAPIClient(cc *grpc.ClientConn) ConfigAPIClient {
	return &configAPIClient{cc}
}

func (c *configAPIClient) GetSettings(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*Settings, error) {
	out := new(Settings)
	err := c.cc.Invoke(ctx, "/api.v1.ConfigAPI/GetSettings", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *configAPIClient) UpdateConfig(ctx context.Context, in *Configs, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/api.v1.ConfigAPI/UpdateConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *configAPIClient) ListConfig(ctx context.Context, in *ListConfigRequest, opts ...grpc.CallOption) (*Configs, error) {
	out := new(Configs)
	err := c.cc.Invoke(ctx, "/api.v1.ConfigAPI/ListConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *configAPIClient) GetStats(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*Stats, error) {
	out := new(Stats)
	err := c.cc.Invoke(ctx, "/api.v1.ConfigAPI/GetStats", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *configAPIClient) GetEnvs(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*Envs, error) {
	out := new(Envs)
	err := c.cc.Invoke(ctx, "/api.v1.ConfigAPI/GetEnvs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *configAPIClient) UpdateSitemap(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/api.v1.ConfigAPI/UpdateSitemap", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ConfigAPIServer is the server API for ConfigAPI service.
type ConfigAPIServer interface {
	// 获取系统配置（针对所有用户，只读）
	GetSettings(context.Context, *emptypb.Empty) (*Settings, error)
	// UpdateConfig 更新配置
	UpdateConfig(context.Context, *Configs) (*emptypb.Empty, error)
	// ListConfig 查询配置项
	ListConfig(context.Context, *ListConfigRequest) (*Configs, error)
	// 获取系统配置
	GetStats(context.Context, *emptypb.Empty) (*Stats, error)
	// 获取系统环境依赖检测
	GetEnvs(context.Context, *emptypb.Empty) (*Envs, error)
	// 更新站点地图
	UpdateSitemap(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
}

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

func (*UnimplementedConfigAPIServer) GetSettings(ctx context.Context, req *emptypb.Empty) (*Settings, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSettings not implemented")
}
func (*UnimplementedConfigAPIServer) UpdateConfig(ctx context.Context, req *Configs) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateConfig not implemented")
}
func (*UnimplementedConfigAPIServer) ListConfig(ctx context.Context, req *ListConfigRequest) (*Configs, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListConfig not implemented")
}
func (*UnimplementedConfigAPIServer) GetStats(ctx context.Context, req *emptypb.Empty) (*Stats, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetStats not implemented")
}
func (*UnimplementedConfigAPIServer) GetEnvs(ctx context.Context, req *emptypb.Empty) (*Envs, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetEnvs not implemented")
}
func (*UnimplementedConfigAPIServer) UpdateSitemap(ctx context.Context, req *emptypb.Empty) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateSitemap not implemented")
}

func RegisterConfigAPIServer(s *grpc.Server, srv ConfigAPIServer) {
	s.RegisterService(&_ConfigAPI_serviceDesc, srv)
}

func _ConfigAPI_GetSettings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConfigAPIServer).GetSettings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.ConfigAPI/GetSettings",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConfigAPIServer).GetSettings(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConfigAPI_UpdateConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Configs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConfigAPIServer).UpdateConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.ConfigAPI/UpdateConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConfigAPIServer).UpdateConfig(ctx, req.(*Configs))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConfigAPI_ListConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConfigAPIServer).ListConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.ConfigAPI/ListConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConfigAPIServer).ListConfig(ctx, req.(*ListConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConfigAPI_GetStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConfigAPIServer).GetStats(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.ConfigAPI/GetStats",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConfigAPIServer).GetStats(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConfigAPI_GetEnvs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConfigAPIServer).GetEnvs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.ConfigAPI/GetEnvs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConfigAPIServer).GetEnvs(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConfigAPI_UpdateSitemap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConfigAPIServer).UpdateSitemap(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.v1.ConfigAPI/UpdateSitemap",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConfigAPIServer).UpdateSitemap(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

var _ConfigAPI_serviceDesc = grpc.ServiceDesc{
	ServiceName: "api.v1.ConfigAPI",
	HandlerType: (*ConfigAPIServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetSettings",
			Handler:    _ConfigAPI_GetSettings_Handler,
		},
		{
			MethodName: "UpdateConfig",
			Handler:    _ConfigAPI_UpdateConfig_Handler,
		},
		{
			MethodName: "ListConfig",
			Handler:    _ConfigAPI_ListConfig_Handler,
		},
		{
			MethodName: "GetStats",
			Handler:    _ConfigAPI_GetStats_Handler,
		},
		{
			MethodName: "GetEnvs",
			Handler:    _ConfigAPI_GetEnvs_Handler,
		},
		{
			MethodName: "UpdateSitemap",
			Handler:    _ConfigAPI_UpdateSitemap_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api/v1/config.proto",
}

func (m *Config) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Config) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Config) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UpdatedAt != nil {
		n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.UpdatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.UpdatedAt):])
		if err1 != nil {
			return 0, err1
		}
		i -= n1
		i = encodeVarintConfig(dAtA, i, uint64(n1))
		i--
		dAtA[i] = 0x5a
	}
	if m.CreatedAt != nil {
		n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.CreatedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.CreatedAt):])
		if err2 != nil {
			return 0, err2
		}
		i -= n2
		i = encodeVarintConfig(dAtA, i, uint64(n2))
		i--
		dAtA[i] = 0x52
	}
	if len(m.Options) > 0 {
		i -= len(m.Options)
		copy(dAtA[i:], m.Options)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Options)))
		i--
		dAtA[i] = 0x4a
	}
	if m.Sort != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.Sort))
		i--
		dAtA[i] = 0x40
	}
	if len(m.Category) > 0 {
		i -= len(m.Category)
		copy(dAtA[i:], m.Category)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Category)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.InputType) > 0 {
		i -= len(m.InputType)
		copy(dAtA[i:], m.InputType)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.InputType)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Placeholder) > 0 {
		i -= len(m.Placeholder)
		copy(dAtA[i:], m.Placeholder)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Placeholder)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Label) > 0 {
		i -= len(m.Label)
		copy(dAtA[i:], m.Label)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Label)))
		i--
		dAtA[i] = 0x12
	}
	if m.Id != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ListConfigRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ListConfigRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ListConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Category) > 0 {
		for iNdEx := len(m.Category) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Category[iNdEx])
			copy(dAtA[i:], m.Category[iNdEx])
			i = encodeVarintConfig(dAtA, i, uint64(len(m.Category[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Configs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Configs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Configs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Config) > 0 {
		for iNdEx := len(m.Config) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Config[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintConfig(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ConfigCaptcha) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConfigCaptcha) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConfigCaptcha) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0x22
	}
	if m.Height != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x18
	}
	if m.Width != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.Width))
		i--
		dAtA[i] = 0x10
	}
	if m.Length != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.Length))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ConfigSystem) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConfigSystem) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConfigSystem) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0x72
	}
	if len(m.RecommendWords) > 0 {
		for iNdEx := len(m.RecommendWords) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RecommendWords[iNdEx])
			copy(dAtA[i:], m.RecommendWords[iNdEx])
			i = encodeVarintConfig(dAtA, i, uint64(len(m.RecommendWords[iNdEx])))
			i--
			dAtA[i] = 0x6a
		}
	}
	if len(m.LoginBackground) > 0 {
		i -= len(m.LoginBackground)
		copy(dAtA[i:], m.LoginBackground)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.LoginBackground)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.RegisterBackground) > 0 {
		i -= len(m.RegisterBackground)
		copy(dAtA[i:], m.RegisterBackground)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.RegisterBackground)))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.CopyrightStartYear) > 0 {
		i -= len(m.CopyrightStartYear)
		copy(dAtA[i:], m.CopyrightStartYear)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.CopyrightStartYear)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.Sitename) > 0 {
		i -= len(m.Sitename)
		copy(dAtA[i:], m.Sitename)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Sitename)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.Analytics) > 0 {
		i -= len(m.Analytics)
		copy(dAtA[i:], m.Analytics)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Analytics)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.Icp) > 0 {
		i -= len(m.Icp)
		copy(dAtA[i:], m.Icp)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Icp)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Favicon) > 0 {
		i -= len(m.Favicon)
		copy(dAtA[i:], m.Favicon)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Favicon)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Logo) > 0 {
		i -= len(m.Logo)
		copy(dAtA[i:], m.Logo)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Logo)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Keywords) > 0 {
		i -= len(m.Keywords)
		copy(dAtA[i:], m.Keywords)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Keywords)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Title) > 0 {
		i -= len(m.Title)
		copy(dAtA[i:], m.Title)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Title)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Domain) > 0 {
		i -= len(m.Domain)
		copy(dAtA[i:], m.Domain)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Domain)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ConfigFooter) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConfigFooter) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConfigFooter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Feedback) > 0 {
		i -= len(m.Feedback)
		copy(dAtA[i:], m.Feedback)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Feedback)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Copyright) > 0 {
		i -= len(m.Copyright)
		copy(dAtA[i:], m.Copyright)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Copyright)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Agreement) > 0 {
		i -= len(m.Agreement)
		copy(dAtA[i:], m.Agreement)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Agreement)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Contact) > 0 {
		i -= len(m.Contact)
		copy(dAtA[i:], m.Contact)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Contact)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.About) > 0 {
		i -= len(m.About)
		copy(dAtA[i:], m.About)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.About)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ConfigSecurity) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConfigSecurity) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConfigSecurity) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DocumentAllowedExt) > 0 {
		for iNdEx := len(m.DocumentAllowedExt) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.DocumentAllowedExt[iNdEx])
			copy(dAtA[i:], m.DocumentAllowedExt[iNdEx])
			i = encodeVarintConfig(dAtA, i, uint64(len(m.DocumentAllowedExt[iNdEx])))
			i--
			dAtA[i] = 0x52
		}
	}
	if m.MaxDocumentSize != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.MaxDocumentSize))
		i--
		dAtA[i] = 0x48
	}
	if m.EnableCaptchaUpload {
		i--
		if m.EnableCaptchaUpload {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.EnableCaptchaFindPassword {
		i--
		if m.EnableCaptchaFindPassword {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.EnableCaptchaComment {
		i--
		if m.EnableCaptchaComment {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.EnableCaptchaRegister {
		i--
		if m.EnableCaptchaRegister {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.EnableCaptchaLogin {
		i--
		if m.EnableCaptchaLogin {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.EnableRegister {
		i--
		if m.EnableRegister {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.CloseStatement) > 0 {
		i -= len(m.CloseStatement)
		copy(dAtA[i:], m.CloseStatement)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.CloseStatement)))
		i--
		dAtA[i] = 0x12
	}
	if m.IsClose {
		i--
		if m.IsClose {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Settings) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Settings) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Settings) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Security != nil {
		{
			size, err := m.Security.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Footer != nil {
		{
			size, err := m.Footer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.System != nil {
		{
			size, err := m.System.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintConfig(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EnvDependent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EnvDependent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EnvDependent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsRequired {
		i--
		if m.IsRequired {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if len(m.Cmd) > 0 {
		i -= len(m.Cmd)
		copy(dAtA[i:], m.Cmd)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Cmd)))
		i--
		dAtA[i] = 0x32
	}
	if m.CheckedAt != nil {
		n6, err6 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.CheckedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.CheckedAt):])
		if err6 != nil {
			return 0, err6
		}
		i -= n6
		i = encodeVarintConfig(dAtA, i, uint64(n6))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Error) > 0 {
		i -= len(m.Error)
		copy(dAtA[i:], m.Error)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0x22
	}
	if m.IsInstalled {
		i--
		if m.IsInstalled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Envs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Envs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Envs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Envs) > 0 {
		for iNdEx := len(m.Envs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Envs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintConfig(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Stats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Stats) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Stats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ReportCount != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.ReportCount))
		i--
		dAtA[i] = 0x60
	}
	if len(m.BuildAt) > 0 {
		i -= len(m.BuildAt)
		copy(dAtA[i:], m.BuildAt)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.BuildAt)))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.Os) > 0 {
		i -= len(m.Os)
		copy(dAtA[i:], m.Os)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Os)))
		i--
		dAtA[i] = 0x42
	}
	if m.FriendlinkCount != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.FriendlinkCount))
		i--
		dAtA[i] = 0x38
	}
	if m.BannerCount != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.BannerCount))
		i--
		dAtA[i] = 0x30
	}
	if m.CommentCount != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.CommentCount))
		i--
		dAtA[i] = 0x28
	}
	if m.ArticleCount != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.ArticleCount))
		i--
		dAtA[i] = 0x20
	}
	if m.CategoryCount != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.CategoryCount))
		i--
		dAtA[i] = 0x18
	}
	if m.DocumentCount != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.DocumentCount))
		i--
		dAtA[i] = 0x10
	}
	if m.UserCount != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.UserCount))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintConfig(dAtA []byte, offset int, v uint64) int {
	offset -= sovConfig(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Config) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovConfig(uint64(m.Id))
	}
	l = len(m.Label)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Placeholder)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.InputType)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Category)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.Sort != 0 {
		n += 1 + sovConfig(uint64(m.Sort))
	}
	l = len(m.Options)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.CreatedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.CreatedAt)
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.UpdatedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.UpdatedAt)
		n += 1 + l + sovConfig(uint64(l))
	}
	return n
}

func (m *ListConfigRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Category) > 0 {
		for _, s := range m.Category {
			l = len(s)
			n += 1 + l + sovConfig(uint64(l))
		}
	}
	return n
}

func (m *Configs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Config) > 0 {
		for _, e := range m.Config {
			l = e.Size()
			n += 1 + l + sovConfig(uint64(l))
		}
	}
	return n
}

func (m *ConfigCaptcha) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Length != 0 {
		n += 1 + sovConfig(uint64(m.Length))
	}
	if m.Width != 0 {
		n += 1 + sovConfig(uint64(m.Width))
	}
	if m.Height != 0 {
		n += 1 + sovConfig(uint64(m.Height))
	}
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	return n
}

func (m *ConfigSystem) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Domain)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Keywords)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Logo)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Favicon)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Icp)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Analytics)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Sitename)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.CopyrightStartYear)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.RegisterBackground)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.LoginBackground)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if len(m.RecommendWords) > 0 {
		for _, s := range m.RecommendWords {
			l = len(s)
			n += 1 + l + sovConfig(uint64(l))
		}
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	return n
}

func (m *ConfigFooter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.About)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Contact)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Agreement)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Copyright)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Feedback)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	return n
}

func (m *ConfigSecurity) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IsClose {
		n += 2
	}
	l = len(m.CloseStatement)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.EnableRegister {
		n += 2
	}
	if m.EnableCaptchaLogin {
		n += 2
	}
	if m.EnableCaptchaRegister {
		n += 2
	}
	if m.EnableCaptchaComment {
		n += 2
	}
	if m.EnableCaptchaFindPassword {
		n += 2
	}
	if m.EnableCaptchaUpload {
		n += 2
	}
	if m.MaxDocumentSize != 0 {
		n += 1 + sovConfig(uint64(m.MaxDocumentSize))
	}
	if len(m.DocumentAllowedExt) > 0 {
		for _, s := range m.DocumentAllowedExt {
			l = len(s)
			n += 1 + l + sovConfig(uint64(l))
		}
	}
	return n
}

func (m *Settings) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.System != nil {
		l = m.System.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.Footer != nil {
		l = m.Footer.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.Security != nil {
		l = m.Security.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	return n
}

func (m *EnvDependent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.IsInstalled {
		n += 2
	}
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.CheckedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.CheckedAt)
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Cmd)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.IsRequired {
		n += 2
	}
	return n
}

func (m *Envs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Envs) > 0 {
		for _, e := range m.Envs {
			l = e.Size()
			n += 1 + l + sovConfig(uint64(l))
		}
	}
	return n
}

func (m *Stats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UserCount != 0 {
		n += 1 + sovConfig(uint64(m.UserCount))
	}
	if m.DocumentCount != 0 {
		n += 1 + sovConfig(uint64(m.DocumentCount))
	}
	if m.CategoryCount != 0 {
		n += 1 + sovConfig(uint64(m.CategoryCount))
	}
	if m.ArticleCount != 0 {
		n += 1 + sovConfig(uint64(m.ArticleCount))
	}
	if m.CommentCount != 0 {
		n += 1 + sovConfig(uint64(m.CommentCount))
	}
	if m.BannerCount != 0 {
		n += 1 + sovConfig(uint64(m.BannerCount))
	}
	if m.FriendlinkCount != 0 {
		n += 1 + sovConfig(uint64(m.FriendlinkCount))
	}
	l = len(m.Os)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.BuildAt)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.ReportCount != 0 {
		n += 1 + sovConfig(uint64(m.ReportCount))
	}
	return n
}

func sovConfig(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozConfig(x uint64) (n int) {
	return sovConfig(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Config) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Config: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Config: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Label = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Placeholder", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Placeholder = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InputType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InputType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Category", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Category = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType)
			}
			m.Sort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sort |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Options = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CreatedAt == nil {
				m.CreatedAt = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.CreatedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UpdatedAt == nil {
				m.UpdatedAt = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ListConfigRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListConfigRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Category", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Category = append(m.Category, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Configs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Configs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Configs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Config = append(m.Config, &Config{})
			if err := m.Config[len(m.Config)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConfigCaptcha) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConfigCaptcha: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConfigCaptcha: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType)
			}
			m.Length = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Length |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType)
			}
			m.Width = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Width |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConfigSystem) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConfigSystem: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConfigSystem: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Domain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Domain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Keywords", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Keywords = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Logo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Logo = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Favicon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Favicon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Icp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Icp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Analytics", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Analytics = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sitename", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sitename = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CopyrightStartYear", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CopyrightStartYear = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegisterBackground", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RegisterBackground = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LoginBackground", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LoginBackground = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecommendWords", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecommendWords = append(m.RecommendWords, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConfigFooter) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConfigFooter: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConfigFooter: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field About", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.About = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Contact", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Contact = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Agreement", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Agreement = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Copyright", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Copyright = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Feedback", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Feedback = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConfigSecurity) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConfigSecurity: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConfigSecurity: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsClose", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsClose = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CloseStatement", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CloseStatement = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableRegister", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableRegister = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableCaptchaLogin", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableCaptchaLogin = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableCaptchaRegister", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableCaptchaRegister = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableCaptchaComment", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableCaptchaComment = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableCaptchaFindPassword", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableCaptchaFindPassword = bool(v != 0)
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableCaptchaUpload", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableCaptchaUpload = bool(v != 0)
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxDocumentSize", wireType)
			}
			m.MaxDocumentSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxDocumentSize |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DocumentAllowedExt", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DocumentAllowedExt = append(m.DocumentAllowedExt, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Settings) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Settings: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Settings: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field System", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.System == nil {
				m.System = &ConfigSystem{}
			}
			if err := m.System.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Footer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Footer == nil {
				m.Footer = &ConfigFooter{}
			}
			if err := m.Footer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Security", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Security == nil {
				m.Security = &ConfigSecurity{}
			}
			if err := m.Security.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EnvDependent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EnvDependent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EnvDependent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsInstalled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsInstalled = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Error = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CheckedAt == nil {
				m.CheckedAt = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.CheckedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cmd", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cmd = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsRequired", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsRequired = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Envs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Envs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Envs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Envs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Envs = append(m.Envs, &EnvDependent{})
			if err := m.Envs[len(m.Envs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Stats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Stats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Stats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserCount", wireType)
			}
			m.UserCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DocumentCount", wireType)
			}
			m.DocumentCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DocumentCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CategoryCount", wireType)
			}
			m.CategoryCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CategoryCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArticleCount", wireType)
			}
			m.ArticleCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ArticleCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommentCount", wireType)
			}
			m.CommentCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommentCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BannerCount", wireType)
			}
			m.BannerCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BannerCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FriendlinkCount", wireType)
			}
			m.FriendlinkCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FriendlinkCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Os", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Os = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BuildAt", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BuildAt = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReportCount", wireType)
			}
			m.ReportCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReportCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipConfig(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthConfig
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupConfig
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthConfig
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthConfig        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowConfig          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupConfig = fmt.Errorf("proto: unexpected end of group")
)
