// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: base/types/gfspserver/approval.proto

package gfspserver

import (
	context "context"
	fmt "fmt"
	gfsperrors "github.com/bnb-chain/greenfield-storage-provider/base/types/gfsperrors"
	gfsptask "github.com/bnb-chain/greenfield-storage-provider/base/types/gfsptask"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	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

type GfSpAskApprovalRequest struct {
	// Types that are valid to be assigned to Request:
	//	*GfSpAskApprovalRequest_CreateBucketApprovalTask
	//	*GfSpAskApprovalRequest_MigrateBucketApprovalTask
	//	*GfSpAskApprovalRequest_CreateObjectApprovalTask
	//	*GfSpAskApprovalRequest_DelegateCreateObjectApprovalTask
	Request isGfSpAskApprovalRequest_Request `protobuf_oneof:"request"`
}

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

var xxx_messageInfo_GfSpAskApprovalRequest proto.InternalMessageInfo

type isGfSpAskApprovalRequest_Request interface {
	isGfSpAskApprovalRequest_Request()
	MarshalTo([]byte) (int, error)
	Size() int
}

type GfSpAskApprovalRequest_CreateBucketApprovalTask struct {
	CreateBucketApprovalTask *gfsptask.GfSpCreateBucketApprovalTask `protobuf:"bytes,1,opt,name=create_bucket_approval_task,json=createBucketApprovalTask,proto3,oneof" json:"create_bucket_approval_task,omitempty"`
}
type GfSpAskApprovalRequest_MigrateBucketApprovalTask struct {
	MigrateBucketApprovalTask *gfsptask.GfSpMigrateBucketApprovalTask `protobuf:"bytes,2,opt,name=migrate_bucket_approval_task,json=migrateBucketApprovalTask,proto3,oneof" json:"migrate_bucket_approval_task,omitempty"`
}
type GfSpAskApprovalRequest_CreateObjectApprovalTask struct {
	CreateObjectApprovalTask *gfsptask.GfSpCreateObjectApprovalTask `protobuf:"bytes,3,opt,name=create_object_approval_task,json=createObjectApprovalTask,proto3,oneof" json:"create_object_approval_task,omitempty"`
}
type GfSpAskApprovalRequest_DelegateCreateObjectApprovalTask struct {
	DelegateCreateObjectApprovalTask *gfsptask.GfSpDelegateCreateObjectApprovalTask `protobuf:"bytes,4,opt,name=delegate_create_object_approval_task,json=delegateCreateObjectApprovalTask,proto3,oneof" json:"delegate_create_object_approval_task,omitempty"`
}

func (*GfSpAskApprovalRequest_CreateBucketApprovalTask) isGfSpAskApprovalRequest_Request()         {}
func (*GfSpAskApprovalRequest_MigrateBucketApprovalTask) isGfSpAskApprovalRequest_Request()        {}
func (*GfSpAskApprovalRequest_CreateObjectApprovalTask) isGfSpAskApprovalRequest_Request()         {}
func (*GfSpAskApprovalRequest_DelegateCreateObjectApprovalTask) isGfSpAskApprovalRequest_Request() {}

func (m *GfSpAskApprovalRequest) GetRequest() isGfSpAskApprovalRequest_Request {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *GfSpAskApprovalRequest) GetCreateBucketApprovalTask() *gfsptask.GfSpCreateBucketApprovalTask {
	if x, ok := m.GetRequest().(*GfSpAskApprovalRequest_CreateBucketApprovalTask); ok {
		return x.CreateBucketApprovalTask
	}
	return nil
}

func (m *GfSpAskApprovalRequest) GetMigrateBucketApprovalTask() *gfsptask.GfSpMigrateBucketApprovalTask {
	if x, ok := m.GetRequest().(*GfSpAskApprovalRequest_MigrateBucketApprovalTask); ok {
		return x.MigrateBucketApprovalTask
	}
	return nil
}

func (m *GfSpAskApprovalRequest) GetCreateObjectApprovalTask() *gfsptask.GfSpCreateObjectApprovalTask {
	if x, ok := m.GetRequest().(*GfSpAskApprovalRequest_CreateObjectApprovalTask); ok {
		return x.CreateObjectApprovalTask
	}
	return nil
}

func (m *GfSpAskApprovalRequest) GetDelegateCreateObjectApprovalTask() *gfsptask.GfSpDelegateCreateObjectApprovalTask {
	if x, ok := m.GetRequest().(*GfSpAskApprovalRequest_DelegateCreateObjectApprovalTask); ok {
		return x.DelegateCreateObjectApprovalTask
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*GfSpAskApprovalRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*GfSpAskApprovalRequest_CreateBucketApprovalTask)(nil),
		(*GfSpAskApprovalRequest_MigrateBucketApprovalTask)(nil),
		(*GfSpAskApprovalRequest_CreateObjectApprovalTask)(nil),
		(*GfSpAskApprovalRequest_DelegateCreateObjectApprovalTask)(nil),
	}
}

