// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v3.19.0
// source: automate-gateway/api/license/license.proto

package license

import (
	context "context"
	_ "github.com/chef/automate/api/external/annotations/iam"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type ApplyLicenseReq struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	License       string                 `protobuf:"bytes,1,opt,name=license,proto3" json:"license,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ApplyLicenseReq) Reset() {
	*x = ApplyLicenseReq{}
	mi := &file_automate_gateway_api_license_license_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ApplyLicenseReq) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ApplyLicenseReq) ProtoMessage() {}

func (x *ApplyLicenseReq) ProtoReflect() protoreflect.Message {
	mi := &file_automate_gateway_api_license_license_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ApplyLicenseReq.ProtoReflect.Descriptor instead.
func (*ApplyLicenseReq) Descriptor() ([]byte, []int) {
	return file_automate_gateway_api_license_license_proto_rawDescGZIP(), []int{0}
}

func (x *ApplyLicenseReq) GetLicense() string {
	if x != nil {
		return x.License
	}
	return ""
}

type ApplyLicenseResp struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Status        *GetStatusResp         `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ApplyLicenseResp) Reset() {
	*x = ApplyLicenseResp{}
	mi := &file_automate_gateway_api_license_license_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ApplyLicenseResp) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ApplyLicenseResp) ProtoMessage() {}

func (x *ApplyLicenseResp) ProtoReflect() protoreflect.Message {
	mi := &file_automate_gateway_api_license_license_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ApplyLicenseResp.ProtoReflect.Descriptor instead.
func (*ApplyLicenseResp) Descriptor() ([]byte, []int) {
	return file_automate_gateway_api_license_license_proto_rawDescGZIP(), []int{1}
}

func (x *ApplyLicenseResp) GetStatus() *GetStatusResp {
	if x != nil {
		return x.Status
	}
	return nil
}

type GetStatusReq struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetStatusReq) Reset() {
	*x = GetStatusReq{}
	mi := &file_automate_gateway_api_license_license_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetStatusReq) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetStatusReq) ProtoMessage() {}

func (x *GetStatusReq) ProtoReflect() protoreflect.Message {
	mi := &file_automate_gateway_api_license_license_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetStatusReq.ProtoReflect.Descriptor instead.
func (*GetStatusReq) Descriptor() ([]byte, []int) {
	return file_automate_gateway_api_license_license_proto_rawDescGZIP(), []int{2}
}

type GetStatusResp struct {
	state          protoimpl.MessageState   `protogen:"open.v1"`
	LicenseId      string                   `protobuf:"bytes,1,opt,name=license_id,json=licenseId,proto3" json:"license_id,omitempty"`
	ConfiguredAt   *timestamppb.Timestamp   `protobuf:"bytes,2,opt,name=configured_at,json=configuredAt,proto3" json:"configured_at,omitempty"`
	LicensedPeriod *GetStatusResp_DateRange `protobuf:"bytes,3,opt,name=licensed_period,json=licensedPeriod,proto3" json:"licensed_period,omitempty"`
	CustomerName   string                   `protobuf:"bytes,4,opt,name=customer_name,json=customerName,proto3" json:"customer_name,omitempty"`
	GracePeriod    bool                     `protobuf:"varint,5,opt,name=grace_period,json=gracePeriod,proto3" json:"grace_period,omitempty"`
	LicenseType    string                   `protobuf:"bytes,6,opt,name=license_type,json=licenseType,proto3" json:"license_type,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *GetStatusResp) Reset() {
	*x = GetStatusResp{}
	mi := &file_automate_gateway_api_license_license_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetStatusResp) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetStatusResp) ProtoMessage() {}

func (x *GetStatusResp) ProtoReflect() protoreflect.Message {
	mi := &file_automate_gateway_api_license_license_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetStatusResp.ProtoReflect.Descriptor instead.
func (*GetStatusResp) Descriptor() ([]byte, []int) {
	return file_automate_gateway_api_license_license_proto_rawDescGZIP(), []int{3}
}

func (x *GetStatusResp) GetLicenseId() string {
	if x != nil {
		return x.LicenseId
	}
	return ""
}

func (x *GetStatusResp) GetConfiguredAt() *timestamppb.Timestamp {
	if x != nil {
		return x.ConfiguredAt
	}
	return nil
}

func (x *GetStatusResp) GetLicensedPeriod() *GetStatusResp_DateRange {
	if x != nil {
		return x.LicensedPeriod
	}
	return nil
}

func (x *GetStatusResp) GetCustomerName() string {
	if x != nil {
		return x.CustomerName
	}
	return ""
}

func (x *GetStatusResp) GetGracePeriod() bool {
	if x != nil {
		return x.GracePeriod
	}
	return false
}

func (x *GetStatusResp) GetLicenseType() string {
	if x != nil {
		return x.LicenseType
	}
	return ""
}

type RequestLicenseReq struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	FirstName     string                 `protobuf:"bytes,1,opt,name=first_name,json=firstName,proto3" json:"first_name,omitempty"`
	LastName      string                 `protobuf:"bytes,2,opt,name=last_name,json=lastName,proto3" json:"last_name,omitempty"`
	Email         string                 `protobuf:"bytes,3,opt,name=email,proto3" json:"email,omitempty"`
	GdprAgree     bool                   `protobuf:"varint,4,opt,name=gdpr_agree,json=gdprAgree,proto3" json:"gdpr_agree,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RequestLicenseReq) Reset() {
	*x = RequestLicenseReq{}
	mi := &file_automate_gateway_api_license_license_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RequestLicenseReq) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RequestLicenseReq) ProtoMessage() {}

