text:
0x54, 0x0a, 0x0d,
	0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x2e,
	0x6d, 0x61, 0x67, 0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65,
	0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20,
	0x2e, 0x6d, 0x61, 0x67, 0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74,
	0x65, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
	0x22, 0x00, 0x12, 0x5d, 0x0a, 0x10, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x53,
	0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x22, 0x2e, 0x6d, 0x61, 0x67, 0x6d, 0x61, 0x2e, 0x6c,
	0x74, 0x65, 0x2e, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e,
	0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6d, 0x61, 0x67,
	0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x65,
	0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
	0x00, 0x32, 0x83, 0x02, 0x0a, 0x18, 0x53, 0x65, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61,
	0x63, 0x65, 0x46, 0x6f, 0x72, 0x55, 0x73, 0x65, 0x72, 0x50, 0x6c, 0x61, 0x6e, 0x65, 0x12, 0x46,
	0x0a, 0x0f, 0x53, 0x65, 0x74, 0x55, 0x50, 0x46, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x74, 0x61, 0x74,
	0x65, 0x12, 0x17, 0x2e, 0x6d, 0x61, 0x67, 0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x55, 0x50,
	0x46, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x1a, 0x18, 0x2e, 0x6d, 0x61, 0x67,
	0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x53, 0x6d, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74,
	0x56, 0x6f, 0x69, 0x64, 0x22, 0x00, 0x12, 0x54, 0x0a, 0x14, 0x53, 0x65, 0x74, 0x55, 0x50, 0x46,
	0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x20,
	0x2e, 0x6d, 0x61, 0x67, 0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x55, 0x50, 0x46, 0x53, 0x65,
	0x73, 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x53, 0x74, 0x61, 0x74, 0x65,
	0x1a, 0x18, 0x2e, 0x6d, 0x61, 0x67, 0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x53, 0x6d, 0x43,
	0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x56, 0x6f, 0x69, 0x64, 0x22, 0x00, 0x12, 0x49, 0x0a, 0x11,
	0x53, 0x65, 0x6e, 0x64, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
	0x74, 0x12, 0x18, 0x2e, 0x6d, 0x61, 0x67, 0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x55, 0x50,
	0x46, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x66, 0x6f, 0x1a, 0x18, 0x2e, 0x6d, 0x61,
	0x67, 0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x53, 0x6d, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78,
	0x74, 0x56, 0x6f, 0x69, 0x64, 0x22, 0x00, 0x32, 0xc1, 0x01, 0x0a, 0x16, 0x41, 0x6d, 0x66, 0x50,
	0x64, 0x75, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x6d, 0x43, 0x6f, 0x6e, 0x74, 0x65,
	0x78, 0x74, 0x12, 0x52, 0x0a, 0x14, 0x53, 0x65, 0x74, 0x41, 0x6d, 0x66, 0x53, 0x65, 0x73, 0x73,
	0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x1e, 0x2e, 0x6d, 0x61, 0x67,
	0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x4d, 0x53, 0x65, 0x73, 0x73,
	0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x1a, 0x18, 0x2e, 0x6d, 0x61, 0x67,
	0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x53, 0x6d, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74,
	0x56, 0x6f, 0x69, 0x64, 0x22, 0x00, 0x12, 0x53, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x53, 0x6d, 0x66,
	0x4e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x2e, 0x6d,
	0x61, 0x67, 0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x6d, 0x4e, 0x6f,
	0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78,
	0x74, 0x1a, 0x18, 0x2e, 0x6d, 0x61, 0x67, 0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x53, 0x6d,
	0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x56, 0x6f, 0x69, 0x64, 0x32, 0xc7, 0x01, 0x0a, 0x16,
	0x53, 0x6d, 0x66, 0x50, 0x64, 0x75, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x6d, 0x43,
	0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x55, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x41, 0x6d, 0x66,
	0x4e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x2e, 0x6d,
	0x61, 0x67, 0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x6d, 0x4e, 0x6f,
	0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78,
	0x74, 0x1a, 0x18, 0x2e, 0x6d, 0x61, 0x67, 0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x53, 0x6d,
	0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x56, 0x6f, 0x69, 0x64, 0x22, 0x00, 0x12, 0x56, 0x0a,
	0x14, 0x53, 0x65, 0x74, 0x53, 0x6d, 0x66, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f,
	0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x24, 0x2e, 0x6d, 0x61, 0x67, 0x6d, 0x61, 0x2e, 0x6c, 0x74,
	0x65, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x4d, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f,
	0x6e, 0x74, 0x65, 0x78, 0x74, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x1a, 0x18, 0x2e, 0x6d, 0x61,
	0x67, 0x6d, 0x61, 0x2e, 0x6c, 0x74, 0x65, 0x2e, 0x53, 0x6d, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78,
	0x74, 0x56, 0x6f, 0x69, 0x64, 0x42, 0x1b, 0x5a, 0x19, 0x6d, 0x61, 0x67, 0x6d, 0x61, 0x2f, 0x6c,
	0x74, 0x65, 0x2f, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x2f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74,
	0x6f, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}

var (
	file_lte_protos_session_manager_proto_rawDescOnce sync.Once
	file_lte_protos_session_manager_proto_rawDescData = file_lte_protos_session_manager_proto_rawDesc
)

func file_lte_protos_session_manager_proto_rawDescGZIP() []byte {
	file_lte_protos_session_manager_proto_rawDescOnce.Do(func() {
		file_lte_protos_session_manager_proto_rawDescData = protoimpl.X.CompressGZIP(file_lte_protos_session_manager_proto_rawDescData)
	})
	return file_lte_protos_session_manager_proto_rawDescData
}

