repository.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: server/repository/repository.proto

// Repository Service
//
// Repository Service API performs CRUD actions against repository resources

package repository

import (
	context "context"
	fmt "fmt"
	v1alpha1 "github.com/argoproj/argo-cd/pkg/apis/application/v1alpha1"
	apiclient "github.com/argoproj/argo-cd/reposerver/apiclient"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	_ "k8s.io/api/core/v1"
	math "math"
	math_bits "math/bits"
)

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

// RepoAppsQuery is a query for Repository apps
type RepoAppsQuery struct {
	Repo                 string   `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"`
	Revision             string   `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RepoAppsQuery) Reset()         { *m = RepoAppsQuery{} }
func (m *RepoAppsQuery) String() string { return proto.CompactTextString(m) }
func (*RepoAppsQuery) ProtoMessage()    {}
func (*RepoAppsQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_8d38260443475705, []int{0}
}
func (m *RepoAppsQuery) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RepoAppsQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RepoAppsQuery.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 *RepoAppsQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RepoAppsQuery.Merge(m, src)
}
func (m *RepoAppsQuery) XXX_Size() int {
	return m.Size()
}
func (m *RepoAppsQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_RepoAppsQuery.DiscardUnknown(m)
}

var xxx_messageInfo_RepoAppsQuery proto.InternalMessageInfo

func (m *RepoAppsQuery) GetRepo() string {
	if m != nil {
		return m.Repo
	}
	return ""
}

func (m *RepoAppsQuery) GetRevision() string {
	if m != nil {
		return m.Revision
	}
	return ""
}

// AppInfo contains application type and app file path
type AppInfo struct {
	Type                 string   `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Path                 string   `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AppInfo) Reset()         { *m = AppInfo{} }
func (m *AppInfo) String() string { return proto.CompactTextString(m) }
func (*AppInfo) ProtoMessage()    {}
func (*AppInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_8d38260443475705, []int{1}
}
func (m *AppInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AppInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AppInfo.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 *AppInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AppInfo.Merge(m, src)
}
func (m *AppInfo) XXX_Size() int {
	return m.Size()
}
func (m *AppInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_AppInfo.DiscardUnknown(m)
}

var xxx_messageInfo_AppInfo proto.InternalMessageInfo

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

func (m *AppInfo) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

// RepoAppDetailsQuery contains query information for app details request
type RepoAppDetailsQuery struct {
	Source               *v1alpha1.ApplicationSource `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (m *RepoAppDetailsQuery) Reset()         { *m = RepoAppDetailsQuery{} }
func (m *RepoAppDetailsQuery) String() string { return proto.CompactTextString(m) }
func (*RepoAppDetailsQuery) ProtoMessage()    {}
func (*RepoAppDetailsQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_8d38260443475705, []int{2}
}
func (m *RepoAppDetailsQuery) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RepoAppDetailsQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RepoAppDetailsQuery.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 *RepoAppDetailsQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RepoAppDetailsQuery.Merge(m, src)
}
func (m *RepoAppDetailsQuery) XXX_Size() int {
	return m.Size()
}
func (m *RepoAppDetailsQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_RepoAppDetailsQuery.DiscardUnknown(m)
}

var xxx_messageInfo_RepoAppDetailsQuery proto.InternalMessageInfo

func (m *RepoAppDetailsQuery) GetSource() *v1alpha1.ApplicationSource {
	if m != nil {
		return m.Source
	}
	return nil
}