func (x *RequestLicenseReq) ProtoReflect() protoreflect.Message {
	mi := &file_automate_gateway_api_license_license_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RequestLicenseReq.ProtoReflect.Descriptor instead.
func (*RequestLicenseReq) Descriptor() ([]byte, []int) {
	return file_automate_gateway_api_license_license_proto_rawDescGZIP(), []int{4}
}

func (x *RequestLicenseReq) GetFirstName() string {
	if x != nil {
		return x.FirstName
	}
	return ""
}

func (x *RequestLicenseReq) GetLastName() string {
	if x != nil {
		return x.LastName
	}
	return ""
}

func (x *RequestLicenseReq) GetEmail() string {
	if x != nil {
		return x.Email
	}
	return ""
}

func (x *RequestLicenseReq) GetGdprAgree() bool {
	if x != nil {
		return x.GdprAgree
	}
	return false
}

type RequestLicenseResp struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Deprecated: Marked as deprecated in automate-gateway/api/license/license.proto.
	License       string         `protobuf:"bytes,1,opt,name=license,proto3" json:"license,omitempty"`
	Status        *GetStatusResp `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RequestLicenseResp) Reset() {
	*x = RequestLicenseResp{}
	mi := &file_automate_gateway_api_license_license_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RequestLicenseResp) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RequestLicenseResp) ProtoMessage() {}

func (x *RequestLicenseResp) ProtoReflect() protoreflect.Message {
	mi := &file_automate_gateway_api_license_license_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RequestLicenseResp.ProtoReflect.Descriptor instead.
func (*RequestLicenseResp) Descriptor() ([]byte, []int) {
	return file_automate_gateway_api_license_license_proto_rawDescGZIP(), []int{5}
}

// Deprecated: Marked as deprecated in automate-gateway/api/license/license.proto.
func (x *RequestLicenseResp) GetLicense() string {
	if x != nil {
		return x.License
	}
	return ""
}

func (x *RequestLicenseResp) GetStatus() *GetStatusResp {
	if x != nil {
		return x.Status
	}
	return nil
}

type GetStatusResp_DateRange struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Start         *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=start,proto3" json:"start,omitempty"`
	End           *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=end,proto3" json:"end,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetStatusResp_DateRange) Reset() {
	*x = GetStatusResp_DateRange{}
	mi := &file_automate_gateway_api_license_license_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetStatusResp_DateRange) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetStatusResp_DateRange) ProtoMessage() {}