var file_lte_protos_session_manager_proto_enumTypes = make([]protoimpl.EnumInfo, 32)
var file_lte_protos_session_manager_proto_msgTypes = make([]protoimpl.MessageInfo, 79)
var file_lte_protos_session_manager_proto_goTypes = []interface{}{
	(RATType)(0),                                   // 0: magma.lte.RATType
	(NotifyUeEvents)(0),                            // 1: magma.lte.NotifyUeEvents
	(EventTrigger)(0),                              // 2: magma.lte.EventTrigger
	(QCI)(0),                                       // 3: magma.lte.QCI
	(ReAuthResult)(0),                              // 4: magma.lte.ReAuthResult
	(CreditLimitType)(0),                           // 5: magma.lte.CreditLimitType
	(MonitoringLevel)(0),                           // 6: magma.lte.MonitoringLevel
	(PduSessionType)(0),                            // 7: magma.lte.PduSessionType
	(SscMode)(0),                                   // 8: magma.lte.SscMode
	(M5GSMCause)(0),                                // 9: magma.lte.M5GSMCause
	(RequestType)(0),                               // 10: magma.lte.RequestType
	(AccessType)(0),                                // 11: magma.lte.AccessType
	(DnnSelectionMode)(0),                          // 12: magma.lte.DnnSelectionMode
	(PremCapab)(0),                                 // 13: magma.lte.prem_capab
	(PremVuner)(0),                                 // 14: magma.lte.prem_vuner
	(TypeOfList)(0),                                // 15: magma.lte.TypeOfList
	(Priorityaccess)(0),                            // 16: magma.lte.priorityaccess
	(SMSessionFSMState)(0),                         // 17: magma.lte.SMSessionFSMState
	(ChargingReAuthRequest_Type)(0),                // 18: magma.lte.ChargingReAuthRequest.Type
	(PolicyReAuthAnswer_FailureCode)(0),            // 19: magma.lte.PolicyReAuthAnswer.FailureCode
	(RedirectServer_RedirectAddressType)(0),        // 20: magma.lte.RedirectServer.RedirectAddressType
	(ChargingCredit_UnitType)(0),                   // 21: magma.lte.ChargingCredit.UnitType
	(ChargingCredit_FinalAction)(0),                // 22: magma.lte.ChargingCredit.FinalAction
	(CreditUsage_UpdateType)(0),                    // 23: magma.lte.CreditUsage.UpdateType
	(UsageMonitoringCredit_Action)(0),              // 24: magma.lte.UsageMonitoringCredit.Action
	(QosInformationRequest_BitrateUnitsAMBR)(0),    // 25: magma.lte.QosInformationRequest.BitrateUnitsAMBR
	(M5GQosInformationRequest_BitrateUnitsAMBR)(0), // 26: magma.lte.M5GQosInformationRequest.BitrateUnitsAMBR
	(NodeID_NodeIDType)(0),                         // 27: magma.lte.NodeID.NodeIDType
	(QosPolicy_PolicyState)(0),                     // 28: magma.lte.QosPolicy.PolicyState
	(QosPolicy_PolicyAction)(0),                    // 29: magma.lte.QosPolicy.PolicyAction
	(UserPlaneIPResourceSchema_InterfaceValue)(0),  // 30: magma.lte.UserPlaneIPResourceSchema.InterfaceValue
	(UPFAssociationState_AssociationState)(0),      // 31: magma.lte.UPFAssociationState.AssociationState
	(*RuleRecord)(nil),                             // 32: magma.lte.RuleRecord
	(*RuleRecordTable)(nil),                        // 33: magma.lte.RuleRecordTable
	(*LocalCreateSessionRequest)(nil),              // 34: magma.lte.LocalCreateSessionRequest
	(*Teids)(nil),                                  // 35: magma.lte.Teids
	(*CommonSessionContext)(nil),                   // 36: magma.lte.CommonSessionContext
	(*RatSpecificContext)(nil),                     // 37: magma.lte.RatSpecificContext
	(*TeidSet)(nil),                                // 38: magma.lte.TeidSet
	(*RatSpecificNotification)(nil),                // 39: magma.lte.RatSpecificNotification
	(*SetSmNotificationContext)(nil),               // 40: magma.lte.SetSmNotificationContext
	(*LTESessionContext)(nil),                      // 41: magma.lte.LTESessionContext
	(*WLANSessionContext)(nil),                     // 42: magma.lte.WLANSessionContext
	(*LocalCreateSessionResponse)(nil),             // 43: magma.lte.LocalCreateSessionResponse
	(*LocalEndSessionRequest)(nil),                 // 44: magma.lte.LocalEndSessionRequest
	(*LocalEndSessionResponse)(nil),                // 45: magma.lte.LocalEndSessionResponse
	(*UpdateTunnelIdsRequest)(nil),                 // 46: magma.lte.UpdateTunnelIdsRequest
	(*UpdateTunnelIdsResponse)(nil),                // 47: magma.lte.UpdateTunnelIdsResponse
	(*PolicyBearerBindingRequest)(nil),             // 48: magma.lte.PolicyBearerBindingRequest
	(*PolicyBearerBindingResponse)(nil),            // 49: magma.lte.PolicyBearerBindingResponse
	(*ChargingReAuthRequest)(nil),                  // 50: magma.lte.ChargingReAuthRequest
	(*ChargingReAuthAnswer)(nil),                   // 51: magma.lte.ChargingReAuthAnswer
	(*PolicyReAuthRequest)(nil),                    // 52: magma.lte.PolicyReAuthRequest
	(*QoSInformation)(nil),                         // 53: magma.lte.QoSInformation
	(*PolicyReAuthAnswer)(nil),                     // 54: magma.lte.PolicyReAuthAnswer
	(*RuleSet)(nil),                                // 55: magma.lte.RuleSet
	(*RulesPerSubscriber)(nil),                     // 56: magma.lte.RulesPerSubscriber
	(*SessionRules)(nil),                           // 57: magma.lte.SessionRules
	(*Timezone)(nil),                               // 58: magma.lte.Timezone
	(*CreditUnit)(nil),                             // 59: magma.lte.CreditUnit
	(*GrantedUnits)(nil),                           // 60: magma.lte.GrantedUnits
	(*RedirectServer)(nil),                         // 61: magma.lte.RedirectServer
	(*ChargingCredit)(nil),                         // 62: magma.lte.ChargingCredit
	(*RequestedUnits)(nil),                         // 63: magma.lte.RequestedUnits
	(*CreditUsage)(nil),                            // 64: magma.lte.CreditUsage
	(*CreditUsageUpdate)(nil),                      // 65: magma.lte.CreditUsageUpdate
	(*CreditUpdateResponse)(nil),                   // 66: magma.lte.CreditUpdateResponse
	(*UsageMonitorUpdate)(nil),                     // 67: magma.lte.UsageMonitorUpdate
	(*UsageMonitoringCredit)(nil),                  // 68: magma.lte.UsageMonitoringCredit
	(*UsageMonitoringUpdateRequest)(nil),           // 69: magma.lte.UsageMonitoringUpdateRequest
	(*UsageMonitoringUpdateResponse)(nil),          // 70: magma.lte.UsageMonitoringUpdateResponse
	(*QosInformationRequest)(nil),                  // 71: magma.lte.QosInformationRequest
	(*M5GQosInformationRequest)(nil),               // 72: magma.lte.M5GQosInformationRequest
	(*TgppContext)(nil),                            // 73: magma.lte.TgppContext
	(*CreateSessionRequest)(nil),                   // 74: magma.lte.CreateSessionRequest
	(*CreateSessionResponse)(nil),                  // 75: magma.lte.CreateSessionResponse
	(*StaticRuleInstall)(nil),                      // 76: magma.lte.StaticRuleInstall
	(*DynamicRuleInstall)(nil),                     // 77: magma.lte.DynamicRuleInstall
	(*UpdateSessionRequest)(nil),                   // 78: magma.lte.UpdateSessionRequest
	(*UpdateSessionResponse)(nil),                  // 79: magma.lte.UpdateSessionResponse
	(*SessionTerminateResponse)(nil),               // 80: magma.lte.SessionTerminateResponse
	(*SessionTerminateRequest)(nil),                // 81: magma.lte.SessionTerminateRequest
	(*NodeID)(nil),                                 // 82: magma.lte.NodeID
	(*M5GSMCapability)(nil),                        // 83: magma.lte.M5GSMCapability
	(*QosRules)(nil),                               // 84: magma.lte.QosRules
	(*QosPolicy)(nil),                              // 85: magma.lte.QosPolicy
	(*AllocationAndRetentionPrio)(nil),             // 86: magma.lte.allocation_and_retention_prio
	(*QosCharacteristics)(nil),                     // 87: magma.lte.qos_characteristics
	(*FlowLevelParams)(nil),                        // 88: magma.lte.flow_level_params
	(*QosFlow)(nil),                                // 89: magma.lte.qos_flow
	(*QosFlowRequestList)(nil),                     // 90: magma.lte.qos_flow_request_list
	(*LadnServiceArea)(nil),                        // 91: magma.lte.LadnServiceArea
	(*TrackingAreaIdentityList)(nil),               // 92: magma.lte.TrackingAreaIdentityList
	(*M5GSMSessionContext)(nil),                    // 93: magma.lte.M5GSMSessionContext
	(*SetSMSessionContext)(nil),                    // 94: magma.lte.SetSMSessionContext
	(*SmContextVoid)(nil),                          // 95: magma.lte.SmContextVoid
	(*RatSpecificContextAccess)(nil),               // 96: magma.lte.RatSpecificContextAccess
	(*M5GSMSessionContextAccess)(nil),              // 97: magma.lte.M5GSMSessionContextAccess
	(*SetSMSessionContextAccess)(nil),              // 98: magma.lte.SetSMSessionContextAccess
	(*UPFNodeState)(nil),                           // 99: magma.lte.UPFNodeState
	(*UserPlaneIPResourceSchema)(nil),              // 100: magma.lte.UserPlaneIPResourceSchema
	(*UPFAssociationState)(nil),                    // 101: magma.lte.UPFAssociationState
	(*UPFFeatureSet)(nil),                          // 102: magma.lte.UPFFeatureSet
	(*UPFNodeReport)(nil),                          // 103: magma.lte.UPFNodeReport
	(*LoadControlInformation)(nil),                 // 104: magma.lte.LoadControlInformation
	(*OverloadTimer)(nil),                          // 105: magma.lte.OverloadTimer
	(*OverloadControlInformation)(nil),             // 106: magma.lte.OverloadControlInformation
	(*UPFSessionState)(nil),                        // 107: magma.lte.UPFSessionState
	(*UPFSessionConfigState)(nil),                  // 108: magma.lte.UPFSessionConfigState
	(*UPFPagingInfo)(nil),                          // 109: magma.lte.UPFPagingInfo
	nil,                                            // 110: magma.lte.PolicyReAuthAnswer.FailedRulesEntry
	(*SubscriberID)(nil),                           // 111: magma.lte.SubscriberID
	(*ServiceIdentifier)(nil),                      // 112: magma.lte.ServiceIdentifier
	(*timestamp.Timestamp)(nil),                    // 113: google.protobuf.Timestamp
	(*PolicyRule)(nil),                             // 114: magma.lte.PolicyRule
	(*protos.Void)(nil),                            // 115: magma.orc8r.Void
}
var file_lte_protos_session_manager_proto_depIdxs = []int32{
	32,  // 0: magma.lte.RuleRecordTable.records:type_name -> magma.lte.RuleRecord
	36,  // 1: magma.lte.LocalCreateSessionRequest.common_context:type_name -> magma.lte.CommonSessionContext
	37,  // 2: magma.lte.LocalCreateSessionRequest.rat_specific_context:type_name -> magma.lte.RatSpecificContext
	111, // 3: magma.lte.CommonSessionContext.sid:type_name -> magma.lte.SubscriberID
	0,   // 4: magma.lte.CommonSessionContext.rat_type:type_name -> magma.lte.RATType
	17,  // 5: magma.lte.CommonSessionContext.sm_session_state:type_name -> magma.lte.SMSessionFSMState
	35,  // 6: magma.lte.CommonSessionContext.teids:type_name -> magma.lte.Teids
	41,  // 7: magma.lte.RatSpecificContext.lte_context:type_name -> magma.lte.LTESessionContext
	42,  // 8: magma.lte.RatSpecificContext.wlan_context:type_name -> magma.lte.WLANSessionContext
	93,  // 9: magma.lte.RatSpecificContext.m5gsm_session_context:type_name -> magma.lte.M5GSMSessionContext
	10,  // 10: magma.lte.RatSpecificNotification.request_type:type_name -> magma.lte.RequestType
	11,  // 11: magma.lte.RatSpecificNotification.access_type:type_name -> magma.lte.AccessType
	7,   // 12: magma.lte.RatSpecificNotification.pdu_session_type:type_name -> magma.lte.PduSessionType
	83,  // 13: magma.lte.RatSpecificNotification.m5g_sm_capability:type_name -> magma.lte.M5GSMCapability
	9,   // 14: magma.lte.RatSpecificNotification.m5gsm_cause:type_name -> magma.lte.M5GSMCause
	1,   // 15: magma.lte.RatSpecificNotification.notify_ue_event:type_name -> magma.lte.NotifyUeEvents
	36,  // 16: magma.lte.SetSmNotificationContext.common_context:type_name -> magma.lte.CommonSessionContext
	39,  // 17: magma.lte.SetSmNotificationContext.rat_specific_notification:type_name -> magma.lte.RatSpecificNotification
	71,  // 18: magma.lte.LTESessionContext.qos_info:type_name -> magma.lte.QosInformationRequest
	111, // 19: magma.lte.LocalEndSessionRequest.sid:type_name -> magma.lte.SubscriberID
	111, // 20: magma.lte.UpdateTunnelIdsRequest.sid:type_name -> magma.lte.SubscriberID
	111, // 21: magma.lte.PolicyBearerBindingRequest.sid:type_name -> magma.lte.SubscriberID
	35,  // 22: magma.lte.PolicyBearerBindingRequest.teids:type_name -> magma.lte.Teids
	18,  // 23: magma.lte.ChargingReAuthRequest.type:type_name -> magma.lte.ChargingReAuthRequest.Type
	112, // 24: magma.lte.ChargingReAuthRequest.service_identifier:type_name -> magma.lte.ServiceIdentifier
	4,   // 25: magma.lte.ChargingReAuthAnswer.result:type_name -> magma.lte.ReAuthResult
	76,  // 26: magma.lte.PolicyReAuthRequest.rules_to_install:type_name -> magma.lte.StaticRuleInstall
	77,  // 27: magma.lte.PolicyReAuthRequest.dynamic_rules_to_install:type_name -> magma.lte.DynamicRuleInstall
	2,   // 28: magma.lte.PolicyReAuthRequest.event_triggers:type_name -> magma.lte.EventTrigger
	113, // 29: magma.lte.PolicyReAuthRequest.revalidation_time:type_name -> google.protobuf.Timestamp
	68,  // 30: magma.lte.PolicyReAuthRequest.usage_monitoring_credits:type_name -> magma.lte.UsageMonitoringCredit
	53,  // 31: magma.lte.PolicyReAuthRequest.qos_info:type_name -> magma.lte.QoSInformation
	3,   // 32: magma.lte.QoSInformation.qci:type_name -> magma.lte.QCI
	4,   // 33: magma.lte.PolicyReAuthAnswer.result:type_name -> magma.lte.ReAuthResult
	110, // 34: magma.lte.PolicyReAuthAnswer.failed_rules:type_name -> magma.lte.PolicyReAuthAnswer.FailedRulesEntry
	76,  // 35: magma.lte.RuleSet.static_rules:type_name -> magma.lte.StaticRuleInstall
	77,  // 36: magma.lte.RuleSet.dynamic_rules:type_name -> magma.lte.DynamicRuleInstall
	55,  // 37: magma.lte.RulesPerSubscriber.rule_set:type_name -> magma.lte.RuleSet
	56,  // 38: magma.lte.SessionRules.rules_per_subscriber:type_name -> magma.lte.RulesPerSubscriber
	59,  // 39: magma.lte.GrantedUnits.total:type_name -> magma.lte.CreditUnit
	59,  // 40: magma.lte.GrantedUnits.tx:type_name -> magma.lte.CreditUnit
	59,  // 41: magma.lte.GrantedUnits.rx:type_name -> magma.lte.CreditUnit
	20,  // 42: magma.lte.RedirectServer.redirect_address_type:type_name -> magma.lte.RedirectServer.RedirectAddressType
	21,  // 43: magma.lte.ChargingCredit.type:type_name -> magma.lte.ChargingCredit.UnitType
	22,  // 44: magma.lte.ChargingCredit.final_action:type_name -> magma.lte.ChargingCredit.FinalAction
	60,  // 45: magma.lte.ChargingCredit.granted_units:type_name -> magma.lte.GrantedUnits
	61,  // 46: magma.lte.ChargingCredit.redirect_server:type_name -> magma.lte.RedirectServer
	23,  // 47: magma.lte.CreditUsage.type:type_name -> magma.lte.CreditUsage.UpdateType
	112, // 48: magma.lte.CreditUsage.service_identifier:type_name -> magma.lte.ServiceIdentifier
	63,  // 49: magma.lte.CreditUsage.requested_units:type_name -> magma.lte.RequestedUnits
	64,  // 50: magma.lte.CreditUsageUpdate.usage:type_name -> magma.lte.CreditUsage
	73,  // 51: magma.lte.CreditUsageUpdate.tgpp_ctx:type_name -> magma.lte.TgppContext
	36,  // 52: magma.lte.CreditUsageUpdate.common_context:type_name -> magma.lte.CommonSessionContext
	37,  // 53: magma.lte.CreditUsageUpdate.rat_specific_context:type_name -> magma.lte.RatSpecificContext
	62,  // 54: magma.lte.CreditUpdateResponse.credit:type_name -> magma.lte.ChargingCredit
	112, // 55: magma.lte.CreditUpdateResponse.service_identifier:type_name -> magma.lte.ServiceIdentifier
	5,   // 56: magma.lte.CreditUpdateResponse.limit_type:type_name -> magma.lte.CreditLimitType
	73,  // 57: magma.lte.CreditUpdateResponse.tgpp_ctx:type_name -> magma.lte.TgppContext
	6,   // 58: magma.lte.UsageMonitorUpdate.level:type_name -> magma.lte.MonitoringLevel
	24,  // 59: magma.lte.UsageMonitoringCredit.action:type_name -> magma.lte.UsageMonitoringCredit.Action
	6,   // 60: magma.lte.UsageMonitoringCredit.level:type_name -> magma.lte.MonitoringLevel
	60,  // 61: magma.lte.UsageMonitoringCredit.granted_units:type_name -> magma.lte.GrantedUnits
	67,  // 62: magma.lte.UsageMonitoringUpdateRequest.update:type_name -> magma.lte.UsageMonitorUpdate
	0,   // 63: magma.lte.UsageMonitoringUpdateRequest.rat_type:type_name -> magma.lte.RATType
	73,  // 64: magma.lte.UsageMonitoringUpdateRequest.tgpp_ctx:type_name -> magma.lte.TgppContext
	2,   // 65: magma.lte.UsageMonitoringUpdateRequest.event_trigger:type_name -> magma.lte.EventTrigger
	68,  // 66: magma.lte.UsageMonitoringUpdateResponse.credit:type_name -> magma.lte.UsageMonitoringCredit
	2,   // 67: magma.lte.UsageMonitoringUpdateResponse.event_triggers:type_name -> magma.lte.EventTrigger
	113, // 68: magma.lte.UsageMonitoringUpdateResponse.revalidation_time:type_name -> google.protobuf.Timestamp
	76,  // 69: magma.lte.UsageMonitoringUpdateResponse.static_rules_to_install:type_name -> magma.lte.StaticRuleInstall
	77,  // 70: magma.lte.UsageMonitoringUpdateResponse.dynamic_rules_to_install:type_name -> magma.lte.DynamicRuleInstall
	73,  // 71: magma.lte.UsageMonitoringUpdateResponse.tgpp_ctx:type_name -> magma.lte.TgppContext
	25,  // 72: magma.lte.QosInformationRequest.br_unit:type_name -> magma.lte.QosInformationRequest.BitrateUnitsAMBR
	13,  // 73: magma.lte.M5GQosInformationRequest.preemption_capability:type_name -> magma.lte.prem_capab
	14,  // 74: magma.lte.M5GQosInformationRequest.preemption_vulnerability:type_name -> magma.lte.prem_vuner
	3,   // 75: magma.lte.M5GQosInformationRequest.qos_class_id:type_name -> magma.lte.QCI
	26,  // 76: magma.lte.M5GQosInformationRequest.br_unit:type_name -> magma.lte.M5GQosInformationRequest.BitrateUnitsAMBR
	58,  // 77: magma.lte.CreateSessionRequest.access_timezone:type_name -> magma.lte.Timezone
	63,  // 78: magma.lte.CreateSessionRequest.requested_units:type_name -> magma.lte.RequestedUnits
	36,  // 79: magma.lte.CreateSessionRequest.common_context:type_name -> magma.lte.CommonSessionContext
	37,  // 80: magma.lte.CreateSessionRequest.rat_specific_context:type_name -> magma.lte.RatSpecificContext
	66,  // 81: magma.lte.CreateSessionResponse.credits:type_name -> magma.lte.CreditUpdateResponse
	70,  // 82: magma.lte.CreateSessionResponse.usage_monitors:type_name -> magma.lte.UsageMonitoringUpdateResponse
	76,  // 83: magma.lte.CreateSessionResponse.static_rules:type_name -> magma.lte.StaticRuleInstall
	77,  // 84: magma.lte.CreateSessionResponse.dynamic_rules:type_name -> magma.lte.DynamicRuleInstall
	73,  // 85: magma.lte.CreateSessionResponse.tgpp_ctx:type_name -> magma.lte.TgppContext
	2,   // 86: magma.lte.CreateSessionResponse.event_triggers:type_name -> magma.lte.EventTrigger
	113, // 87: magma.lte.CreateSessionResponse.revalidation_time:type_name -> google.protobuf.Timestamp
	113, // 88: magma.lte.StaticRuleInstall.activation_time:type_name -> google.protobuf.Timestamp
	113, // 89: magma.lte.StaticRuleInstall.deactivation_time:type_name -> google.protobuf.Timestamp
	114, // 90: magma.lte.DynamicRuleInstall.policy_rule:type_name -> magma.lte.PolicyRule
	113, // 91: magma.lte.DynamicRuleInstall.activation_time:type_name -> google.protobuf.Timestamp
	113, // 92: magma.lte.DynamicRuleInstall.deactivation_time:type_name -> google.protobuf.Timestamp
	65,  // 93: magma.lte.UpdateSessionRequest.updates:type_name -> magma.lte.CreditUsageUpdate
	69,  // 94: magma.lte.UpdateSessionRequest.usage_monitors:type_name -> magma.lte.UsageMonitoringUpdateRequest
	66,  // 95: magma.lte.UpdateSessionResponse.responses:type_name -> magma.lte.CreditUpdateResponse
	70,  // 96: magma.lte.UpdateSessionResponse.usage_monitor_responses:type_name -> magma.lte.UsageMonitoringUpdateResponse
	64,  // 97: magma.lte.SessionTerminateRequest.credit_usages:type_name -> magma.lte.CreditUsage
	67,  // 98: magma.lte.SessionTerminateRequest.monitor_usages:type_name -> magma.lte.UsageMonitorUpdate
	73,  // 99: magma.lte.SessionTerminateRequest.tgpp_ctx:type_name -> magma.lte.TgppContext
	36,  // 100: magma.lte.SessionTerminateRequest.common_context:type_name -> magma.lte.CommonSessionContext
	27,  // 101: magma.lte.NodeID.node_id_type:type_name -> magma.lte.NodeID.NodeIDType
	28,  // 102: magma.lte.QosPolicy.policy_state:type_name -> magma.lte.QosPolicy.PolicyState
	29,  // 103: magma.lte.QosPolicy.policy_action:type_name -> magma.lte.QosPolicy.PolicyAction
	114, // 104: magma.lte.QosPolicy.qos:type_name -> magma.lte.PolicyRule
	13,  // 105: magma.lte.allocation_and_retention_prio.pre_emtion_cap:type_name -> magma.lte.prem_capab
	14,  // 106: magma.lte.allocation_and_retention_prio.pre_emtion_vul:type_name -> magma.lte.prem_vuner
	87,  // 107: magma.lte.flow_level_params.qos_chars:type_name -> magma.lte.qos_characteristics
	86,  // 108: magma.lte.flow_level_params.alloc_reten_prio:type_name -> magma.lte.allocation_and_retention_prio
	88,  // 109: magma.lte.qos_flow.param:type_name -> magma.lte.flow_level_params
	89,  // 110: magma.lte.qos_flow_request_list.flow:type_name -> magma.lte.qos_flow
	92,  // 111: magma.lte.LadnServiceArea.identity_list:type_name -> magma.lte.TrackingAreaIdentityList
	15,  // 112: magma.lte.TrackingAreaIdentityList.type_of_list:type_name -> magma.lte.TypeOfList
	10,  // 113: magma.lte.M5GSMSessionContext.request_type:type_name -> magma.lte.RequestType
	61,  // 114: magma.lte.M5GSMSessionContext.pdu_address:type_name -> magma.lte.RedirectServer
	16,  // 115: magma.lte.M5GSMSessionContext.priority_access:type_name -> magma.lte.priorityaccess
	11,  // 116: magma.lte.M5GSMSessionContext.access_type:type_name -> magma.lte.AccessType
	91,  // 117: magma.lte.M5GSMSessionContext.ladn_service_area:type_name -> magma.lte.LadnServiceArea
	12,  // 118: magma.lte.M5GSMSessionContext.dnn_selection_mode:type_name -> magma.lte.DnnSelectionMode
	7,   // 119: magma.lte.M5GSMSessionContext.pdu_session_type:type_name -> magma.lte.PduSessionType
	8,   // 120: magma.lte.M5GSMSessionContext.ssc_mode:type_name -> magma.lte.SscMode
	83,  // 121: magma.lte.M5GSMSessionContext.m5g_sm_capability:type_name -> magma.lte.M5GSMCapability
	9,   // 122: magma.lte.M5GSMSessionContext.m5gsm_cause:type_name -> magma.lte.M5GSMCause
	84,  // 123: magma.lte.M5GSMSessionContext.requested_qos_rules:type_name -> magma.lte.QosRules
	38,  // 124: magma.lte.M5GSMSessionContext.gnode_endpoint:type_name -> magma.lte.TeidSet
	38,  // 125: magma.lte.M5GSMSessionContext.upf_endpoint:type_name -> magma.lte.TeidSet
	72,  // 126: magma.lte.M5GSMSessionContext.subscribed_qos:type_name -> magma.lte.M5GQosInformationRequest
	85,  // 127: magma.lte.M5GSMSessionContext.qos_policy:type_name -> magma.lte.QosPolicy
	36,  // 128: magma.lte.SetSMSessionContext.common_context:type_name -> magma.lte.CommonSessionContext
	37,  // 129: magma.lte.SetSMSessionContext.rat_specific_context:type_name -> magma.lte.RatSpecificContext
	97,  // 130: magma.lte.RatSpecificContextAccess.m5g_session_context_rsp:type_name -> magma.lte.M5GSMSessionContextAccess
	7,   // 131: magma.lte.M5GSMSessionContextAccess.pdu_session_type:type_name -> magma.lte.PduSessionType
	8,   // 132: magma.lte.M5GSMSessionContextAccess.selected_ssc_mode:type_name -> magma.lte.SscMode
	84,  // 133: magma.lte.M5GSMSessionContextAccess.authorized_qos_rules:type_name -> magma.lte.QosRules
	72,  // 134: magma.lte.M5GSMSessionContextAccess.subscribed_qos:type_name -> magma.lte.M5GQosInformationRequest
	9,   // 135: magma.lte.M5GSMSessionContextAccess.M5gsm_cause:type_name -> magma.lte.M5GSMCause
	8,   // 136: magma.lte.M5GSMSessionContextAccess.allowed_ssc_mode:type_name -> magma.lte.SscMode
	61,  // 137: magma.lte.M5GSMSessionContextAccess.pdu_address:type_name -> magma.lte.RedirectServer
	38,  // 138: magma.lte.M5GSMSessionContextAccess.upf_endpoint:type_name -> magma.lte.TeidSet
	85,  // 139: magma.lte.M5GSMSessionContextAccess.qos_policy:type_name -> magma.lte.QosPolicy
	36,  // 140: magma.lte.SetSMSessionContextAccess.common_context:type_name -> magma.lte.CommonSessionContext
	96,  // 141: magma.lte.SetSMSessionContextAccess.rat_specific_context:type_name -> magma.lte.RatSpecificContextAccess
	101, // 142: magma.lte.UPFNodeState.associaton_state:type_name -> magma.lte.UPFAssociationState
	103, // 143: magma.lte.UPFNodeState.node_report:type_name -> magma.lte.UPFNodeReport
	31,  // 144: magma.lte.UPFAssociationState.assoc_state:type_name -> magma.lte.UPFAssociationState.AssociationState
	113, // 145: magma.lte.UPFAssociationState.recovery_time_stamp:type_name -> google.protobuf.Timestamp
	102, // 146: magma.lte.UPFAssociationState.feature_set:type_name -> magma.lte.UPFFeatureSet
	100, // 147: magma.lte.UPFAssociationState.ip_resource_schema:type_name -> magma.lte.UserPlaneIPResourceSchema
	113, // 148: magma.lte.UPFAssociationState.graceful_release_period:type_name -> google.protobuf.Timestamp
	104, // 149: magma.lte.UPFNodeReport.load_control_info:type_name -> magma.lte.LoadControlInformation
	106, // 150: magma.lte.UPFNodeReport.overload_control_info:type_name -> magma.lte.OverloadControlInformation
	105, // 151: magma.lte.OverloadControlInformation.period_of_validity:type_name -> magma.lte.OverloadTimer
	107, // 152: magma.lte.UPFSessionConfigState.upf_session_state:type_name -> magma.lte.UPFSessionState
	19,  // 153: magma.lte.PolicyReAuthAnswer.FailedRulesEntry.value:type_name -> magma.lte.PolicyReAuthAnswer.FailureCode
	33,  // 154: magma.lte.LocalSessionManager.ReportRuleStats:input_type -> magma.lte.RuleRecordTable
	34,  // 155: magma.lte.LocalSessionManager.CreateSession:input_type -> magma.lte.LocalCreateSessionRequest
	44,  // 156: magma.lte.LocalSessionManager.EndSession:input_type -> magma.lte.LocalEndSessionRequest
	48,  // 157: magma.lte.LocalSessionManager.BindPolicy2Bearer:input_type -> magma.lte.PolicyBearerBindingRequest
	57,  // 158: magma.lte.LocalSessionManager.SetSessionRules:input_type -> magma.lte.SessionRules
	46,  // 159: magma.lte.LocalSessionManager.UpdateTunnelIds:input_type -> magma.lte.UpdateTunnelIdsRequest
	50,  // 160: magma.lte.SessionProxyResponder.ChargingReAuth:input_type -> magma.lte.ChargingReAuthRequest
	52,  // 161: magma.lte.SessionProxyResponder.PolicyReAuth:input_type -> magma.lte.PolicyReAuthRequest
	74,  // 162: magma.lte.CentralSessionController.CreateSession:input_type -> magma.lte.CreateSessionRequest
	78,  // 163: magma.lte.CentralSessionController.UpdateSession:input_type -> magma.lte.UpdateSessionRequest
	81,  // 164: magma.lte.CentralSessionController.TerminateSession:input_type -> magma.lte.SessionTerminateRequest
	99,  // 165: magma.lte.SetInterfaceForUserPlane.SetUPFNodeState:input_type -> magma.lte.UPFNodeState
	108, // 166: magma.lte.SetInterfaceForUserPlane.SetUPFSessionsConfig:input_type -> magma.lte.UPFSessionConfigState
	109, // 167: magma.lte.SetInterfaceForUserPlane.SendPagingRequest:input_type -> magma.lte.UPFPagingInfo
	94,  // 168: magma.lte.AmfPduSessionSmContext.SetAmfSessionContext:input_type -> magma.lte.SetSMSessionContext
	40,  // 169: magma.lte.AmfPduSessionSmContext.SetSmfNotification:input_type -> magma.lte.SetSmNotificationContext
	40,  // 170: magma.lte.SmfPduSessionSmContext.SetAmfNotification:input_type -> magma.lte.SetSmNotificationContext
	98,  // 171: magma.lte.SmfPduSessionSmContext.SetSmfSessionContext:input_type -> magma.lte.SetSMSessionContextAccess
	115, // 172: magma.lte.LocalSessionManager.ReportRuleStats:output_type -> magma.orc8r.Void
	43,  // 173: magma.lte.LocalSessionManager.CreateSession:output_type -> magma.lte.LocalCreateSessionResponse
	45,  // 174: magma.lte.LocalSessionManager.EndSession:output_type -> magma.lte.LocalEndSessionResponse
	49,  // 175: magma.lte.LocalSessionManager.BindPolicy2Bearer:output_type -> magma.lte.PolicyBearerBindingResponse
	115, // 176: magma.lte.LocalSessionManager.SetSessionRules:output_type -> magma.orc8r.Void
	47,  // 177: magma.lte.LocalSessionManager.UpdateTunnelIds:output_type -> magma.lte.UpdateTunnelIdsResponse
	51,  // 178: magma.lte.SessionProxyResponder.ChargingReAuth:output_type -> magma.lte.ChargingReAuthAnswer
	54,  // 179: magma.lte.SessionProxyResponder.PolicyReAuth:output_type -> magma.lte.PolicyReAuthAnswer
	75,  // 180: magma.lte.CentralSessionController.CreateSession:output_type -> magma.lte.CreateSessionResponse
	79,  // 181: magma.lte.CentralSessionController.UpdateSession:output_type -> magma.lte.UpdateSessionResponse
	80,  // 182: magma.lte.CentralSessionController.TerminateSession:output_type -> magma.lte.SessionTerminateResponse
	95,  // 183: magma.lte.SetInterfaceForUserPlane.SetUPFNodeState:output_type -> magma.lte.SmContextVoid
	95,  // 184: magma.lte.SetInterfaceForUserPlane.SetUPFSessionsConfig:output_type -> magma.lte.SmContextVoid
	95,  // 185: magma.lte.SetInterfaceForUserPlane.SendPagingRequest:output_type -> magma.lte.SmContextVoid
	95,  // 186: magma.lte.AmfPduSessionSmContext.SetAmfSessionContext:output_type -> magma.lte.SmContextVoid
	95,  // 187: magma.lte.AmfPduSessionSmContext.SetSmfNotification:output_type -> magma.lte.SmContextVoid
	95,  // 188: magma.lte.SmfPduSessionSmContext.SetAmfNotification:output_type -> magma.lte.SmContextVoid
	95,  // 189: magma.lte.SmfPduSessionSmContext.SetSmfSessionContext:output_type -> magma.lte.SmContextVoid
	172, // [172:190] is the sub-list for method output_type
	154, // [154:172] is the sub-list for method input_type
	154, // [154:154] is the sub-list for extension type_name
	154, // [154:154] is the sub-list for extension extendee
	0,   // [0:154] is the sub-list for field type_name
}

