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

// The Apigee Mixer adapter provides Apigee's distributed authentication and quota policy checks
// as well as the ingestion of Istio telemetry for analysis and reporting.
//
// Important: The adapter is provided in an enhanced Mixer image. The default Mixer image must be replaced and the
// proper CRDs must be applied in order to use these features. Complete Apigee documentation on the concepts and usage
// of this adapter is available on the [Apigee Adapter for Istio](https://docs.apigee.com/api-platform/istio-adapter/concepts)
// site. For more information and product support, please [contact Apigee support](https://apigee.com/about/support/portal).
//
// This adapter supports the [authorization template](https://istio.io/docs/reference/config/policy-and-telemetry/templates/authorization/)
// and Apigee's [analytics template](https://istio.io/docs/reference/config/policy-and-telemetry/templates/analytics/).
//
// Example config:
//
// ```yaml
// apiVersion: config.istio.io/v1alpha2
// kind: apigee
// metadata:
//   name: apigee-handler
//   namespace: istio-system
// spec:
//   apigee_base: https://istioservices.apigee.net/edgemicro
//   customer_base: https://myorg-test.apigee.net/istio-auth
//   hybrid_config: /opt/apigee/customer/default.properties
//   org_name: myorg
//   env_name: test
//   key: mykey
//   secret: mysecret
//   temp_dir: /tmp/apigee-istio
//   client_timeout: 30s
//   allowUnverifiedSSLCert: false
//   products:
//     refresh_rate: 2m
//   analytics:
//     legacy_endpoint: false
//     file_limit: 1024
//   auth:
//     api_key_claim:
//     api_key_cache_duration: 30m
// ```

package config

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	reflect "reflect"
	strings "strings"
)

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

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

// The Configuration for the Apigee adapter provides information on how the adapter should contact
// the Apigee proxies and how it should operate. Running the `apigee-istio provision` CLI command
// will ensure that all proxies are installed into your Apigee environment and generate this file
// with all required settings for you.
// For additional information on this adapter or support please contact anchor-prega-support@google.com.
type Params struct {
	// Apigee Base is the URI for a shared proxy on Apigee.
	// Required.
	ApigeeBase string `protobuf:"bytes,1,opt,name=apigee_base,json=apigeeBase,proto3" json:"apigee_base,omitempty"`
	// Customer Base is the URI for an organization-specific proxy on Apigee.
	// Required.
	CustomerBase string `protobuf:"bytes,2,opt,name=customer_base,json=customerBase,proto3" json:"customer_base,omitempty"`
	// Org Name is the name of the organization on Apigee.
	// Required.
	OrgName string `protobuf:"bytes,3,opt,name=org_name,json=orgName,proto3" json:"org_name,omitempty"`
	// Env Name is the name of the environment on Apigee.
	// Required.
	EnvName string `protobuf:"bytes,4,opt,name=env_name,json=envName,proto3" json:"env_name,omitempty"`
	// Key is used to authenticate to the Apigee proxy endpoints, generated during provisioning.
	// Required.
	Key string `protobuf:"bytes,5,opt,name=key,proto3" json:"key,omitempty"`
	// Secret is used to authenticate to the Apigee proxy endpoints, generated during provisioning.
	// Required.
	Secret string `protobuf:"bytes,6,opt,name=secret,proto3" json:"secret,omitempty"`
	// The local directory to be used by the adapter for temporary files.
	// Optional. Default: "/tmp/apigee-istio".
	TempDir string `protobuf:"bytes,7,opt,name=temp_dir,json=tempDir,proto3" json:"temp_dir,omitempty"`
	// The timeout to be used for adapter requests to Apigee servers.
	// Optional. Default: "30s" (30 seconds).
	ClientTimeout *types.Duration `protobuf:"bytes,8,opt,name=client_timeout,json=clientTimeout,proto3" json:"client_timeout,omitempty"`
	// Set to true to allow an unknown server SSL Certificate (eg. self-signed)
	// Optional. Default: false.
	AllowUnverifiedSSLCert bool `protobuf:"varint,9,opt,name=allowUnverifiedSSLCert,proto3" json:"allowUnverifiedSSLCert,omitempty"`
	// Path to the local Apigee Hybrid configuration file.
	// Optional. Presence indicates Hybrid environment, must not be set for SaaS or OPDK.
	HybridConfig string `protobuf:"bytes,10,opt,name=hybrid_config,json=hybridConfig,proto3" json:"hybrid_config,omitempty"`
	// Options specific to to products handling.
	Products *ParamsProductOptions `protobuf:"bytes,15,opt,name=products,proto3" json:"products,omitempty"`
	// Options specific to to analytics handling.
	Analytics *ParamsAnalyticsOptions `protobuf:"bytes,16,opt,name=analytics,proto3" json:"analytics,omitempty"`
	// Options specific to to auth handling.
	Auth *ParamsAuthOptions `protobuf:"bytes,17,opt,name=auth,proto3" json:"auth,omitempty"`
}

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