func (x *GetStatusResp_DateRange) ProtoReflect() protoreflect.Message {
	mi := &file_automate_gateway_api_license_license_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetStatusResp_DateRange.ProtoReflect.Descriptor instead.
func (*GetStatusResp_DateRange) Descriptor() ([]byte, []int) {
	return file_automate_gateway_api_license_license_proto_rawDescGZIP(), []int{3, 0}
}

func (x *GetStatusResp_DateRange) GetStart() *timestamppb.Timestamp {
	if x != nil {
		return x.Start
	}
	return nil
}

func (x *GetStatusResp_DateRange) GetEnd() *timestamppb.Timestamp {
	if x != nil {
		return x.End
	}
	return nil
}

var File_automate_gateway_api_license_license_proto protoreflect.FileDescriptor

const file_automate_gateway_api_license_license_proto_rawDesc = "" +
	"\n" +
	"*automate-gateway/api/license/license.proto\x12\x19chef.automate.api.license\x1a\x1cgoogle/api/annotations.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a*external/annotations/iam/annotations.proto\"+\n" +
	"\x0fApplyLicenseReq\x12\x18\n" +
	"\alicense\x18\x01 \x01(\tR\alicense\"T\n" +
	"\x10ApplyLicenseResp\x12@\n" +
	"\x06status\x18\x01 \x01(\v2(.chef.automate.api.license.GetStatusRespR\x06status\"\x0e\n" +
	"\fGetStatusReq\"\xa4\x03\n" +
	"\rGetStatusResp\x12\x1d\n" +
	"\n" +
	"license_id\x18\x01 \x01(\tR\tlicenseId\x12?\n" +
	"\rconfigured_at\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\fconfiguredAt\x12[\n" +
	"\x0flicensed_period\x18\x03 \x01(\v22.chef.automate.api.license.GetStatusResp.DateRangeR\x0elicensedPeriod\x12#\n" +
	"\rcustomer_name\x18\x04 \x01(\tR\fcustomerName\x12!\n" +
	"\fgrace_period\x18\x05 \x01(\bR\vgracePeriod\x12!\n" +
	"\flicense_type\x18\x06 \x01(\tR\vlicenseType\x1ak\n" +
	"\tDateRange\x120\n" +
	"\x05start\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\x05start\x12,\n" +
	"\x03end\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\x03end\"\x84\x01\n" +
	"\x11RequestLicenseReq\x12\x1d\n" +
	"\n" +
	"first_name\x18\x01 \x01(\tR\tfirstName\x12\x1b\n" +
	"\tlast_name\x18\x02 \x01(\tR\blastName\x12\x14\n" +
	"\x05email\x18\x03 \x01(\tR\x05email\x12\x1d\n" +
	"\n" +
	"gdpr_agree\x18\x04 \x01(\bR\tgdprAgree\"t\n" +
	"\x12RequestLicenseResp\x12\x1c\n" +
	"\alicense\x18\x01 \x01(\tB\x02\x18\x01R\alicense\x12@\n" +
	"\x06status\x18\x02 \x01(\v2(.chef.automate.api.license.GetStatusRespR\x06status2\xa7\x04\n" +
	"\aLicense\x12\xb3\x01\n" +
	"\fApplyLicense\x12*.chef.automate.api.license.ApplyLicenseReq\x1a+.chef.automate.api.license.ApplyLicenseResp\"J\x8a\xb5\x18&\n" +
	"\x0esystem:license\x12\x14system:license:apply\x82\xd3\xe4\x93\x02\x1a:\x01*\"\x15/api/v0/license/apply\x12\xa5\x01\n" +
	"\tGetStatus\x12'.chef.automate.api.license.GetStatusReq\x1a(.chef.automate.api.license.GetStatusResp\"E\x8a\xb5\x18#\n" +
	"\rsystem:status\x12\x12system:license:get\x82\xd3\xe4\x93\x02\x18\x12\x16/api/v0/license/status\x12\xbd\x01\n" +
	"\x0eRequestLicense\x12,.chef.automate.api.license.RequestLicenseReq\x1a-.chef.automate.api.license.RequestLicenseResp\"N\x8a\xb5\x18(\n" +
	"\x0esystem:license\x12\x16system:license:request\x82\xd3\xe4\x93\x02\x1c:\x01*\"\x17/api/v0/license/requestBBZ@github.com/chef/automate/components/automate-gateway/api/licenseb\x06proto3"

var (
	file_automate_gateway_api_license_license_proto_rawDescOnce sync.Once
	file_automate_gateway_api_license_license_proto_rawDescData []byte
)

func file_automate_gateway_api_license_license_proto_rawDescGZIP() []byte {
	file_automate_gateway_api_license_license_proto_rawDescOnce.Do(func() {
		file_automate_gateway_api_license_license_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_automate_gateway_api_license_license_proto_rawDesc), len(file_automate_gateway_api_license_license_proto_rawDesc)))
	})
	return file_automate_gateway_api_license_license_proto_rawDescData
}