// RepoAppsResponse contains applications of specified repository
type RepoAppsResponse struct {
	Items                []*AppInfo `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *RepoAppsResponse) Reset()         { *m = RepoAppsResponse{} }
func (m *RepoAppsResponse) String() string { return proto.CompactTextString(m) }
func (*RepoAppsResponse) ProtoMessage()    {}
func (*RepoAppsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8d38260443475705, []int{3}
}
func (m *RepoAppsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RepoAppsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RepoAppsResponse.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 *RepoAppsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RepoAppsResponse.Merge(m, src)
}
func (m *RepoAppsResponse) XXX_Size() int {
	return m.Size()
}
func (m *RepoAppsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RepoAppsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RepoAppsResponse proto.InternalMessageInfo

func (m *RepoAppsResponse) GetItems() []*AppInfo {
	if m != nil {
		return m.Items
	}
	return nil
}

// RepoQuery is a query for Repository resources
type RepoQuery struct {
	// Repo URL for query
	Repo string `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"`
	// Whether to force a cache refresh on repo's connection state
	ForceRefresh         bool     `protobuf:"varint,2,opt,name=forceRefresh,proto3" json:"forceRefresh,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RepoQuery) Reset()         { *m = RepoQuery{} }
func (m *RepoQuery) String() string { return proto.CompactTextString(m) }
func (*RepoQuery) ProtoMessage()    {}
func (*RepoQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_8d38260443475705, []int{4}
}
func (m *RepoQuery) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RepoQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RepoQuery.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 *RepoQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RepoQuery.Merge(m, src)
}
func (m *RepoQuery) XXX_Size() int {
	return m.Size()
}
func (m *RepoQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_RepoQuery.DiscardUnknown(m)
}

var xxx_messageInfo_RepoQuery proto.InternalMessageInfo

func (m *RepoQuery) GetRepo() string {
	if m != nil {
		return m.Repo
	}
	return ""
}

func (m *RepoQuery) GetForceRefresh() bool {
	if m != nil {
		return m.ForceRefresh
	}
	return false
}

// RepoAccessQuery is a query for checking access to a repo
type RepoAccessQuery struct {
	// The URL to the repo
	Repo string `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"`
	// Username for accessing repo
	Username string `protobuf:"bytes,2,opt,name=username,proto3" json:"username,omitempty"`
	// Password for accessing repo
	Password string `protobuf:"bytes,3,opt,name=password,proto3" json:"password,omitempty"`
	// Private key data for accessing SSH repository
	SshPrivateKey string `protobuf:"bytes,4,opt,name=sshPrivateKey,proto3" json:"sshPrivateKey,omitempty"`
	// Whether to skip certificate or host key validation
	Insecure bool `protobuf:"varint,5,opt,name=insecure,proto3" json:"insecure,omitempty"`
	// TLS client cert data for accessing HTTPS repository
	TlsClientCertData string `protobuf:"bytes,6,opt,name=tlsClientCertData,proto3" json:"tlsClientCertData,omitempty"`
	// TLS client cert key for accessing HTTPS repository
	TlsClientCertKey string `protobuf:"bytes,7,opt,name=tlsClientCertKey,proto3" json:"tlsClientCertKey,omitempty"`
	// The type of the repo
	Type string `protobuf:"bytes,9,opt,name=type,proto3" json:"type,omitempty"`
	// The name of the repo
	Name                 string   `protobuf:"bytes,10,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RepoAccessQuery) Reset()         { *m = RepoAccessQuery{} }
func (m *RepoAccessQuery) String() string { return proto.CompactTextString(m) }
func (*RepoAccessQuery) ProtoMessage()    {}
func (*RepoAccessQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_8d38260443475705, []int{5}
}
func (m *RepoAccessQuery) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RepoAccessQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RepoAccessQuery.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 *RepoAccessQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RepoAccessQuery.Merge(m, src)
}
func (m *RepoAccessQuery) XXX_Size() int {
	return m.Size()
}
func (m *RepoAccessQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_RepoAccessQuery.DiscardUnknown(m)
}

var xxx_messageInfo_RepoAccessQuery proto.InternalMessageInfo

func (m *RepoAccessQuery) GetRepo() string {
	if m != nil {
		return m.Repo
	}
	return ""
}

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

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

func (m *RepoAccessQuery) GetSshPrivateKey() string {
	if m != nil {
		return m.SshPrivateKey
	}
	return ""
}

func (m *RepoAccessQuery) GetInsecure() bool {
	if m != nil {
		return m.Insecure
	}
	return false
}

func (m *RepoAccessQuery) GetTlsClientCertData() string {
	if m != nil {
		return m.TlsClientCertData
	}
	return ""
}

func (m *RepoAccessQuery) GetTlsClientCertKey() string {
	if m != nil {
		return m.TlsClientCertKey
	}
	return ""
}

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

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

type RepoResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RepoResponse) Reset()         { *m = RepoResponse{} }
func (m *RepoResponse) String() string { return proto.CompactTextString(m) }
func (*RepoResponse) ProtoMessage()    {}
func (*RepoResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8d38260443475705, []int{6}
}
func (m *RepoResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RepoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RepoResponse.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 *RepoResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RepoResponse.Merge(m, src)
}
func (m *RepoResponse) XXX_Size() int {
	return m.Size()
}
func (m *RepoResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RepoResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RepoResponse proto.InternalMessageInfo

// RepoCreateRequest is a request for creating repository config
type RepoCreateRequest struct {
	// Repository definition
	Repo *v1alpha1.Repository `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"`
	// Whether to create in upsert mode
	Upsert bool `protobuf:"varint,2,opt,name=upsert,proto3" json:"upsert,omitempty"`
	// Whether to operate on credential set instead of repository
	CredsOnly            bool     `protobuf:"varint,3,opt,name=credsOnly,proto3" json:"credsOnly,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RepoCreateRequest) Reset()         { *m = RepoCreateRequest{} }
func (m *RepoCreateRequest) String() string { return proto.CompactTextString(m) }
func (*RepoCreateRequest) ProtoMessage()    {}
func (*RepoCreateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8d38260443475705, []int{7}
}
func (m *RepoCreateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RepoCreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RepoCreateRequest.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 *RepoCreateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RepoCreateRequest.Merge(m, src)
}
func (m *RepoCreateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RepoCreateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RepoCreateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RepoCreateRequest proto.InternalMessageInfo

func (m *RepoCreateRequest) GetRepo() *v1alpha1.Repository {
	if m != nil {
		return m.Repo
	}
	return nil
}

func (m *RepoCreateRequest) GetUpsert() bool {
	if m != nil {
		return m.Upsert
	}
	return false
}

func (m *RepoCreateRequest) GetCredsOnly() bool {
	if m != nil {
		return m.CredsOnly
	}
	return false
}

type RepoUpdateRequest struct {
	Repo                 *v1alpha1.Repository `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *RepoUpdateRequest) Reset()         { *m = RepoUpdateRequest{} }