func init() { file_lte_protos_session_manager_proto_init() }
func file_lte_protos_session_manager_proto_init() {
	if File_lte_protos_session_manager_proto != nil {
		return
	}
	file_lte_protos_policydb_proto_init()
	file_lte_protos_subscriberdb_proto_init()
	if !protoimpl.UnsafeEnabled {
		file_lte_protos_session_manager_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*RuleRecord); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*RuleRecordTable); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*LocalCreateSessionRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Teids); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*CommonSessionContext); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*RatSpecificContext); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TeidSet); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*RatSpecificNotification); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*SetSmNotificationContext); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*LTESessionContext); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*WLANSessionContext); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*LocalCreateSessionResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*LocalEndSessionRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*LocalEndSessionResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UpdateTunnelIdsRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UpdateTunnelIdsResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*PolicyBearerBindingRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*PolicyBearerBindingResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*ChargingReAuthRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*ChargingReAuthAnswer); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*PolicyReAuthRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*QoSInformation); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*PolicyReAuthAnswer); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*RuleSet); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*RulesPerSubscriber); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*SessionRules); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Timezone); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*CreditUnit); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*GrantedUnits); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*RedirectServer); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*ChargingCredit); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*RequestedUnits); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*CreditUsage); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*CreditUsageUpdate); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*CreditUpdateResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UsageMonitorUpdate); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UsageMonitoringCredit); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UsageMonitoringUpdateRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UsageMonitoringUpdateResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*QosInformationRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*M5GQosInformationRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TgppContext); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*CreateSessionRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*CreateSessionResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*StaticRuleInstall); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*DynamicRuleInstall); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UpdateSessionRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UpdateSessionResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*SessionTerminateResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*SessionTerminateRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*NodeID); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*M5GSMCapability); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*QosRules); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*QosPolicy); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*AllocationAndRetentionPrio); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*QosCharacteristics); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*FlowLevelParams); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*QosFlow); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*QosFlowRequestList); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*LadnServiceArea); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TrackingAreaIdentityList); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*M5GSMSessionContext); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*SetSMSessionContext); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*SmContextVoid); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*RatSpecificContextAccess); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*M5GSMSessionContextAccess); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*SetSMSessionContextAccess); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UPFNodeState); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UserPlaneIPResourceSchema); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UPFAssociationState); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UPFFeatureSet); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UPFNodeReport); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*LoadControlInformation); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*OverloadTimer); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*OverloadControlInformation); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UPFSessionState); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UPFSessionConfigState); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_lte_protos_session_manager_proto_msgTypes[77].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*UPFPagingInfo); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
	}
	file_lte_protos_session_manager_proto_msgTypes[5].OneofWrappers = []interface{}{
		(*RatSpecificContext_LteContext)(nil),
		(*RatSpecificContext_WlanContext)(nil),
		(*RatSpecificContext_M5GsmSessionContext)(nil),
	}
	file_lte_protos_session_manager_proto_msgTypes[67].OneofWrappers = []interface{}{
		(*UPFNodeState_AssociatonState)(nil),
		(*UPFNodeState_NodeReport)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: file_lte_protos_session_manager_proto_rawDesc,
			NumEnums:      32,
			NumMessages:   79,
			NumExtensions: 0,
			NumServices:   6,
		},
		GoTypes:           file_lte_protos_session_manager_proto_goTypes,
		DependencyIndexes: file_lte_protos_session_manager_proto_depIdxs,
		EnumInfos:         file_lte_protos_session_manager_proto_enumTypes,
		MessageInfos:      file_lte_protos_session_manager_proto_msgTypes,
	}.Build()
	File_lte_protos_session_manager_proto = out.File
	file_lte_protos_session_manager_proto_rawDesc = nil
	file_lte_protos_session_manager_proto_goTypes = nil
	file_lte_protos_session_manager_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