var xxx_messageInfo_Params proto.InternalMessageInfo

// Options specific to to products handling.
type ParamsProductOptions struct {
	// The rate at which the list of products is refreshed from Apigee.
	// Optional. Default: "2m" (2 minutes).
	RefreshRate *types.Duration `protobuf:"bytes,1,opt,name=refresh_rate,json=refreshRate,proto3" json:"refresh_rate,omitempty"`
}

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

var xxx_messageInfo_ParamsProductOptions proto.InternalMessageInfo

// Options specific to to analytics handling.
type ParamsAnalyticsOptions struct {
	// If true, use legacy direct communication analytics protocol instead of buffering. Must be true for OPDK.
	// Optional. Default: false.
	LegacyEndpoint bool `protobuf:"varint,1,opt,name=legacy_endpoint,json=legacyEndpoint,proto3" json:"legacy_endpoint,omitempty"`
	// The number of analytics files that can be buffered before oldest files are dropped.
	// Optional. Default: 1024.
	FileLimit int64 `protobuf:"varint,2,opt,name=file_limit,json=fileLimit,proto3" json:"file_limit,omitempty"`
	// The size of the channel used to buffer rfecord sends in memory.
	// Optional. Default: 10.
	SendChannelSize int64 `protobuf:"varint,3,opt,name=send_channel_size,json=sendChannelSize,proto3" json:"send_channel_size,omitempty"`
	// How often spooled analytics are swept and sent to Apigee.
	// Optional. Default: "2m" (2 minutes).
	CollectionInterval *types.Duration `protobuf:"bytes,4,opt,name=collection_interval,json=collectionInterval,proto3" json:"collection_interval,omitempty"`
}

func (m *ParamsAnalyticsOptions) Reset()      { *m = ParamsAnalyticsOptions{} }
func (*ParamsAnalyticsOptions) ProtoMessage() {}
func (*ParamsAnalyticsOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_a328857fcf72425d, []int{0, 1}
}
func (m *ParamsAnalyticsOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ParamsAnalyticsOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ParamsAnalyticsOptions.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ParamsAnalyticsOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParamsAnalyticsOptions.Merge(m, src)
}
func (m *ParamsAnalyticsOptions) XXX_Size() int {
	return m.Size()
}
func (m *ParamsAnalyticsOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_ParamsAnalyticsOptions.DiscardUnknown(m)
}

var xxx_messageInfo_ParamsAnalyticsOptions proto.InternalMessageInfo

// Options specific to to auth handling.
type ParamsAuthOptions struct {
	// The length of time API Keys are valid in the cache.
	// Optional. Default: "30m" (30 minutes).
	ApiKeyCacheDuration *types.Duration `protobuf:"bytes,1,opt,name=api_key_cache_duration,json=apiKeyCacheDuration,proto3" json:"api_key_cache_duration,omitempty"`
	// The name of a JWT claim from which to look for an api_key.
	// Optional. Default: none.
	ApiKeyClaim string `protobuf:"bytes,2,opt,name=api_key_claim,json=apiKeyClaim,proto3" json:"api_key_claim,omitempty"`
}

func (m *ParamsAuthOptions) Reset()      { *m = ParamsAuthOptions{} }
func (*ParamsAuthOptions) ProtoMessage() {}
func (*ParamsAuthOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_a328857fcf72425d, []int{0, 2}
}
func (m *ParamsAuthOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ParamsAuthOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ParamsAuthOptions.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ParamsAuthOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParamsAuthOptions.Merge(m, src)
}
func (m *ParamsAuthOptions) XXX_Size() int {
	return m.Size()
}
func (m *ParamsAuthOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_ParamsAuthOptions.DiscardUnknown(m)
}

var xxx_messageInfo_ParamsAuthOptions proto.InternalMessageInfo