func (m *RepoUpdateRequest) String() string { return proto.CompactTextString(m) }
func (*RepoUpdateRequest) ProtoMessage()    {}
func (*RepoUpdateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8d38260443475705, []int{8}
}
func (m *RepoUpdateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RepoUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RepoUpdateRequest.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 *RepoUpdateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RepoUpdateRequest.Merge(m, src)
}
func (m *RepoUpdateRequest) XXX_Size() int {
	return m.Size()
}
func (m *RepoUpdateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RepoUpdateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RepoUpdateRequest proto.InternalMessageInfo

func (m *RepoUpdateRequest) GetRepo() *v1alpha1.Repository {
	if m != nil {
		return m.Repo
	}
	return nil
}

func init() {
	proto.RegisterType((*RepoAppsQuery)(nil), "repository.RepoAppsQuery")
	proto.RegisterType((*AppInfo)(nil), "repository.AppInfo")
	proto.RegisterType((*RepoAppDetailsQuery)(nil), "repository.RepoAppDetailsQuery")
	proto.RegisterType((*RepoAppsResponse)(nil), "repository.RepoAppsResponse")
	proto.RegisterType((*RepoQuery)(nil), "repository.RepoQuery")
	proto.RegisterType((*RepoAccessQuery)(nil), "repository.RepoAccessQuery")
	proto.RegisterType((*RepoResponse)(nil), "repository.RepoResponse")
	proto.RegisterType((*RepoCreateRequest)(nil), "repository.RepoCreateRequest")
	proto.RegisterType((*RepoUpdateRequest)(nil), "repository.RepoUpdateRequest")
}

func init() {
	proto.RegisterFile("server/repository/repository.proto", fileDescriptor_8d38260443475705)
}

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

// RepositoryServiceClient is the client API for RepositoryService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RepositoryServiceClient interface {
	// List returns list of repos or repository credentials
	List(ctx context.Context, in *RepoQuery, opts ...grpc.CallOption) (*v1alpha1.RepositoryList, error)
	// ListRepositories gets a list of all configured repositories
	ListRepositories(ctx context.Context, in *RepoQuery, opts ...grpc.CallOption) (*v1alpha1.RepositoryList, error)
	// ListApps returns list of apps in the repo
	ListApps(ctx context.Context, in *RepoAppsQuery, opts ...grpc.CallOption) (*RepoAppsResponse, error)
	// GetAppDetails returns application details by given path
	GetAppDetails(ctx context.Context, in *RepoAppDetailsQuery, opts ...grpc.CallOption) (*apiclient.RepoAppDetailsResponse, error)
	GetHelmCharts(ctx context.Context, in *RepoQuery, opts ...grpc.CallOption) (*apiclient.HelmChartsResponse, error)
	// Create creates a repo or a repo credential set
	Create(ctx context.Context, in *RepoCreateRequest, opts ...grpc.CallOption) (*v1alpha1.Repository, error)
	// CreateRepository creates a new repository configuration
	CreateRepository(ctx context.Context, in *RepoCreateRequest, opts ...grpc.CallOption) (*v1alpha1.Repository, error)
	// Update updates a repo or repo credential set
	Update(ctx context.Context, in *RepoUpdateRequest, opts ...grpc.CallOption) (*v1alpha1.Repository, error)
	// UpdateRepository updates a repository configuration
	UpdateRepository(ctx context.Context, in *RepoUpdateRequest, opts ...grpc.CallOption) (*v1alpha1.Repository, error)
	// Delete deletes a repository from the configuration
	Delete(ctx context.Context, in *RepoQuery, opts ...grpc.CallOption) (*RepoResponse, error)
	// DeleteRepository deletes a repository from the configuration
	DeleteRepository(ctx context.Context, in *RepoQuery, opts ...grpc.CallOption) (*RepoResponse, error)
	// ValidateAccess validates access to a repository with given parameters
	ValidateAccess(ctx context.Context, in *RepoAccessQuery, opts ...grpc.CallOption) (*RepoResponse, error)
}