// LocalSessionManagerClient is the client API for LocalSessionManager service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type LocalSessionManagerClient interface {
	ReportRuleStats(ctx context.Context, in *RuleRecordTable, opts ...grpc.CallOption) (*protos.Void, error)
	CreateSession(ctx context.Context, in *LocalCreateSessionRequest, opts ...grpc.CallOption) (*LocalCreateSessionResponse, error)
	EndSession(ctx context.Context, in *LocalEndSessionRequest, opts ...grpc.CallOption) (*LocalEndSessionResponse, error)
	// A response to CreateBearer request defined in spgw service. Sends a mapping of dedicated bearer ID <-> policy.
	BindPolicy2Bearer(ctx context.Context, in *PolicyBearerBindingRequest, opts ...grpc.CallOption) (*PolicyBearerBindingResponse, error)
	// A set interface of subscribers -> currently active rules
	SetSessionRules(ctx context.Context, in *SessionRules, opts ...grpc.CallOption) (*protos.Void, error)
	UpdateTunnelIds(ctx context.Context, in *UpdateTunnelIdsRequest, opts ...grpc.CallOption) (*UpdateTunnelIdsResponse, error)
}

type localSessionManagerClient struct {
	cc grpc.ClientConnInterface
}

func NewLocalSessionManagerClient(cc grpc.ClientConnInterface) LocalSessionManagerClient {
	return &localSessionManagerClient{cc}
}