var file_automate_gateway_api_license_license_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
var file_automate_gateway_api_license_license_proto_goTypes = []any{
	(*ApplyLicenseReq)(nil),         // 0: chef.automate.api.license.ApplyLicenseReq
	(*ApplyLicenseResp)(nil),        // 1: chef.automate.api.license.ApplyLicenseResp
	(*GetStatusReq)(nil),            // 2: chef.automate.api.license.GetStatusReq
	(*GetStatusResp)(nil),           // 3: chef.automate.api.license.GetStatusResp
	(*RequestLicenseReq)(nil),       // 4: chef.automate.api.license.RequestLicenseReq
	(*RequestLicenseResp)(nil),      // 5: chef.automate.api.license.RequestLicenseResp
	(*GetStatusResp_DateRange)(nil), // 6: chef.automate.api.license.GetStatusResp.DateRange
	(*timestamppb.Timestamp)(nil),   // 7: google.protobuf.Timestamp
}
var file_automate_gateway_api_license_license_proto_depIdxs = []int32{
	3, // 0: chef.automate.api.license.ApplyLicenseResp.status:type_name -> chef.automate.api.license.GetStatusResp
	7, // 1: chef.automate.api.license.GetStatusResp.configured_at:type_name -> google.protobuf.Timestamp
	6, // 2: chef.automate.api.license.GetStatusResp.licensed_period:type_name -> chef.automate.api.license.GetStatusResp.DateRange
	3, // 3: chef.automate.api.license.RequestLicenseResp.status:type_name -> chef.automate.api.license.GetStatusResp
	7, // 4: chef.automate.api.license.GetStatusResp.DateRange.start:type_name -> google.protobuf.Timestamp
	7, // 5: chef.automate.api.license.GetStatusResp.DateRange.end:type_name -> google.protobuf.Timestamp
	0, // 6: chef.automate.api.license.License.ApplyLicense:input_type -> chef.automate.api.license.ApplyLicenseReq
	2, // 7: chef.automate.api.license.License.GetStatus:input_type -> chef.automate.api.license.GetStatusReq
	4, // 8: chef.automate.api.license.License.RequestLicense:input_type -> chef.automate.api.license.RequestLicenseReq
	1, // 9: chef.automate.api.license.License.ApplyLicense:output_type -> chef.automate.api.license.ApplyLicenseResp
	3, // 10: chef.automate.api.license.License.GetStatus:output_type -> chef.automate.api.license.GetStatusResp
	5, // 11: chef.automate.api.license.License.RequestLicense:output_type -> chef.automate.api.license.RequestLicenseResp
	9, // [9:12] is the sub-list for method output_type
	6, // [6:9] is the sub-list for method input_type
	6, // [6:6] is the sub-list for extension type_name
	6, // [6:6] is the sub-list for extension extendee
	0, // [0:6] is the sub-list for field type_name
}