func init() {
	proto.RegisterType((*Params)(nil), "config.Params")
	proto.RegisterType((*ParamsProductOptions)(nil), "config.Params.product_options")
	proto.RegisterType((*ParamsAnalyticsOptions)(nil), "config.Params.analytics_options")
	proto.RegisterType((*ParamsAuthOptions)(nil), "config.Params.auth_options")
}

func init() { proto.RegisterFile("adapter/config/config.proto", fileDescriptor_a328857fcf72425d) }

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

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

func (m *Params) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ApigeeBase) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.ApigeeBase)))
		i += copy(dAtA[i:], m.ApigeeBase)
	}
	if len(m.CustomerBase) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.CustomerBase)))
		i += copy(dAtA[i:], m.CustomerBase)
	}
	if len(m.OrgName) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.OrgName)))
		i += copy(dAtA[i:], m.OrgName)
	}
	if len(m.EnvName) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.EnvName)))
		i += copy(dAtA[i:], m.EnvName)
	}
	if len(m.Key) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	if len(m.Secret) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Secret)))
		i += copy(dAtA[i:], m.Secret)
	}
	if len(m.TempDir) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.TempDir)))
		i += copy(dAtA[i:], m.TempDir)
	}
	if m.ClientTimeout != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.ClientTimeout.Size()))
		n1, err := m.ClientTimeout.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.AllowUnverifiedSSLCert {
		dAtA[i] = 0x48
		i++
		if m.AllowUnverifiedSSLCert {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.HybridConfig) > 0 {
		dAtA[i] = 0x52
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.HybridConfig)))
		i += copy(dAtA[i:], m.HybridConfig)
	}
	if m.Products != nil {
		dAtA[i] = 0x7a
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.Products.Size()))
		n2, err := m.Products.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.Analytics != nil {
		dAtA[i] = 0x82
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.Analytics.Size()))
		n3, err := m.Analytics.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.Auth != nil {
		dAtA[i] = 0x8a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.Auth.Size()))
		n4, err := m.Auth.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	return i, nil
}

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

func (m *ParamsProductOptions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.RefreshRate != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.RefreshRate.Size()))
		n5, err := m.RefreshRate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	return i, nil
}

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

func (m *ParamsAnalyticsOptions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.LegacyEndpoint {
		dAtA[i] = 0x8
		i++
		if m.LegacyEndpoint {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.FileLimit != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.FileLimit))
	}
	if m.SendChannelSize != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.SendChannelSize))
	}
	if m.CollectionInterval != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.CollectionInterval.Size()))
		n6, err := m.CollectionInterval.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	return i, nil
}

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

func (m *ParamsAuthOptions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ApiKeyCacheDuration != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.ApiKeyCacheDuration.Size()))
		n7, err := m.ApiKeyCacheDuration.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if len(m.ApiKeyClaim) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.ApiKeyClaim)))
		i += copy(dAtA[i:], m.ApiKeyClaim)
	}
	return i, nil
}