func (c *localSessionManagerClient) ReportRuleStats(ctx context.Context, in *RuleRecordTable, opts ...grpc.CallOption) (*protos.Void, error) {
	out := new(protos.Void)
	err := c.cc.Invoke(ctx, "/magma.lte.LocalSessionManager/ReportRuleStats", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *localSessionManagerClient) CreateSession(ctx context.Context, in *LocalCreateSessionRequest, opts ...grpc.CallOption) (*LocalCreateSessionResponse, error) {
	out := new(LocalCreateSessionResponse)
	err := c.cc.Invoke(ctx, "/magma.lte.LocalSessionManager/CreateSession", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *localSessionManagerClient) EndSession(ctx context.Context, in *LocalEndSessionRequest, opts ...grpc.CallOption) (*LocalEndSessionResponse, error) {
	out := new(LocalEndSessionResponse)
	err := c.cc.Invoke(ctx, "/magma.lte.LocalSessionManager/EndSession", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *localSessionManagerClient) BindPolicy2Bearer(ctx context.Context, in *PolicyBearerBindingRequest, opts ...grpc.CallOption) (*PolicyBearerBindingResponse, error) {
	out := new(PolicyBearerBindingResponse)
	err := c.cc.Invoke(ctx, "/magma.lte.LocalSessionManager/BindPolicy2Bearer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *localSessionManagerClient) SetSessionRules(ctx context.Context, in *SessionRules, opts ...grpc.CallOption) (*protos.Void, error) {
	out := new(protos.Void)
	err := c.cc.Invoke(ctx, "/magma.lte.LocalSessionManager/SetSessionRules", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *localSessionManagerClient) UpdateTunnelIds(ctx context.Context, in *UpdateTunnelIdsRequest, opts ...grpc.CallOption) (*UpdateTunnelIdsResponse, error) {
	out := new(UpdateTunnelIdsResponse)
	err := c.cc.Invoke(ctx, "/magma.lte.LocalSessionManager/UpdateTunnelIds", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// LocalSessionManagerServer is the server API for LocalSessionManager service.
type LocalSessionManagerServer interface {
	ReportRuleStats(context.Context, *RuleRecordTable) (*protos.Void, error)
	CreateSession(context.Context, *LocalCreateSessionRequest) (*LocalCreateSessionResponse, error)
	EndSession(context.Context, *LocalEndSessionRequest) (*LocalEndSessionResponse, error)
	// A response to CreateBearer request defined in spgw service. Sends a mapping of dedicated bearer ID <-> policy.
	BindPolicy2Bearer(context.Context, *PolicyBearerBindingRequest) (*PolicyBearerBindingResponse, error)
	// A set interface of subscribers -> currently active rules
	SetSessionRules(context.Context, *SessionRules) (*protos.Void, error)
	UpdateTunnelIds(context.Context, *UpdateTunnelIdsRequest) (*UpdateTunnelIdsResponse, error)
}

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

func (*UnimplementedLocalSessionManagerServer) ReportRuleStats(context.Context, *RuleRecordTable) (*protos.Void, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReportRuleStats not implemented")
}
func (*UnimplementedLocalSessionManagerServer) CreateSession(context.Context, *LocalCreateSessionRequest) (*LocalCreateSessionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSession not implemented")
}
func (*UnimplementedLocalSessionManagerServer) EndSession(context.Context, *LocalEndSessionRequest) (*LocalEndSessionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EndSession not implemented")
}
func (*UnimplementedLocalSessionManagerServer) BindPolicy2Bearer(context.Context, *PolicyBearerBindingRequest) (*PolicyBearerBindingResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BindPolicy2Bearer not implemented")
}
func (*UnimplementedLocalSessionManagerServer) SetSessionRules(context.Context, *SessionRules) (*protos.Void, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetSessionRules not implemented")
}
func (*UnimplementedLocalSessionManagerServer) UpdateTunnelIds(context.Context, *UpdateTunnelIdsRequest) (*UpdateTunnelIdsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateTunnelIds not implemented")
}

func RegisterLocalSessionManagerServer(s *grpc.Server, srv LocalSessionManagerServer) {
	s.RegisterService(&_LocalSessionManager_serviceDesc, srv)
}

func _LocalSessionManager_ReportRuleStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RuleRecordTable)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LocalSessionManagerServer).ReportRuleStats(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.LocalSessionManager/ReportRuleStats",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LocalSessionManagerServer).ReportRuleStats(ctx, req.(*RuleRecordTable))
	}
	return interceptor(ctx, in, info, handler)
}

func _LocalSessionManager_CreateSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LocalCreateSessionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LocalSessionManagerServer).CreateSession(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.LocalSessionManager/CreateSession",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LocalSessionManagerServer).CreateSession(ctx, req.(*LocalCreateSessionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LocalSessionManager_EndSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LocalEndSessionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LocalSessionManagerServer).EndSession(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.LocalSessionManager/EndSession",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LocalSessionManagerServer).EndSession(ctx, req.(*LocalEndSessionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LocalSessionManager_BindPolicy2Bearer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PolicyBearerBindingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LocalSessionManagerServer).BindPolicy2Bearer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.LocalSessionManager/BindPolicy2Bearer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LocalSessionManagerServer).BindPolicy2Bearer(ctx, req.(*PolicyBearerBindingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LocalSessionManager_SetSessionRules_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SessionRules)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LocalSessionManagerServer).SetSessionRules(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.LocalSessionManager/SetSessionRules",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LocalSessionManagerServer).SetSessionRules(ctx, req.(*SessionRules))
	}
	return interceptor(ctx, in, info, handler)
}

func _LocalSessionManager_UpdateTunnelIds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateTunnelIdsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LocalSessionManagerServer).UpdateTunnelIds(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.LocalSessionManager/UpdateTunnelIds",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LocalSessionManagerServer).UpdateTunnelIds(ctx, req.(*UpdateTunnelIdsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _LocalSessionManager_serviceDesc = grpc.ServiceDesc{
	ServiceName: "magma.lte.LocalSessionManager",
	HandlerType: (*LocalSessionManagerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ReportRuleStats",
			Handler:    _LocalSessionManager_ReportRuleStats_Handler,
		},
		{
			MethodName: "CreateSession",
			Handler:    _LocalSessionManager_CreateSession_Handler,
		},
		{
			MethodName: "EndSession",
			Handler:    _LocalSessionManager_EndSession_Handler,
		},
		{
			MethodName: "BindPolicy2Bearer",
			Handler:    _LocalSessionManager_BindPolicy2Bearer_Handler,
		},
		{
			MethodName: "SetSessionRules",
			Handler:    _LocalSessionManager_SetSessionRules_Handler,
		},
		{
			MethodName: "UpdateTunnelIds",
			Handler:    _LocalSessionManager_UpdateTunnelIds_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "lte/protos/session_manager.proto",
}

// SessionProxyResponderClient is the client API for SessionProxyResponder service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SessionProxyResponderClient interface {
	ChargingReAuth(ctx context.Context, in *ChargingReAuthRequest, opts ...grpc.CallOption) (*ChargingReAuthAnswer, error)
	// NOTE: if no session_id is specified, apply to all sessions for the IMSI
	PolicyReAuth(ctx context.Context, in *PolicyReAuthRequest, opts ...grpc.CallOption) (*PolicyReAuthAnswer, error)
}

type sessionProxyResponderClient struct {
	cc grpc.ClientConnInterface
}

func NewSessionProxyResponderClient(cc grpc.ClientConnInterface) SessionProxyResponderClient {
	return &sessionProxyResponderClient{cc}
}

func (c *sessionProxyResponderClient) ChargingReAuth(ctx context.Context, in *ChargingReAuthRequest, opts ...grpc.CallOption) (*ChargingReAuthAnswer, error) {
	out := new(ChargingReAuthAnswer)
	err := c.cc.Invoke(ctx, "/magma.lte.SessionProxyResponder/ChargingReAuth", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sessionProxyResponderClient) PolicyReAuth(ctx context.Context, in *PolicyReAuthRequest, opts ...grpc.CallOption) (*PolicyReAuthAnswer, error) {
	out := new(PolicyReAuthAnswer)
	err := c.cc.Invoke(ctx, "/magma.lte.SessionProxyResponder/PolicyReAuth", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SessionProxyResponderServer is the server API for SessionProxyResponder service.
type SessionProxyResponderServer interface {
	ChargingReAuth(context.Context, *ChargingReAuthRequest) (*ChargingReAuthAnswer, error)
	// NOTE: if no session_id is specified, apply to all sessions for the IMSI
	PolicyReAuth(context.Context, *PolicyReAuthRequest) (*PolicyReAuthAnswer, error)
}

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

func (*UnimplementedSessionProxyResponderServer) ChargingReAuth(context.Context, *ChargingReAuthRequest) (*ChargingReAuthAnswer, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ChargingReAuth not implemented")
}
func (*UnimplementedSessionProxyResponderServer) PolicyReAuth(context.Context, *PolicyReAuthRequest) (*PolicyReAuthAnswer, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PolicyReAuth not implemented")
}

func RegisterSessionProxyResponderServer(s *grpc.Server, srv SessionProxyResponderServer) {
	s.RegisterService(&_SessionProxyResponder_serviceDesc, srv)
}

func _SessionProxyResponder_ChargingReAuth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChargingReAuthRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SessionProxyResponderServer).ChargingReAuth(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.SessionProxyResponder/ChargingReAuth",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SessionProxyResponderServer).ChargingReAuth(ctx, req.(*ChargingReAuthRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SessionProxyResponder_PolicyReAuth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PolicyReAuthRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SessionProxyResponderServer).PolicyReAuth(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.SessionProxyResponder/PolicyReAuth",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SessionProxyResponderServer).PolicyReAuth(ctx, req.(*PolicyReAuthRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _SessionProxyResponder_serviceDesc = grpc.ServiceDesc{
	ServiceName: "magma.lte.SessionProxyResponder",
	HandlerType: (*SessionProxyResponderServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ChargingReAuth",
			Handler:    _SessionProxyResponder_ChargingReAuth_Handler,
		},
		{
			MethodName: "PolicyReAuth",
			Handler:    _SessionProxyResponder_PolicyReAuth_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "lte/protos/session_manager.proto",
}

// CentralSessionControllerClient is the client API for CentralSessionController service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type CentralSessionControllerClient interface {
	// Notify OCS/PCRF of new session and return rules associated with subscriber
	// along with credits for each rule
	CreateSession(ctx context.Context, in *CreateSessionRequest, opts ...grpc.CallOption) (*CreateSessionResponse, error)
	// Updates OCS/PCRF with used credit and terminations from gateway
	UpdateSession(ctx context.Context, in *UpdateSessionRequest, opts ...grpc.CallOption) (*UpdateSessionResponse, error)
	// Terminates session in OCS/PCRF for a subscriber
	TerminateSession(ctx context.Context, in *SessionTerminateRequest, opts ...grpc.CallOption) (*SessionTerminateResponse, error)
}

type centralSessionControllerClient struct {
	cc grpc.ClientConnInterface
}

func NewCentralSessionControllerClient(cc grpc.ClientConnInterface) CentralSessionControllerClient {
	return &centralSessionControllerClient{cc}
}

func (c *centralSessionControllerClient) CreateSession(ctx context.Context, in *CreateSessionRequest, opts ...grpc.CallOption) (*CreateSessionResponse, error) {
	out := new(CreateSessionResponse)
	err := c.cc.Invoke(ctx, "/magma.lte.CentralSessionController/CreateSession", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *centralSessionControllerClient) UpdateSession(ctx context.Context, in *UpdateSessionRequest, opts ...grpc.CallOption) (*UpdateSessionResponse, error) {
	out := new(UpdateSessionResponse)
	err := c.cc.Invoke(ctx, "/magma.lte.CentralSessionController/UpdateSession", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *centralSessionControllerClient) TerminateSession(ctx context.Context, in *SessionTerminateRequest, opts ...grpc.CallOption) (*SessionTerminateResponse, error) {
	out := new(SessionTerminateResponse)
	err := c.cc.Invoke(ctx, "/magma.lte.CentralSessionController/TerminateSession", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CentralSessionControllerServer is the server API for CentralSessionController service.
type CentralSessionControllerServer interface {
	// Notify OCS/PCRF of new session and return rules associated with subscriber
	// along with credits for each rule
	CreateSession(context.Context, *CreateSessionRequest) (*CreateSessionResponse, error)
	// Updates OCS/PCRF with used credit and terminations from gateway
	UpdateSession(context.Context, *UpdateSessionRequest) (*UpdateSessionResponse, error)
	// Terminates session in OCS/PCRF for a subscriber
	TerminateSession(context.Context, *SessionTerminateRequest) (*SessionTerminateResponse, error)
}

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

func (*UnimplementedCentralSessionControllerServer) CreateSession(context.Context, *CreateSessionRequest) (*CreateSessionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSession not implemented")
}
func (*UnimplementedCentralSessionControllerServer) UpdateSession(context.Context, *UpdateSessionRequest) (*UpdateSessionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateSession not implemented")
}
func (*UnimplementedCentralSessionControllerServer) TerminateSession(context.Context, *SessionTerminateRequest) (*SessionTerminateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TerminateSession not implemented")
}

func RegisterCentralSessionControllerServer(s *grpc.Server, srv CentralSessionControllerServer) {
	s.RegisterService(&_CentralSessionController_serviceDesc, srv)
}

func _CentralSessionController_CreateSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateSessionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CentralSessionControllerServer).CreateSession(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.CentralSessionController/CreateSession",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CentralSessionControllerServer).CreateSession(ctx, req.(*CreateSessionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CentralSessionController_UpdateSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateSessionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CentralSessionControllerServer).UpdateSession(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.CentralSessionController/UpdateSession",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CentralSessionControllerServer).UpdateSession(ctx, req.(*UpdateSessionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CentralSessionController_TerminateSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SessionTerminateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CentralSessionControllerServer).TerminateSession(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.CentralSessionController/TerminateSession",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CentralSessionControllerServer).TerminateSession(ctx, req.(*SessionTerminateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _CentralSessionController_serviceDesc = grpc.ServiceDesc{
	ServiceName: "magma.lte.CentralSessionController",
	HandlerType: (*CentralSessionControllerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateSession",
			Handler:    _CentralSessionController_CreateSession_Handler,
		},
		{
			MethodName: "UpdateSession",
			Handler:    _CentralSessionController_UpdateSession_Handler,
		},
		{
			MethodName: "TerminateSession",
			Handler:    _CentralSessionController_TerminateSession_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "lte/protos/session_manager.proto",
}

// SetInterfaceForUserPlaneClient is the client API for SetInterfaceForUserPlane service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SetInterfaceForUserPlaneClient interface {
	SetUPFNodeState(ctx context.Context, in *UPFNodeState, opts ...grpc.CallOption) (*SmContextVoid, error)
	SetUPFSessionsConfig(ctx context.Context, in *UPFSessionConfigState, opts ...grpc.CallOption) (*SmContextVoid, error)
	SendPagingRequest(ctx context.Context, in *UPFPagingInfo, opts ...grpc.CallOption) (*SmContextVoid, error)
}

type setInterfaceForUserPlaneClient struct {
	cc grpc.ClientConnInterface
}

func NewSetInterfaceForUserPlaneClient(cc grpc.ClientConnInterface) SetInterfaceForUserPlaneClient {
	return &setInterfaceForUserPlaneClient{cc}
}

func (c *setInterfaceForUserPlaneClient) SetUPFNodeState(ctx context.Context, in *UPFNodeState, opts ...grpc.CallOption) (*SmContextVoid, error) {
	out := new(SmContextVoid)
	err := c.cc.Invoke(ctx, "/magma.lte.SetInterfaceForUserPlane/SetUPFNodeState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *setInterfaceForUserPlaneClient) SetUPFSessionsConfig(ctx context.Context, in *UPFSessionConfigState, opts ...grpc.CallOption) (*SmContextVoid, error) {
	out := new(SmContextVoid)
	err := c.cc.Invoke(ctx, "/magma.lte.SetInterfaceForUserPlane/SetUPFSessionsConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *setInterfaceForUserPlaneClient) SendPagingRequest(ctx context.Context, in *UPFPagingInfo, opts ...grpc.CallOption) (*SmContextVoid, error) {
	out := new(SmContextVoid)
	err := c.cc.Invoke(ctx, "/magma.lte.SetInterfaceForUserPlane/SendPagingRequest", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SetInterfaceForUserPlaneServer is the server API for SetInterfaceForUserPlane service.
type SetInterfaceForUserPlaneServer interface {
	SetUPFNodeState(context.Context, *UPFNodeState) (*SmContextVoid, error)
	SetUPFSessionsConfig(context.Context, *UPFSessionConfigState) (*SmContextVoid, error)
	SendPagingRequest(context.Context, *UPFPagingInfo) (*SmContextVoid, error)
}

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

func (*UnimplementedSetInterfaceForUserPlaneServer) SetUPFNodeState(context.Context, *UPFNodeState) (*SmContextVoid, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetUPFNodeState not implemented")
}
func (*UnimplementedSetInterfaceForUserPlaneServer) SetUPFSessionsConfig(context.Context, *UPFSessionConfigState) (*SmContextVoid, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetUPFSessionsConfig not implemented")
}
func (*UnimplementedSetInterfaceForUserPlaneServer) SendPagingRequest(context.Context, *UPFPagingInfo) (*SmContextVoid, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendPagingRequest not implemented")
}

func RegisterSetInterfaceForUserPlaneServer(s *grpc.Server, srv SetInterfaceForUserPlaneServer) {
	s.RegisterService(&_SetInterfaceForUserPlane_serviceDesc, srv)
}

func _SetInterfaceForUserPlane_SetUPFNodeState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UPFNodeState)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SetInterfaceForUserPlaneServer).SetUPFNodeState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.SetInterfaceForUserPlane/SetUPFNodeState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SetInterfaceForUserPlaneServer).SetUPFNodeState(ctx, req.(*UPFNodeState))
	}
	return interceptor(ctx, in, info, handler)
}

func _SetInterfaceForUserPlane_SetUPFSessionsConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UPFSessionConfigState)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SetInterfaceForUserPlaneServer).SetUPFSessionsConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.SetInterfaceForUserPlane/SetUPFSessionsConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SetInterfaceForUserPlaneServer).SetUPFSessionsConfig(ctx, req.(*UPFSessionConfigState))
	}
	return interceptor(ctx, in, info, handler)
}

func _SetInterfaceForUserPlane_SendPagingRequest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UPFPagingInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SetInterfaceForUserPlaneServer).SendPagingRequest(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.SetInterfaceForUserPlane/SendPagingRequest",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SetInterfaceForUserPlaneServer).SendPagingRequest(ctx, req.(*UPFPagingInfo))
	}
	return interceptor(ctx, in, info, handler)
}

var _SetInterfaceForUserPlane_serviceDesc = grpc.ServiceDesc{
	ServiceName: "magma.lte.SetInterfaceForUserPlane",
	HandlerType: (*SetInterfaceForUserPlaneServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SetUPFNodeState",
			Handler:    _SetInterfaceForUserPlane_SetUPFNodeState_Handler,
		},
		{
			MethodName: "SetUPFSessionsConfig",
			Handler:    _SetInterfaceForUserPlane_SetUPFSessionsConfig_Handler,
		},
		{
			MethodName: "SendPagingRequest",
			Handler:    _SetInterfaceForUserPlane_SendPagingRequest_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "lte/protos/session_manager.proto",
}

// AmfPduSessionSmContextClient is the client API for AmfPduSessionSmContext service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AmfPduSessionSmContextClient interface {
	// PDU session related configuration from amf to smf
	SetAmfSessionContext(ctx context.Context, in *SetSMSessionContext, opts ...grpc.CallOption) (*SmContextVoid, error)
	// PDU session related notification from amf to smf
	SetSmfNotification(ctx context.Context, in *SetSmNotificationContext, opts ...grpc.CallOption) (*SmContextVoid, error)
}

type amfPduSessionSmContextClient struct {
	cc grpc.ClientConnInterface
}

func NewAmfPduSessionSmContextClient(cc grpc.ClientConnInterface) AmfPduSessionSmContextClient {
	return &amfPduSessionSmContextClient{cc}
}

func (c *amfPduSessionSmContextClient) SetAmfSessionContext(ctx context.Context, in *SetSMSessionContext, opts ...grpc.CallOption) (*SmContextVoid, error) {
	out := new(SmContextVoid)
	err := c.cc.Invoke(ctx, "/magma.lte.AmfPduSessionSmContext/SetAmfSessionContext", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *amfPduSessionSmContextClient) SetSmfNotification(ctx context.Context, in *SetSmNotificationContext, opts ...grpc.CallOption) (*SmContextVoid, error) {
	out := new(SmContextVoid)
	err := c.cc.Invoke(ctx, "/magma.lte.AmfPduSessionSmContext/SetSmfNotification", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AmfPduSessionSmContextServer is the server API for AmfPduSessionSmContext service.
type AmfPduSessionSmContextServer interface {
	// PDU session related configuration from amf to smf
	SetAmfSessionContext(context.Context, *SetSMSessionContext) (*SmContextVoid, error)
	// PDU session related notification from amf to smf
	SetSmfNotification(context.Context, *SetSmNotificationContext) (*SmContextVoid, error)
}

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

func (*UnimplementedAmfPduSessionSmContextServer) SetAmfSessionContext(context.Context, *SetSMSessionContext) (*SmContextVoid, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetAmfSessionContext not implemented")
}
func (*UnimplementedAmfPduSessionSmContextServer) SetSmfNotification(context.Context, *SetSmNotificationContext) (*SmContextVoid, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetSmfNotification not implemented")
}

func RegisterAmfPduSessionSmContextServer(s *grpc.Server, srv AmfPduSessionSmContextServer) {
	s.RegisterService(&_AmfPduSessionSmContext_serviceDesc, srv)
}

func _AmfPduSessionSmContext_SetAmfSessionContext_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetSMSessionContext)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AmfPduSessionSmContextServer).SetAmfSessionContext(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.AmfPduSessionSmContext/SetAmfSessionContext",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AmfPduSessionSmContextServer).SetAmfSessionContext(ctx, req.(*SetSMSessionContext))
	}
	return interceptor(ctx, in, info, handler)
}

func _AmfPduSessionSmContext_SetSmfNotification_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetSmNotificationContext)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AmfPduSessionSmContextServer).SetSmfNotification(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.AmfPduSessionSmContext/SetSmfNotification",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AmfPduSessionSmContextServer).SetSmfNotification(ctx, req.(*SetSmNotificationContext))
	}
	return interceptor(ctx, in, info, handler)
}