func init() { file_automate_gateway_api_license_license_proto_init() }
func file_automate_gateway_api_license_license_proto_init() {
	if File_automate_gateway_api_license_license_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_automate_gateway_api_license_license_proto_rawDesc), len(file_automate_gateway_api_license_license_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   7,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_automate_gateway_api_license_license_proto_goTypes,
		DependencyIndexes: file_automate_gateway_api_license_license_proto_depIdxs,
		MessageInfos:      file_automate_gateway_api_license_license_proto_msgTypes,
	}.Build()
	File_automate_gateway_api_license_license_proto = out.File
	file_automate_gateway_api_license_license_proto_goTypes = nil
	file_automate_gateway_api_license_license_proto_depIdxs = nil
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface

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

// LicenseClient is the client API for License service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type LicenseClient interface {
	ApplyLicense(ctx context.Context, in *ApplyLicenseReq, opts ...grpc.CallOption) (*ApplyLicenseResp, error)
	GetStatus(ctx context.Context, in *GetStatusReq, opts ...grpc.CallOption) (*GetStatusResp, error)
	RequestLicense(ctx context.Context, in *RequestLicenseReq, opts ...grpc.CallOption) (*RequestLicenseResp, error)
}

type licenseClient struct {
	cc grpc.ClientConnInterface
}

func NewLicenseClient(cc grpc.ClientConnInterface) LicenseClient {
	return &licenseClient{cc}
}

func (c *licenseClient) ApplyLicense(ctx context.Context, in *ApplyLicenseReq, opts ...grpc.CallOption) (*ApplyLicenseResp, error) {
	out := new(ApplyLicenseResp)
	err := c.cc.Invoke(ctx, "/chef.automate.api.license.License/ApplyLicense", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *licenseClient) GetStatus(ctx context.Context, in *GetStatusReq, opts ...grpc.CallOption) (*GetStatusResp, error) {
	out := new(GetStatusResp)
	err := c.cc.Invoke(ctx, "/chef.automate.api.license.License/GetStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *licenseClient) RequestLicense(ctx context.Context, in *RequestLicenseReq, opts ...grpc.CallOption) (*RequestLicenseResp, error) {
	out := new(RequestLicenseResp)
	err := c.cc.Invoke(ctx, "/chef.automate.api.license.License/RequestLicense", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// LicenseServer is the server API for License service.
type LicenseServer interface {
	ApplyLicense(context.Context, *ApplyLicenseReq) (*ApplyLicenseResp, error)
	GetStatus(context.Context, *GetStatusReq) (*GetStatusResp, error)
	RequestLicense(context.Context, *RequestLicenseReq) (*RequestLicenseResp, error)
}

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

func (*UnimplementedLicenseServer) ApplyLicense(context.Context, *ApplyLicenseReq) (*ApplyLicenseResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ApplyLicense not implemented")
}
func (*UnimplementedLicenseServer) GetStatus(context.Context, *GetStatusReq) (*GetStatusResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetStatus not implemented")
}
func (*UnimplementedLicenseServer) RequestLicense(context.Context, *RequestLicenseReq) (*RequestLicenseResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RequestLicense not implemented")
}

func RegisterLicenseServer(s *grpc.Server, srv LicenseServer) {
	s.RegisterService(&_License_serviceDesc, srv)
}

func _License_ApplyLicense_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplyLicenseReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LicenseServer).ApplyLicense(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.api.license.License/ApplyLicense",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LicenseServer).ApplyLicense(ctx, req.(*ApplyLicenseReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _License_GetStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetStatusReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LicenseServer).GetStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.api.license.License/GetStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LicenseServer).GetStatus(ctx, req.(*GetStatusReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _License_RequestLicense_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RequestLicenseReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LicenseServer).RequestLicense(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/chef.automate.api.license.License/RequestLicense",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LicenseServer).RequestLicense(ctx, req.(*RequestLicenseReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _License_serviceDesc = grpc.ServiceDesc{
	ServiceName: "chef.automate.api.license.License",
	HandlerType: (*LicenseServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ApplyLicense",
			Handler:    _License_ApplyLicense_Handler,
		},
		{
			MethodName: "GetStatus",
			Handler:    _License_GetStatus_Handler,
		},
		{
			MethodName: "RequestLicense",
			Handler:    _License_RequestLicense_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "automate-gateway/api/license/license.proto",
}