type GfSpAskApprovalResponse struct {
	Err     *gfsperrors.GfSpError `protobuf:"bytes,1,opt,name=err,proto3" json:"err,omitempty"`
	Allowed bool                  `protobuf:"varint,2,opt,name=allowed,proto3" json:"allowed,omitempty"`
	// Types that are valid to be assigned to Response:
	//	*GfSpAskApprovalResponse_CreateBucketApprovalTask
	//	*GfSpAskApprovalResponse_MigrateBucketApprovalTask
	//	*GfSpAskApprovalResponse_CreateObjectApprovalTask
	//	*GfSpAskApprovalResponse_DelegateCreateObjectApprovalTask
	Response isGfSpAskApprovalResponse_Response `protobuf_oneof:"response"`
}

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

var xxx_messageInfo_GfSpAskApprovalResponse proto.InternalMessageInfo

type isGfSpAskApprovalResponse_Response interface {
	isGfSpAskApprovalResponse_Response()
	MarshalTo([]byte) (int, error)
	Size() int
}

type GfSpAskApprovalResponse_CreateBucketApprovalTask struct {
	CreateBucketApprovalTask *gfsptask.GfSpCreateBucketApprovalTask `protobuf:"bytes,3,opt,name=create_bucket_approval_task,json=createBucketApprovalTask,proto3,oneof" json:"create_bucket_approval_task,omitempty"`
}
type GfSpAskApprovalResponse_MigrateBucketApprovalTask struct {
	MigrateBucketApprovalTask *gfsptask.GfSpMigrateBucketApprovalTask `protobuf:"bytes,4,opt,name=migrate_bucket_approval_task,json=migrateBucketApprovalTask,proto3,oneof" json:"migrate_bucket_approval_task,omitempty"`
}
type GfSpAskApprovalResponse_CreateObjectApprovalTask struct {
	CreateObjectApprovalTask *gfsptask.GfSpCreateObjectApprovalTask `protobuf:"bytes,5,opt,name=create_object_approval_task,json=createObjectApprovalTask,proto3,oneof" json:"create_object_approval_task,omitempty"`
}
type GfSpAskApprovalResponse_DelegateCreateObjectApprovalTask struct {
	DelegateCreateObjectApprovalTask *gfsptask.GfSpDelegateCreateObjectApprovalTask `protobuf:"bytes,6,opt,name=delegate_create_object_approval_task,json=delegateCreateObjectApprovalTask,proto3,oneof" json:"delegate_create_object_approval_task,omitempty"`
}

func (*GfSpAskApprovalResponse_CreateBucketApprovalTask) isGfSpAskApprovalResponse_Response()  {}
func (*GfSpAskApprovalResponse_MigrateBucketApprovalTask) isGfSpAskApprovalResponse_Response() {}
func (*GfSpAskApprovalResponse_CreateObjectApprovalTask) isGfSpAskApprovalResponse_Response()  {}
func (*GfSpAskApprovalResponse_DelegateCreateObjectApprovalTask) isGfSpAskApprovalResponse_Response() {
}