var _AmfPduSessionSmContext_serviceDesc = grpc.ServiceDesc{
	ServiceName: "magma.lte.AmfPduSessionSmContext",
	HandlerType: (*AmfPduSessionSmContextServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SetAmfSessionContext",
			Handler:    _AmfPduSessionSmContext_SetAmfSessionContext_Handler,
		},
		{
			MethodName: "SetSmfNotification",
			Handler:    _AmfPduSessionSmContext_SetSmfNotification_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "lte/protos/session_manager.proto",
}

// SmfPduSessionSmContextClient is the client API for SmfPduSessionSmContext service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SmfPduSessionSmContextClient interface {
	SetAmfNotification(ctx context.Context, in *SetSmNotificationContext, opts ...grpc.CallOption) (*SmContextVoid, error)
	SetSmfSessionContext(ctx context.Context, in *SetSMSessionContextAccess, opts ...grpc.CallOption) (*SmContextVoid, error)
}

type smfPduSessionSmContextClient struct {
	cc grpc.ClientConnInterface
}

func NewSmfPduSessionSmContextClient(cc grpc.ClientConnInterface) SmfPduSessionSmContextClient {
	return &smfPduSessionSmContextClient{cc}
}

func (c *smfPduSessionSmContextClient) SetAmfNotification(ctx context.Context, in *SetSmNotificationContext, opts ...grpc.CallOption) (*SmContextVoid, error) {
	out := new(SmContextVoid)
	err := c.cc.Invoke(ctx, "/magma.lte.SmfPduSessionSmContext/SetAmfNotification", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *smfPduSessionSmContextClient) SetSmfSessionContext(ctx context.Context, in *SetSMSessionContextAccess, opts ...grpc.CallOption) (*SmContextVoid, error) {
	out := new(SmContextVoid)
	err := c.cc.Invoke(ctx, "/magma.lte.SmfPduSessionSmContext/SetSmfSessionContext", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SmfPduSessionSmContextServer is the server API for SmfPduSessionSmContext service.
type SmfPduSessionSmContextServer interface {
	SetAmfNotification(context.Context, *SetSmNotificationContext) (*SmContextVoid, error)
	SetSmfSessionContext(context.Context, *SetSMSessionContextAccess) (*SmContextVoid, error)
}

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

func (*UnimplementedSmfPduSessionSmContextServer) SetAmfNotification(context.Context, *SetSmNotificationContext) (*SmContextVoid, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetAmfNotification not implemented")
}
func (*UnimplementedSmfPduSessionSmContextServer) SetSmfSessionContext(context.Context, *SetSMSessionContextAccess) (*SmContextVoid, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetSmfSessionContext not implemented")
}

func RegisterSmfPduSessionSmContextServer(s *grpc.Server, srv SmfPduSessionSmContextServer) {
	s.RegisterService(&_SmfPduSessionSmContext_serviceDesc, srv)
}

func _SmfPduSessionSmContext_SetAmfNotification_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetSmNotificationContext)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SmfPduSessionSmContextServer).SetAmfNotification(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.SmfPduSessionSmContext/SetAmfNotification",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SmfPduSessionSmContextServer).SetAmfNotification(ctx, req.(*SetSmNotificationContext))
	}
	return interceptor(ctx, in, info, handler)
}