type repositoryServiceClient struct {
	cc *grpc.ClientConn
}

func NewRepositoryServiceClient(cc *grpc.ClientConn) RepositoryServiceClient {
	return &repositoryServiceClient{cc}
}

// Deprecated: Do not use.
func (c *repositoryServiceClient) List(ctx context.Context, in *RepoQuery, opts ...grpc.CallOption) (*v1alpha1.RepositoryList, error) {
	out := new(v1alpha1.RepositoryList)
	err := c.cc.Invoke(ctx, "/repository.RepositoryService/List", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *repositoryServiceClient) ListRepositories(ctx context.Context, in *RepoQuery, opts ...grpc.CallOption) (*v1alpha1.RepositoryList, error) {
	out := new(v1alpha1.RepositoryList)
	err := c.cc.Invoke(ctx, "/repository.RepositoryService/ListRepositories", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *repositoryServiceClient) ListApps(ctx context.Context, in *RepoAppsQuery, opts ...grpc.CallOption) (*RepoAppsResponse, error) {
	out := new(RepoAppsResponse)
	err := c.cc.Invoke(ctx, "/repository.RepositoryService/ListApps", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *repositoryServiceClient) GetAppDetails(ctx context.Context, in *RepoAppDetailsQuery, opts ...grpc.CallOption) (*apiclient.RepoAppDetailsResponse, error) {
	out := new(apiclient.RepoAppDetailsResponse)
	err := c.cc.Invoke(ctx, "/repository.RepositoryService/GetAppDetails", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *repositoryServiceClient) GetHelmCharts(ctx context.Context, in *RepoQuery, opts ...grpc.CallOption) (*apiclient.HelmChartsResponse, error) {
	out := new(apiclient.HelmChartsResponse)
	err := c.cc.Invoke(ctx, "/repository.RepositoryService/GetHelmCharts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Deprecated: Do not use.
func (c *repositoryServiceClient) Create(ctx context.Context, in *RepoCreateRequest, opts ...grpc.CallOption) (*v1alpha1.Repository, error) {
	out := new(v1alpha1.Repository)
	err := c.cc.Invoke(ctx, "/repository.RepositoryService/Create", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *repositoryServiceClient) CreateRepository(ctx context.Context, in *RepoCreateRequest, opts ...grpc.CallOption) (*v1alpha1.Repository, error) {
	out := new(v1alpha1.Repository)
	err := c.cc.Invoke(ctx, "/repository.RepositoryService/CreateRepository", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Deprecated: Do not use.
func (c *repositoryServiceClient) Update(ctx context.Context, in *RepoUpdateRequest, opts ...grpc.CallOption) (*v1alpha1.Repository, error) {
	out := new(v1alpha1.Repository)
	err := c.cc.Invoke(ctx, "/repository.RepositoryService/Update", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *repositoryServiceClient) UpdateRepository(ctx context.Context, in *RepoUpdateRequest, opts ...grpc.CallOption) (*v1alpha1.Repository, error) {
	out := new(v1alpha1.Repository)
	err := c.cc.Invoke(ctx, "/repository.RepositoryService/UpdateRepository", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Deprecated: Do not use.
func (c *repositoryServiceClient) Delete(ctx context.Context, in *RepoQuery, opts ...grpc.CallOption) (*RepoResponse, error) {
	out := new(RepoResponse)
	err := c.cc.Invoke(ctx, "/repository.RepositoryService/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *repositoryServiceClient) DeleteRepository(ctx context.Context, in *RepoQuery, opts ...grpc.CallOption) (*RepoResponse, error) {
	out := new(RepoResponse)
	err := c.cc.Invoke(ctx, "/repository.RepositoryService/DeleteRepository", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *repositoryServiceClient) ValidateAccess(ctx context.Context, in *RepoAccessQuery, opts ...grpc.CallOption) (*RepoResponse, error) {
	out := new(RepoResponse)
	err := c.cc.Invoke(ctx, "/repository.RepositoryService/ValidateAccess", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RepositoryServiceServer is the server API for RepositoryService service.
type RepositoryServiceServer interface {
	// List returns list of repos or repository credentials
	List(context.Context, *RepoQuery) (*v1alpha1.RepositoryList, error)
	// ListRepositories gets a list of all configured repositories
	ListRepositories(context.Context, *RepoQuery) (*v1alpha1.RepositoryList, error)
	// ListApps returns list of apps in the repo
	ListApps(context.Context, *RepoAppsQuery) (*RepoAppsResponse, error)
	// GetAppDetails returns application details by given path
	GetAppDetails(context.Context, *RepoAppDetailsQuery) (*apiclient.RepoAppDetailsResponse, error)
	GetHelmCharts(context.Context, *RepoQuery) (*apiclient.HelmChartsResponse, error)
	// Create creates a repo or a repo credential set
	Create(context.Context, *RepoCreateRequest) (*v1alpha1.Repository, error)
	// CreateRepository creates a new repository configuration
	CreateRepository(context.Context, *RepoCreateRequest) (*v1alpha1.Repository, error)
	// Update updates a repo or repo credential set
	Update(context.Context, *RepoUpdateRequest) (*v1alpha1.Repository, error)
	// UpdateRepository updates a repository configuration
	UpdateRepository(context.Context, *RepoUpdateRequest) (*v1alpha1.Repository, error)
	// Delete deletes a repository from the configuration
	Delete(context.Context, *RepoQuery) (*RepoResponse, error)
	// DeleteRepository deletes a repository from the configuration
	DeleteRepository(context.Context, *RepoQuery) (*RepoResponse, error)
	// ValidateAccess validates access to a repository with given parameters
	ValidateAccess(context.Context, *RepoAccessQuery) (*RepoResponse, error)
}

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

func (*UnimplementedRepositoryServiceServer) List(ctx context.Context, req *RepoQuery) (*v1alpha1.RepositoryList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
}
func (*UnimplementedRepositoryServiceServer) ListRepositories(ctx context.Context, req *RepoQuery) (*v1alpha1.RepositoryList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListRepositories not implemented")
}
func (*UnimplementedRepositoryServiceServer) ListApps(ctx context.Context, req *RepoAppsQuery) (*RepoAppsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListApps not implemented")
}
func (*UnimplementedRepositoryServiceServer) GetAppDetails(ctx context.Context, req *RepoAppDetailsQuery) (*apiclient.RepoAppDetailsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAppDetails not implemented")
}
func (*UnimplementedRepositoryServiceServer) GetHelmCharts(ctx context.Context, req *RepoQuery) (*apiclient.HelmChartsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHelmCharts not implemented")
}
func (*UnimplementedRepositoryServiceServer) Create(ctx context.Context, req *RepoCreateRequest) (*v1alpha1.Repository, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Create not implemented")
}
func (*UnimplementedRepositoryServiceServer) CreateRepository(ctx context.Context, req *RepoCreateRequest) (*v1alpha1.Repository, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateRepository not implemented")
}
func (*UnimplementedRepositoryServiceServer) Update(ctx context.Context, req *RepoUpdateRequest) (*v1alpha1.Repository, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Update not implemented")
}
func (*UnimplementedRepositoryServiceServer) UpdateRepository(ctx context.Context, req *RepoUpdateRequest) (*v1alpha1.Repository, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateRepository not implemented")
}
func (*UnimplementedRepositoryServiceServer) Delete(ctx context.Context, req *RepoQuery) (*RepoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (*UnimplementedRepositoryServiceServer) DeleteRepository(ctx context.Context, req *RepoQuery) (*RepoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteRepository not implemented")
}
func (*UnimplementedRepositoryServiceServer) ValidateAccess(ctx context.Context, req *RepoAccessQuery) (*RepoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ValidateAccess not implemented")
}

func RegisterRepositoryServiceServer(s *grpc.Server, srv RepositoryServiceServer) {
	s.RegisterService(&_RepositoryService_serviceDesc, srv)
}

func _RepositoryService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RepoQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RepositoryServiceServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/repository.RepositoryService/List",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RepositoryServiceServer).List(ctx, req.(*RepoQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _RepositoryService_ListRepositories_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RepoQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RepositoryServiceServer).ListRepositories(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/repository.RepositoryService/ListRepositories",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RepositoryServiceServer).ListRepositories(ctx, req.(*RepoQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _RepositoryService_ListApps_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RepoAppsQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RepositoryServiceServer).ListApps(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/repository.RepositoryService/ListApps",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RepositoryServiceServer).ListApps(ctx, req.(*RepoAppsQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _RepositoryService_GetAppDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RepoAppDetailsQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RepositoryServiceServer).GetAppDetails(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/repository.RepositoryService/GetAppDetails",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RepositoryServiceServer).GetAppDetails(ctx, req.(*RepoAppDetailsQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _RepositoryService_GetHelmCharts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RepoQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RepositoryServiceServer).GetHelmCharts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/repository.RepositoryService/GetHelmCharts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RepositoryServiceServer).GetHelmCharts(ctx, req.(*RepoQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _RepositoryService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RepoCreateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RepositoryServiceServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/repository.RepositoryService/Create",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RepositoryServiceServer).Create(ctx, req.(*RepoCreateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RepositoryService_CreateRepository_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RepoCreateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RepositoryServiceServer).CreateRepository(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/repository.RepositoryService/CreateRepository",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RepositoryServiceServer).CreateRepository(ctx, req.(*RepoCreateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RepositoryService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RepoUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RepositoryServiceServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/repository.RepositoryService/Update",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RepositoryServiceServer).Update(ctx, req.(*RepoUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RepositoryService_UpdateRepository_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RepoUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RepositoryServiceServer).UpdateRepository(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/repository.RepositoryService/UpdateRepository",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RepositoryServiceServer).UpdateRepository(ctx, req.(*RepoUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RepositoryService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RepoQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RepositoryServiceServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/repository.RepositoryService/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RepositoryServiceServer).Delete(ctx, req.(*RepoQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _RepositoryService_DeleteRepository_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RepoQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RepositoryServiceServer).DeleteRepository(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/repository.RepositoryService/DeleteRepository",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RepositoryServiceServer).DeleteRepository(ctx, req.(*RepoQuery))
	}
	return interceptor(ctx, in, info, handler)
}

func _RepositoryService_ValidateAccess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RepoAccessQuery)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RepositoryServiceServer).ValidateAccess(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/repository.RepositoryService/ValidateAccess",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RepositoryServiceServer).ValidateAccess(ctx, req.(*RepoAccessQuery))
	}
	return interceptor(ctx, in, info, handler)
}

var _RepositoryService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "repository.RepositoryService",
	HandlerType: (*RepositoryServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "List",
			Handler:    _RepositoryService_List_Handler,
		},
		{
			MethodName: "ListRepositories",
			Handler:    _RepositoryService_ListRepositories_Handler,
		},
		{
			MethodName: "ListApps",
			Handler:    _RepositoryService_ListApps_Handler,
		},
		{
			MethodName: "GetAppDetails",
			Handler:    _RepositoryService_GetAppDetails_Handler,
		},
		{
			MethodName: "GetHelmCharts",
			Handler:    _RepositoryService_GetHelmCharts_Handler,
		},
		{
			MethodName: "Create",
			Handler:    _RepositoryService_Create_Handler,
		},
		{
			MethodName: "CreateRepository",
			Handler:    _RepositoryService_CreateRepository_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _RepositoryService_Update_Handler,
		},
		{
			MethodName: "UpdateRepository",
			Handler:    _RepositoryService_UpdateRepository_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _RepositoryService_Delete_Handler,
		},
		{
			MethodName: "DeleteRepository",
			Handler:    _RepositoryService_DeleteRepository_Handler,
		},
		{
			MethodName: "ValidateAccess",
			Handler:    _RepositoryService_ValidateAccess_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "server/repository/repository.proto",
}

func (m *RepoAppsQuery) 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 *RepoAppsQuery) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RepoAppsQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Revision) > 0 {
		i -= len(m.Revision)
		copy(dAtA[i:], m.Revision)
		i = encodeVarintRepository(dAtA, i, uint64(len(m.Revision)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Repo) > 0 {
		i -= len(m.Repo)
		copy(dAtA[i:], m.Repo)
		i = encodeVarintRepository(dAtA, i, uint64(len(m.Repo)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AppInfo) 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 *AppInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AppInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintRepository(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintRepository(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RepoAppDetailsQuery) 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 *RepoAppDetailsQuery) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RepoAppDetailsQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Source != nil {
		{
			size, err := m.Source.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRepository(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RepoAppsResponse) 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 *RepoAppsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *RepoQuery) 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 *RepoQuery) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RepoQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ForceRefresh {
		i--
		if m.ForceRefresh {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.Repo) > 0 {
		i -= len(m.Repo)
		copy(dAtA[i:], m.Repo)
		i = encodeVarintRepository(dAtA, i, uint64(len(m.Repo)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RepoAccessQuery) 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 *RepoAccessQuery) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RepoAccessQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintRepository(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintRepository(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.TlsClientCertKey) > 0 {
		i -= len(m.TlsClientCertKey)
		copy(dAtA[i:], m.TlsClientCertKey)
		i = encodeVarintRepository(dAtA, i, uint64(len(m.TlsClientCertKey)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.TlsClientCertData) > 0 {
		i -= len(m.TlsClientCertData)
		copy(dAtA[i:], m.TlsClientCertData)
		i = encodeVarintRepository(dAtA, i, uint64(len(m.TlsClientCertData)))
		i--
		dAtA[i] = 0x32
	}
	if m.Insecure {
		i--
		if m.Insecure {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if len(m.SshPrivateKey) > 0 {
		i -= len(m.SshPrivateKey)
		copy(dAtA[i:], m.SshPrivateKey)
		i = encodeVarintRepository(dAtA, i, uint64(len(m.SshPrivateKey)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Password) > 0 {
		i -= len(m.Password)
		copy(dAtA[i:], m.Password)
		i = encodeVarintRepository(dAtA, i, uint64(len(m.Password)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Username) > 0 {
		i -= len(m.Username)
		copy(dAtA[i:], m.Username)
		i = encodeVarintRepository(dAtA, i, uint64(len(m.Username)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Repo) > 0 {
		i -= len(m.Repo)
		copy(dAtA[i:], m.Repo)
		i = encodeVarintRepository(dAtA, i, uint64(len(m.Repo)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RepoResponse) 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 *RepoResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RepoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *RepoCreateRequest) 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 *RepoCreateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RepoCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.CredsOnly {
		i--
		if m.CredsOnly {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.Upsert {
		i--
		if m.Upsert {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Repo != nil {
		{
			size, err := m.Repo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRepository(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RepoUpdateRequest) 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 *RepoUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RepoUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Repo != nil {
		{
			size, err := m.Repo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRepository(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintRepository(dAtA []byte, offset int, v uint64) int {
	offset -= sovRepository(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *RepoAppsQuery) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Repo)
	if l > 0 {
		n += 1 + l + sovRepository(uint64(l))
	}
	l = len(m.Revision)
	if l > 0 {
		n += 1 + l + sovRepository(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AppInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovRepository(uint64(l))
	}
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovRepository(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RepoAppDetailsQuery) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Source != nil {
		l = m.Source.Size()
		n += 1 + l + sovRepository(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *RepoQuery) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Repo)
	if l > 0 {
		n += 1 + l + sovRepository(uint64(l))
	}
	if m.ForceRefresh {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RepoAccessQuery) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Repo)
	if l > 0 {
		n += 1 + l + sovRepository(uint64(l))
	}
	l = len(m.Username)
	if l > 0 {
		n += 1 + l + sovRepository(uint64(l))
	}
	l = len(m.Password)
	if l > 0 {
		n += 1 + l + sovRepository(uint64(l))
	}
	l = len(m.SshPrivateKey)
	if l > 0 {
		n += 1 + l + sovRepository(uint64(l))
	}
	if m.Insecure {
		n += 2
	}
	l = len(m.TlsClientCertData)
	if l > 0 {
		n += 1 + l + sovRepository(uint64(l))
	}
	l = len(m.TlsClientCertKey)
	if l > 0 {
		n += 1 + l + sovRepository(uint64(l))
	}
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovRepository(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovRepository(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RepoResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RepoCreateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Repo != nil {
		l = m.Repo.Size()
		n += 1 + l + sovRepository(uint64(l))
	}
	if m.Upsert {
		n += 2
	}
	if m.CredsOnly {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RepoUpdateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Repo != nil {
		l = m.Repo.Size()
		n += 1 + l + sovRepository(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovRepository(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozRepository(x uint64) (n int) {
	return sovRepository(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *RepoAppsQuery) 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 ErrIntOverflowRepository
			}
			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: RepoAppsQuery: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RepoAppsQuery: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Repo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				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 ErrInvalidLengthRepository
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Repo = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				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 ErrInvalidLengthRepository
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Revision = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRepository(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AppInfo) 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 ErrIntOverflowRepository
			}
			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: AppInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AppInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowRepository
				}
				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 ErrInvalidLengthRepository
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				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 ErrInvalidLengthRepository
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRepository(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RepoAppDetailsQuery) 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 ErrIntOverflowRepository
			}
			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: RepoAppDetailsQuery: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RepoAppDetailsQuery: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRepository
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Source == nil {
				m.Source = &v1alpha1.ApplicationSource{}
			}
			if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRepository(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RepoAppsResponse) 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 ErrIntOverflowRepository
			}
			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: RepoAppsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RepoAppsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRepository
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, &AppInfo{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRepository(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RepoQuery) 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 ErrIntOverflowRepository
			}
			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: RepoQuery: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RepoQuery: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Repo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				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 ErrInvalidLengthRepository
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Repo = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForceRefresh", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ForceRefresh = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipRepository(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RepoAccessQuery) 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 ErrIntOverflowRepository
			}
			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: RepoAccessQuery: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RepoAccessQuery: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Repo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				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 ErrInvalidLengthRepository
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Repo = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				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 ErrInvalidLengthRepository
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				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 ErrInvalidLengthRepository
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Password = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SshPrivateKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				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 ErrInvalidLengthRepository
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SshPrivateKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Insecure", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Insecure = bool(v != 0)
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TlsClientCertData", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				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 ErrInvalidLengthRepository
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TlsClientCertData = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TlsClientCertKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				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 ErrInvalidLengthRepository
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TlsClientCertKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			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 ErrIntOverflowRepository
				}
				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 ErrInvalidLengthRepository
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			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 ErrIntOverflowRepository
				}
				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 ErrInvalidLengthRepository
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRepository(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RepoResponse) 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 ErrIntOverflowRepository
			}
			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: RepoResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RepoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipRepository(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RepoCreateRequest) 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 ErrIntOverflowRepository
			}
			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: RepoCreateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RepoCreateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Repo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRepository
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Repo == nil {
				m.Repo = &v1alpha1.Repository{}
			}
			if err := m.Repo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Upsert", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Upsert = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CredsOnly", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CredsOnly = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipRepository(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RepoUpdateRequest) 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 ErrIntOverflowRepository
			}
			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: RepoUpdateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RepoUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Repo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRepository
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRepository
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRepository
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Repo == nil {
				m.Repo = &v1alpha1.Repository{}
			}
			if err := m.Repo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRepository(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRepository
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipRepository(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, ErrIntOverflowRepository
			}
			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, ErrIntOverflowRepository
				}
				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, ErrIntOverflowRepository
				}
				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, ErrInvalidLengthRepository
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupRepository
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthRepository
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthRepository        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRepository          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupRepository = fmt.Errorf("proto: unexpected end of group")
)