func (m *GfSpAskApprovalResponse) GetResponse() isGfSpAskApprovalResponse_Response {
	if m != nil {
		return m.Response
	}
	return nil
}

func (m *GfSpAskApprovalResponse) GetErr() *gfsperrors.GfSpError {
	if m != nil {
		return m.Err
	}
	return nil
}

func (m *GfSpAskApprovalResponse) GetAllowed() bool {
	if m != nil {
		return m.Allowed
	}
	return false
}

func (m *GfSpAskApprovalResponse) GetCreateBucketApprovalTask() *gfsptask.GfSpCreateBucketApprovalTask {
	if x, ok := m.GetResponse().(*GfSpAskApprovalResponse_CreateBucketApprovalTask); ok {
		return x.CreateBucketApprovalTask
	}
	return nil
}

func (m *GfSpAskApprovalResponse) GetMigrateBucketApprovalTask() *gfsptask.GfSpMigrateBucketApprovalTask {
	if x, ok := m.GetResponse().(*GfSpAskApprovalResponse_MigrateBucketApprovalTask); ok {
		return x.MigrateBucketApprovalTask
	}
	return nil
}

func (m *GfSpAskApprovalResponse) GetCreateObjectApprovalTask() *gfsptask.GfSpCreateObjectApprovalTask {
	if x, ok := m.GetResponse().(*GfSpAskApprovalResponse_CreateObjectApprovalTask); ok {
		return x.CreateObjectApprovalTask
	}
	return nil
}

func (m *GfSpAskApprovalResponse) GetDelegateCreateObjectApprovalTask() *gfsptask.GfSpDelegateCreateObjectApprovalTask {
	if x, ok := m.GetResponse().(*GfSpAskApprovalResponse_DelegateCreateObjectApprovalTask); ok {
		return x.DelegateCreateObjectApprovalTask
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*GfSpAskApprovalResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*GfSpAskApprovalResponse_CreateBucketApprovalTask)(nil),
		(*GfSpAskApprovalResponse_MigrateBucketApprovalTask)(nil),
		(*GfSpAskApprovalResponse_CreateObjectApprovalTask)(nil),
		(*GfSpAskApprovalResponse_DelegateCreateObjectApprovalTask)(nil),
	}
}

func init() {
	proto.RegisterType((*GfSpAskApprovalRequest)(nil), "base.types.gfspserver.GfSpAskApprovalRequest")
	proto.RegisterType((*GfSpAskApprovalResponse)(nil), "base.types.gfspserver.GfSpAskApprovalResponse")
}

func init() {
	proto.RegisterFile("base/types/gfspserver/approval.proto", fileDescriptor_486991960983872e)
}

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

// GfSpApprovalServiceClient is the client API for GfSpApprovalService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type GfSpApprovalServiceClient interface {
	GfSpAskApproval(ctx context.Context, in *GfSpAskApprovalRequest, opts ...grpc.CallOption) (*GfSpAskApprovalResponse, error)
}

type gfSpApprovalServiceClient struct {
	cc grpc1.ClientConn
}

func NewGfSpApprovalServiceClient(cc grpc1.ClientConn) GfSpApprovalServiceClient {
	return &gfSpApprovalServiceClient{cc}
}