func encodeVarintConfig(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *Params) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ApigeeBase)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.CustomerBase)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.OrgName)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.EnvName)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Secret)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.TempDir)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.ClientTimeout != nil {
		l = m.ClientTimeout.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.AllowUnverifiedSSLCert {
		n += 2
	}
	l = len(m.HybridConfig)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.Products != nil {
		l = m.Products.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.Analytics != nil {
		l = m.Analytics.Size()
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.Auth != nil {
		l = m.Auth.Size()
		n += 2 + l + sovConfig(uint64(l))
	}
	return n
}

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

func (m *ParamsAnalyticsOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LegacyEndpoint {
		n += 2
	}
	if m.FileLimit != 0 {
		n += 1 + sovConfig(uint64(m.FileLimit))
	}
	if m.SendChannelSize != 0 {
		n += 1 + sovConfig(uint64(m.SendChannelSize))
	}
	if m.CollectionInterval != nil {
		l = m.CollectionInterval.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	return n
}

func (m *ParamsAuthOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ApiKeyCacheDuration != nil {
		l = m.ApiKeyCacheDuration.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.ApiKeyClaim)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	return n
}

func sovConfig(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozConfig(x uint64) (n int) {
	return sovConfig(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Params) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Params{`,
		`ApigeeBase:` + fmt.Sprintf("%v", this.ApigeeBase) + `,`,
		`CustomerBase:` + fmt.Sprintf("%v", this.CustomerBase) + `,`,
		`OrgName:` + fmt.Sprintf("%v", this.OrgName) + `,`,
		`EnvName:` + fmt.Sprintf("%v", this.EnvName) + `,`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`Secret:` + fmt.Sprintf("%v", this.Secret) + `,`,
		`TempDir:` + fmt.Sprintf("%v", this.TempDir) + `,`,
		`ClientTimeout:` + strings.Replace(fmt.Sprintf("%v", this.ClientTimeout), "Duration", "types.Duration", 1) + `,`,
		`AllowUnverifiedSSLCert:` + fmt.Sprintf("%v", this.AllowUnverifiedSSLCert) + `,`,
		`HybridConfig:` + fmt.Sprintf("%v", this.HybridConfig) + `,`,
		`Products:` + strings.Replace(fmt.Sprintf("%v", this.Products), "ParamsProductOptions", "ParamsProductOptions", 1) + `,`,
		`Analytics:` + strings.Replace(fmt.Sprintf("%v", this.Analytics), "ParamsAnalyticsOptions", "ParamsAnalyticsOptions", 1) + `,`,
		`Auth:` + strings.Replace(fmt.Sprintf("%v", this.Auth), "ParamsAuthOptions", "ParamsAuthOptions", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ParamsProductOptions) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ParamsProductOptions{`,
		`RefreshRate:` + strings.Replace(fmt.Sprintf("%v", this.RefreshRate), "Duration", "types.Duration", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ParamsAnalyticsOptions) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ParamsAnalyticsOptions{`,
		`LegacyEndpoint:` + fmt.Sprintf("%v", this.LegacyEndpoint) + `,`,
		`FileLimit:` + fmt.Sprintf("%v", this.FileLimit) + `,`,
		`SendChannelSize:` + fmt.Sprintf("%v", this.SendChannelSize) + `,`,
		`CollectionInterval:` + strings.Replace(fmt.Sprintf("%v", this.CollectionInterval), "Duration", "types.Duration", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ParamsAuthOptions) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ParamsAuthOptions{`,
		`ApiKeyCacheDuration:` + strings.Replace(fmt.Sprintf("%v", this.ApiKeyCacheDuration), "Duration", "types.Duration", 1) + `,`,
		`ApiKeyClaim:` + fmt.Sprintf("%v", this.ApiKeyClaim) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringConfig(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Params) 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: Params: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApigeeBase", 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.ApigeeBase = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomerBase", 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.CustomerBase = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgName", 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.OrgName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnvName", 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.EnvName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", 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.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Secret", 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.Secret = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TempDir", 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.TempDir = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientTimeout", 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.ClientTimeout == nil {
				m.ClientTimeout = &types.Duration{}
			}
			if err := m.ClientTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllowUnverifiedSSLCert", 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.AllowUnverifiedSSLCert = bool(v != 0)
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HybridConfig", 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.HybridConfig = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Products", 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.Products == nil {
				m.Products = &ParamsProductOptions{}
			}
			if err := m.Products.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Analytics", 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.Analytics == nil {
				m.Analytics = &ParamsAnalyticsOptions{}
			}
			if err := m.Analytics.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Auth", 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.Auth == nil {
				m.Auth = &ParamsAuthOptions{}
			}
			if err := m.Auth.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 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ParamsProductOptions) 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: product_options: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: product_options: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RefreshRate", 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.RefreshRate == nil {
				m.RefreshRate = &types.Duration{}
			}
			if err := m.RefreshRate.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 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ParamsAnalyticsOptions) 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: analytics_options: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: analytics_options: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LegacyEndpoint", 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.LegacyEndpoint = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileLimit", wireType)
			}
			m.FileLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FileLimit |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SendChannelSize", wireType)
			}
			m.SendChannelSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SendChannelSize |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollectionInterval", 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.CollectionInterval == nil {
				m.CollectionInterval = &types.Duration{}
			}
			if err := m.CollectionInterval.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 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ParamsAuthOptions) 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: auth_options: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: auth_options: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApiKeyCacheDuration", 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.ApiKeyCacheDuration == nil {
				m.ApiKeyCacheDuration = &types.Duration{}
			}
			if err := m.ApiKeyCacheDuration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApiKeyClaim", 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.ApiKeyClaim = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthConfig
			}
			if (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
	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
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		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
			if iNdEx < 0 {
				return 0, ErrInvalidLengthConfig
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowConfig
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipConfig(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthConfig
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthConfig = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowConfig   = fmt.Errorf("proto: integer overflow")
)