func _SmfPduSessionSmContext_SetSmfSessionContext_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetSMSessionContextAccess)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SmfPduSessionSmContextServer).SetSmfSessionContext(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/magma.lte.SmfPduSessionSmContext/SetSmfSessionContext",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SmfPduSessionSmContextServer).SetSmfSessionContext(ctx, req.(*SetSMSessionContextAccess))
	}
	return interceptor(ctx, in, info, handler)
}

var _SmfPduSessionSmContext_serviceDesc = grpc.ServiceDesc{
	ServiceName: "magma.lte.SmfPduSessionSmContext",
	HandlerType: (*SmfPduSessionSmContextServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SetAmfNotification",
			Handler:    _SmfPduSessionSmContext_SetAmfNotification_Handler,
		},
		{
			MethodName: "SetSmfSessionContext",
			Handler:    _SmfPduSessionSmContext_SetSmfSessionContext_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "lte/protos/session_manager.proto",
}


text:
DESCRIPTION = "An audio format Conversion library"
HOMEPAGE = "http://www.mega-nerd.com/libsndfile"
AUTHOR = "Erik de Castro Lopo"
SECTION = "libs/multimedia"
LICENSE = "LGPL"
DEPENDS = "sqlite3"
PR = "r1"

SRC_URI = "http://www.mega-nerd.com/libsndfile/libsndfile-${PV}.tar.gz \
          "

S = "${WORKDIR}/libsndfile-${PV}"

inherit autotools_stage  lib_package pkgconfig

do_configure_prepend_arm() {
	export ac_cv_sys_largefile_source=1
	export ac_cv_sys_file_offset_bits=64
	ac_cv_sizeof_off_t=8
}

do_configure_prepend_chinook-compat () {

        for i in  lt~obsolete.m4 ltsugar.m4 libtool.m4 ltoptions.m4 ltversion.m4
        do
                rm ${S}/M4/${i}
        done
}

PACKAGES =+ "${PN}-octave"
FILES_${PN}-octave += "/usr/share/octave/site/m"

license: MIT

repository: demsey/openembedded

license_type: permissive

repo_name: demsey/openembedded

branch_name: HEAD

extension: bb


text:
SUMMARY = "A script to install metasploit-framework"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

SRC_URI = "file://msfinstaller.sh \
           "

RDEPENDS:${PN} = "packagegroup-core-buildessential \
                  ruby ruby-dev \
                  libxml2 libxml2-dev \
                  libxslt libxslt-dev \
                  libpq libpq-dev \
                  libpcap libpcap-dev \
                  bash curl ncurses-tools \
                  postgresql postgresql-client \
                 "

S = "${WORKDIR}"

do_install() {
    install -d ${D}${bindir}
    install -m 0755 ${S}/msfinstaller.sh ${D}${bindir}/msfinstaller.sh
}

INSANE_SKIP:${PN} += "dev-deps"

repository: blademist/meta-penetration

repo_name: blademist/meta-penetration

branch_name: refs/heads/master