func (c *gfSpApprovalServiceClient) GfSpAskApproval(ctx context.Context, in *GfSpAskApprovalRequest, opts ...grpc.CallOption) (*GfSpAskApprovalResponse, error) {
	out := new(GfSpAskApprovalResponse)
	err := c.cc.Invoke(ctx, "/base.types.gfspserver.GfSpApprovalService/GfSpAskApproval", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GfSpApprovalServiceServer is the server API for GfSpApprovalService service.
type GfSpApprovalServiceServer interface {
	GfSpAskApproval(context.Context, *GfSpAskApprovalRequest) (*GfSpAskApprovalResponse, error)
}

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

func (*UnimplementedGfSpApprovalServiceServer) GfSpAskApproval(ctx context.Context, req *GfSpAskApprovalRequest) (*GfSpAskApprovalResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GfSpAskApproval not implemented")
}

func RegisterGfSpApprovalServiceServer(s grpc1.Server, srv GfSpApprovalServiceServer) {
	s.RegisterService(&_GfSpApprovalService_serviceDesc, srv)
}

func _GfSpApprovalService_GfSpAskApproval_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GfSpAskApprovalRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GfSpApprovalServiceServer).GfSpAskApproval(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/base.types.gfspserver.GfSpApprovalService/GfSpAskApproval",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GfSpApprovalServiceServer).GfSpAskApproval(ctx, req.(*GfSpAskApprovalRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _GfSpApprovalService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "base.types.gfspserver.GfSpApprovalService",
	HandlerType: (*GfSpApprovalServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GfSpAskApproval",
			Handler:    _GfSpApprovalService_GfSpAskApproval_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "base/types/gfspserver/approval.proto",
}

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

func (m *GfSpAskApprovalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Request != nil {
		{
			size := m.Request.Size()
			i -= size
			if _, err := m.Request.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *GfSpAskApprovalRequest_CreateBucketApprovalTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CreateBucketApprovalTask != nil {
		{
			size, err := m.CreateBucketApprovalTask.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApproval(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *GfSpAskApprovalRequest_MigrateBucketApprovalTask) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpAskApprovalRequest_MigrateBucketApprovalTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MigrateBucketApprovalTask != nil {
		{
			size, err := m.MigrateBucketApprovalTask.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApproval(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *GfSpAskApprovalRequest_CreateObjectApprovalTask) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpAskApprovalRequest_CreateObjectApprovalTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CreateObjectApprovalTask != nil {
		{
			size, err := m.CreateObjectApprovalTask.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApproval(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *GfSpAskApprovalRequest_DelegateCreateObjectApprovalTask) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpAskApprovalRequest_DelegateCreateObjectApprovalTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DelegateCreateObjectApprovalTask != nil {
		{
			size, err := m.DelegateCreateObjectApprovalTask.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApproval(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *GfSpAskApprovalResponse) 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 *GfSpAskApprovalResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpAskApprovalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Response != nil {
		{
			size := m.Response.Size()
			i -= size
			if _, err := m.Response.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.Allowed {
		i--
		if m.Allowed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Err != nil {
		{
			size, err := m.Err.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApproval(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *GfSpAskApprovalResponse_CreateBucketApprovalTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CreateBucketApprovalTask != nil {
		{
			size, err := m.CreateBucketApprovalTask.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApproval(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *GfSpAskApprovalResponse_MigrateBucketApprovalTask) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpAskApprovalResponse_MigrateBucketApprovalTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MigrateBucketApprovalTask != nil {
		{
			size, err := m.MigrateBucketApprovalTask.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApproval(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *GfSpAskApprovalResponse_CreateObjectApprovalTask) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpAskApprovalResponse_CreateObjectApprovalTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CreateObjectApprovalTask != nil {
		{
			size, err := m.CreateObjectApprovalTask.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApproval(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *GfSpAskApprovalResponse_DelegateCreateObjectApprovalTask) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GfSpAskApprovalResponse_DelegateCreateObjectApprovalTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DelegateCreateObjectApprovalTask != nil {
		{
			size, err := m.DelegateCreateObjectApprovalTask.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApproval(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func encodeVarintApproval(dAtA []byte, offset int, v uint64) int {
	offset -= sovApproval(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *GfSpAskApprovalRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Request != nil {
		n += m.Request.Size()
	}
	return n
}

func (m *GfSpAskApprovalRequest_CreateBucketApprovalTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CreateBucketApprovalTask != nil {
		l = m.CreateBucketApprovalTask.Size()
		n += 1 + l + sovApproval(uint64(l))
	}
	return n
}
func (m *GfSpAskApprovalRequest_MigrateBucketApprovalTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MigrateBucketApprovalTask != nil {
		l = m.MigrateBucketApprovalTask.Size()
		n += 1 + l + sovApproval(uint64(l))
	}
	return n
}
func (m *GfSpAskApprovalRequest_CreateObjectApprovalTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CreateObjectApprovalTask != nil {
		l = m.CreateObjectApprovalTask.Size()
		n += 1 + l + sovApproval(uint64(l))
	}
	return n
}
func (m *GfSpAskApprovalRequest_DelegateCreateObjectApprovalTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DelegateCreateObjectApprovalTask != nil {
		l = m.DelegateCreateObjectApprovalTask.Size()
		n += 1 + l + sovApproval(uint64(l))
	}
	return n
}
func (m *GfSpAskApprovalResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovApproval(uint64(l))
	}
	if m.Allowed {
		n += 2
	}
	if m.Response != nil {
		n += m.Response.Size()
	}
	return n
}

func (m *GfSpAskApprovalResponse_CreateBucketApprovalTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CreateBucketApprovalTask != nil {
		l = m.CreateBucketApprovalTask.Size()
		n += 1 + l + sovApproval(uint64(l))
	}
	return n
}
func (m *GfSpAskApprovalResponse_MigrateBucketApprovalTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MigrateBucketApprovalTask != nil {
		l = m.MigrateBucketApprovalTask.Size()
		n += 1 + l + sovApproval(uint64(l))
	}
	return n
}
func (m *GfSpAskApprovalResponse_CreateObjectApprovalTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CreateObjectApprovalTask != nil {
		l = m.CreateObjectApprovalTask.Size()
		n += 1 + l + sovApproval(uint64(l))
	}
	return n
}
func (m *GfSpAskApprovalResponse_DelegateCreateObjectApprovalTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DelegateCreateObjectApprovalTask != nil {
		l = m.DelegateCreateObjectApprovalTask.Size()
		n += 1 + l + sovApproval(uint64(l))
	}
	return n
}

func sovApproval(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozApproval(x uint64) (n int) {
	return sovApproval(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GfSpAskApprovalRequest) 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 ErrIntOverflowApproval
			}
			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: GfSpAskApprovalRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpAskApprovalRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateBucketApprovalTask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApproval
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApproval
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApproval
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfsptask.GfSpCreateBucketApprovalTask{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpAskApprovalRequest_CreateBucketApprovalTask{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MigrateBucketApprovalTask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApproval
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApproval
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApproval
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfsptask.GfSpMigrateBucketApprovalTask{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpAskApprovalRequest_MigrateBucketApprovalTask{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateObjectApprovalTask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApproval
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApproval
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApproval
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfsptask.GfSpCreateObjectApprovalTask{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpAskApprovalRequest_CreateObjectApprovalTask{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegateCreateObjectApprovalTask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApproval
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApproval
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApproval
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfsptask.GfSpDelegateCreateObjectApprovalTask{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Request = &GfSpAskApprovalRequest_DelegateCreateObjectApprovalTask{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApproval(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApproval
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GfSpAskApprovalResponse) 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 ErrIntOverflowApproval
			}
			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: GfSpAskApprovalResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GfSpAskApprovalResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApproval
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApproval
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApproval
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Err == nil {
				m.Err = &gfsperrors.GfSpError{}
			}
			if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Allowed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApproval
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Allowed = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateBucketApprovalTask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApproval
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApproval
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApproval
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfsptask.GfSpCreateBucketApprovalTask{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &GfSpAskApprovalResponse_CreateBucketApprovalTask{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MigrateBucketApprovalTask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApproval
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApproval
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApproval
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfsptask.GfSpMigrateBucketApprovalTask{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &GfSpAskApprovalResponse_MigrateBucketApprovalTask{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateObjectApprovalTask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApproval
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApproval
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApproval
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfsptask.GfSpCreateObjectApprovalTask{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &GfSpAskApprovalResponse_CreateObjectApprovalTask{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegateCreateObjectApprovalTask", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApproval
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApproval
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApproval
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &gfsptask.GfSpDelegateCreateObjectApprovalTask{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &GfSpAskApprovalResponse_DelegateCreateObjectApprovalTask{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApproval(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthApproval
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthApproval        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowApproval          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupApproval = fmt.Errorf("proto: unexpected end of group")
)
