aboutsummaryrefslogtreecommitdiffstats
path: root/lib/megaco/test/megaco_test_msg_v1_lib.erl
diff options
context:
space:
mode:
authorErlang/OTP <[email protected]>2009-11-20 14:54:40 +0000
committerErlang/OTP <[email protected]>2009-11-20 14:54:40 +0000
commit84adefa331c4159d432d22840663c38f155cd4c1 (patch)
treebff9a9c66adda4df2106dfd0e5c053ab182a12bd /lib/megaco/test/megaco_test_msg_v1_lib.erl
downloadotp-84adefa331c4159d432d22840663c38f155cd4c1.tar.gz
otp-84adefa331c4159d432d22840663c38f155cd4c1.tar.bz2
otp-84adefa331c4159d432d22840663c38f155cd4c1.zip
The R13B03 release.OTP_R13B03
Diffstat (limited to 'lib/megaco/test/megaco_test_msg_v1_lib.erl')
-rw-r--r--lib/megaco/test/megaco_test_msg_v1_lib.erl7024
1 files changed, 7024 insertions, 0 deletions
diff --git a/lib/megaco/test/megaco_test_msg_v1_lib.erl b/lib/megaco/test/megaco_test_msg_v1_lib.erl
new file mode 100644
index 0000000000..638215e8c1
--- /dev/null
+++ b/lib/megaco/test/megaco_test_msg_v1_lib.erl
@@ -0,0 +1,7024 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2007-2009. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+%%
+%%----------------------------------------------------------------------
+%% Purpose: Utility functions for creating the megaco types
+%% This file is originally a copy of megaco_test_msg_v2_lib.erl
+%% which is why so much of it is commented out.
+%%----------------------------------------------------------------------
+
+-module(megaco_test_msg_v1_lib).
+
+%% ----
+
+-include_lib("megaco/include/megaco_message_v1.hrl").
+-include_lib("megaco/include/megaco.hrl").
+
+%% ----
+
+-export([
+ cre_MegacoMessage/1, cre_MegacoMessage/2,
+%% cre_AuthenticationHeader/3,
+ cre_Message/3,
+%% cre_ErrorDescriptor/1, cre_ErrorDescriptor/2,
+%% cre_ErrorCode/1,
+%% cre_ErrorText/1,
+ cre_ContextID/1,
+ cre_Transaction/1,
+ cre_TransactionId/1,
+ cre_TransactionRequest/2,
+%% cre_TransactionPending/1,
+%% cre_TransactionReply/2, cre_TransactionReply/3,
+%% cre_TransactionAck/1, cre_TransactionAck/2,
+ cre_ActionRequest/2, cre_ActionRequest/3, cre_ActionRequest/4,
+%% cre_ActionReply/2, cre_ActionReply/3, cre_ActionReply/4,
+%% cre_ContextRequest/0, cre_ContextRequest/1, cre_ContextRequest/2,
+%% cre_ContextRequest/3,
+%% cre_ContextAttrAuditRequest/0, cre_ContextAttrAuditRequest/3,
+%% cre_CommandRequest/1, cre_CommandRequest/2, cre_CommandRequest/3,
+%% cre_Command/2,
+%% cre_CommandReply/2,
+%% cre_TopologyRequest/3, cre_TopologyRequest/4,
+%% cre_AmmRequest/2,
+ cre_AmmDescriptor/1,
+%% cre_AmmsReply/1, cre_AmmsReply/2,
+%% cre_SubtractRequest/1, cre_SubtractRequest/2,
+%% cre_AuditRequest/2,
+%% cre_AuditReply/1,
+%% cre_AuditResult/2,
+%% cre_AuditReturnParameter/1,
+%% cre_AuditDescriptor/0, cre_AuditDescriptor/1, cre_AuditDescriptor/2,
+%% cre_IndAuditParameter/1,
+%% cre_IndAudMediaDescriptor/0, cre_IndAudMediaDescriptor/1,
+%% cre_IndAudMediaDescriptor/2,
+%% cre_IndAudStreamDescriptor/2,
+%% cre_IndAudStreamParms/0, cre_IndAudStreamParms/1,
+%% cre_IndAudStreamParms/3,
+%% cre_IndAudLocalControlDescriptor/0,
+%% cre_IndAudLocalControlDescriptor/4,
+%% cre_IndAudPropertyParm/1,
+%% cre_IndAudLocalRemoteDescriptor/1,
+%% cre_IndAudLocalRemoteDescriptor/2,
+%% cre_IndAudPropertyGroup/1,
+%% cre_IndAudTerminationStateDescriptor/1,
+%% cre_IndAudTerminationStateDescriptor/3,
+%% cre_IndAudEventsDescriptor/1, cre_IndAudEventsDescriptor/2,
+%% cre_IndAudEventsDescriptor/3,
+%% cre_IndAudEventBufferDescriptor/1,
+%% cre_IndAudEventBufferDescriptor/2,
+%% cre_IndAudSignalsDescriptor/1,
+%% cre_IndAudSeqSigList/1,
+%% cre_IndAudSeqSigList/2,
+%% cre_IndAudSignal/1, cre_IndAudSignal/2,
+%% cre_IndAudDigitMapDescriptor/0, cre_IndAudDigitMapDescriptor/1,
+%% cre_IndAudStatisticsDescriptor/1,
+%% cre_IndAudPackagesDescriptor/2,
+%% cre_NotifyRequest/2, cre_NotifyRequest/3,
+%% cre_NotifyReply/1, cre_NotifyReply/2,
+%% cre_ObservedEventsDescriptor/2,
+%% cre_ObservedEvent/2, cre_ObservedEvent/3, cre_ObservedEvent/4,
+ cre_EventName/1,
+ cre_EventParameter/2, cre_EventParameter/4,
+%% cre_ServiceChangeRequest/2,
+%% cre_ServiceChangeReply/2,
+%% cre_ServiceChangeResult/1,
+%% %% cre_WildcardField/1,
+%% cre_TerminationID/2,
+%% cre_TerminationIDList/1,
+%% cre_MediaDescriptor/0, cre_MediaDescriptor/1, cre_MediaDescriptor/2,
+%% cre_StreamDescriptor/2,
+%% cre_StreamParms/0, cre_StreamParms/1, cre_StreamParms/2,
+%% cre_StreamParms/3,
+%% cre_LocalControlDescriptor/1, cre_LocalControlDescriptor/2,
+%% cre_LocalControlDescriptor/4,
+%% cre_StreamMode/1,
+%% cre_PropertyParm/2, cre_PropertyParm/4,
+%% cre_Name/1,
+ cre_PkgdName/1,
+ cre_PkgdName/2,
+%% cre_Relation/1,
+%% cre_LocalRemoteDescriptor/1,
+%% cre_PropertyGroup/1,
+%% cre_TerminationStateDescriptor/1,
+%% cre_TerminationStateDescriptor/2,
+%% cre_TerminationStateDescriptor/3,
+%% cre_EventBufferControl/1,
+%% cre_ServiceState/1,
+%% cre_MuxDescriptor/2, %% cre_MuxDescriptor/3,
+%% cre_MuxType/1,
+%% cre_StreamID/1,
+%% cre_EventsDescriptor/0, cre_EventsDescriptor/2,
+%% cre_RequestedEvent/1,
+%% cre_RequestedEvent/2, cre_RequestedEvent/3, cre_RequestedEvent/4,
+%% cre_RequestedActions/0,
+%% cre_RequestedActions/1, cre_RequestedActions/4,
+%% cre_EventDM/1,
+%% cre_SecondEventsDescriptor/1, cre_SecondEventsDescriptor/2,
+%% cre_SecondRequestedEvent/2, cre_SecondRequestedEvent/3,
+%% cre_SecondRequestedEvent/4,
+%% cre_SecondRequestedActions/0, cre_SecondRequestedActions/1,
+%% cre_SecondRequestedActions/2, cre_SecondRequestedActions/3,
+ cre_EventBufferDescriptor/1,
+ cre_EventSpec/2,
+ cre_EventSpec/3,
+%% cre_SignalsDescriptor/1,
+%% cre_SignalRequest/1,
+%% cre_SeqSigList/2,
+%% cre_Signal/1, cre_Signal/2, cre_Signal/7,
+%% cre_SignalType/1,
+%% cre_SignalName/1,
+%% cre_NotifyCompletion/1,
+%% cre_SigParameter/2, cre_SigParameter/4,
+%% cre_RequestID/1,
+%% cre_ModemDescriptor/2, %% cre_ModemDescriptor/3,
+%% cre_ModemType/1,
+%% cre_DigitMapDescriptor/0, cre_DigitMapDescriptor/1,
+%% cre_DigitMapDescriptor/2,
+%% cre_DigitMapName/1,
+%% cre_DigitMapValue/1, cre_DigitMapValue/4, cre_DigitMapValue/5,
+%% cre_ServiceChangeParm/2, cre_ServiceChangeParm/4,
+%% cre_ServiceChangeParm/9,
+%% cre_ServiceChangeAddress/2,
+%% cre_ServiceChangeResParm/0, cre_ServiceChangeResParm/2,
+%% cre_ServiceChangeResParm/5,
+%% cre_ServiceChangeMethod/1,
+%% cre_ServiceChangeProfile/1, cre_ServiceChangeProfile/2,
+%% cre_PackagesDescriptor/1,
+%% cre_PackagesItem/2,
+%% cre_StatisticsDescriptor/1,
+%% cre_StatisticsParameter/1, cre_StatisticsParameter/2,
+%% %% cre_NonStandardData/2,
+%% %% cre_NonStandardIdentifier/1,
+%% %% cre_H221NonStandard/4,
+%% cre_TimeNotation/2,
+%% cre_Value/1,
+ cre_BOOLEAN/1
+ ]).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+cre_MegacoMessage(M) when is_record(M, 'Message') ->
+ #'MegacoMessage'{mess = M}.
+
+cre_MegacoMessage(AH, M)
+ when is_record(AH, 'AuthenticationHeader') andalso
+ is_record(M, 'Message') ->
+ #'MegacoMessage'{authHeader = AH,
+ mess = M}.
+
+%% cre_AuthenticationHeader(SPI, SN, AD) ->
+%% #'AuthenticationHeader'{secParmIndex = SPI,
+%% seqNum = SN,
+%% ad = AD}.
+
+cre_Message(V, Mid, ED) when is_record(ED, 'ErrorDescriptor') ->
+ Body = {errorDescriptor, ED},
+ #'Message'{version = V,
+ mId = Mid,
+ messageBody = Body};
+cre_Message(V, Mid, Transactions) when is_list(Transactions) ->
+ Body = {transactions, Transactions},
+ #'Message'{version = V,
+ mId = Mid,
+ messageBody = Body};
+cre_Message(V, Mid, {transactions, T} = Body) when is_list(T) ->
+ #'Message'{version = V,
+ mId = Mid,
+ messageBody = Body};
+cre_Message(V, Mid, {errorDescriptor, ED} = Body)
+ when is_record(ED, 'ErrorDescriptor') ->
+ #'Message'{version = V,
+ mId = Mid,
+ messageBody = Body}.
+
+
+%% cre_ErrorDescriptor(EC) when integer(EC) ->
+%% #'ErrorDescriptor'{errorCode = EC}.
+
+%% cre_ErrorDescriptor(EC, ET) when integer(EC), list(ET) ->
+%% #'ErrorDescriptor'{errorCode = EC, errorText = ET}.
+
+%% cre_ErrorCode(C) when integer(C), 0 =< C, C =< 65535 ->
+%% C;
+%% cre_ErrorCode(C) ->
+%% exit({invalid_ErrorCode, C}).
+
+%% cre_ErrorText(T) when list(T) ->
+%% T.
+
+cre_ContextID(Val) when (0 =< Val) and (Val =< 4294967295) ->
+ Val;
+cre_ContextID(Val) ->
+ exit({invalid_ContextID, Val}).
+
+cre_Transaction(TR) when is_record(TR, 'TransactionRequest') ->
+ {transactionRequest, TR};
+cre_Transaction(TP) when is_record(TP, 'TransactionPending') ->
+ {transactionPending, TP};
+cre_Transaction(TR) when is_record(TR, 'TransactionReply') ->
+ {transactionReply, TR};
+cre_Transaction(TRA) when is_list(TRA) ->
+ {transactionResponseAck, TRA}.
+
+cre_TransactionId(Val) when (0 =< Val) andalso (Val =< 4294967295) ->
+ Val;
+cre_TransactionId(Val) ->
+ exit({invalid_TransactionId, Val}).
+
+cre_TransactionRequest(TransID, ARs) when is_integer(TransID) andalso is_list(ARs) ->
+ #'TransactionRequest'{transactionId = TransID,
+ actions = ARs}.
+
+%% cre_TransactionPending(TransID) when integer(TransID) ->
+%% #'TransactionPending'{transactionId = TransID}.
+
+%% cre_TransactionReply(TransID, ED)
+%% when integer(TransID), record(ED, 'ErrorDescriptor') ->
+%% Res = {transactionError, ED},
+%% #'TransactionReply'{transactionId = TransID,
+%% transactionResult = Res};
+%% cre_TransactionReply(TransID, ARs)
+%% when integer(TransID), list(ARs) ->
+%% Res = {actionReplies, ARs},
+%% #'TransactionReply'{transactionId = TransID,
+%% transactionResult = Res}.
+
+%% cre_TransactionReply(TransID, IAR, ED)
+%% when is_integer(TransID) and
+%% ((IAR == 'NULL') or (IAR == asn1_NOVALUE)) and
+%% is_record(ED, 'ErrorDescriptor') ->
+%% Res = {transactionError, ED},
+%% #'TransactionReply'{transactionId = TransID,
+%% transactionResult = Res};
+%% cre_TransactionReply(TransID, IAR, ARs)
+%% when is_integer(TransID) and
+%% ((IAR == 'NULL') or (IAR == asn1_NOVALUE)) and
+%% is_list(ARs) ->
+%% Res = {actionReplies, ARs},
+%% #'TransactionReply'{transactionId = TransID,
+%% transactionResult = Res}.
+
+%% cre_TransactionAck(FirstAck) ->
+%% #'TransactionAck'{firstAck = FirstAck}.
+
+%% cre_TransactionAck(FirstAck, FirstAck) ->
+%% #'TransactionAck'{firstAck = FirstAck};
+%% cre_TransactionAck(FirstAck, LastAck) ->
+%% #'TransactionAck'{firstAck = FirstAck,
+%% lastAck = LastAck}.
+
+cre_ActionRequest(CtxID, CmdReqs)
+ when is_integer(CtxID) and is_list(CmdReqs) ->
+ #'ActionRequest'{contextId = CtxID,
+ commandRequests = CmdReqs}.
+
+cre_ActionRequest(CtxID, CtxReq, CmdReqs)
+ when is_integer(CtxID) and
+ is_record(CtxReq, 'ContextRequest') and
+ is_list(CmdReqs) ->
+ #'ActionRequest'{contextId = CtxID,
+ contextRequest = CtxReq,
+ commandRequests = CmdReqs};
+cre_ActionRequest(CtxID, CAAR, CmdReqs)
+ when is_integer(CtxID) and
+ is_record(CAAR, 'ContextAttrAuditRequest') and
+ is_list(CmdReqs) ->
+ #'ActionRequest'{contextId = CtxID,
+ contextAttrAuditReq = CAAR,
+ commandRequests = CmdReqs}.
+
+cre_ActionRequest(CtxID, CtxReq, CAAR, CmdReqs)
+ when is_integer(CtxID) and
+ is_record(CtxReq, 'ContextRequest') and
+ is_record(CAAR, 'ContextAttrAuditRequest') and
+ is_list(CmdReqs) ->
+ #'ActionRequest'{contextId = CtxID,
+ contextRequest = CtxReq,
+ contextAttrAuditReq = CAAR,
+ commandRequests = CmdReqs}.
+
+%% cre_ActionReply(CtxID, CmdReps)
+%% when integer(CtxID),
+%% list(CmdReps) ->
+%% #'ActionReply'{contextId = CtxID,
+%% commandReply = CmdReps}.
+
+%% cre_ActionReply(CtxID, ED, CmdReps)
+%% when integer(CtxID),
+%% record(ED, 'ErrorDescriptor'),
+%% list(CmdReps) ->
+%% #'ActionReply'{contextId = CtxID,
+%% errorDescriptor = ED,
+%% commandReply = CmdReps};
+%% cre_ActionReply(CtxID, CtxReq, CmdReps)
+%% when integer(CtxID),
+%% record(CtxReq, 'ContextRequest'),
+%% list(CmdReps) ->
+%% #'ActionReply'{contextId = CtxID,
+%% contextReply = CtxReq,
+%% commandReply = CmdReps}.
+
+%% cre_ActionReply(CtxID, ED, CtxReq, CmdReps)
+%% when integer(CtxID),
+%% record(ED, 'ErrorDescriptor'),
+%% record(CtxReq, 'ContextRequest'),
+%% list(CmdReps) ->
+%% #'ActionReply'{contextId = CtxID,
+%% errorDescriptor = ED,
+%% contextReply = CtxReq,
+%% commandReply = CmdReps}.
+
+%% cre_ContextRequest() ->
+%% #'ContextRequest'{}.
+
+%% cre_ContextRequest(Prio) when integer(Prio), 0 =< Prio, Prio =< 15 ->
+%% #'ContextRequest'{priority = Prio};
+%% cre_ContextRequest(Em) when Em == true; Em == false; Em == asn1_NOVALUE ->
+%% #'ContextRequest'{emergency = Em};
+%% cre_ContextRequest(Top) when list(Top) ->
+%% #'ContextRequest'{topologyReq = Top}.
+
+%% cre_ContextRequest(Prio, Em)
+%% when (is_integer(Prio) and (0 =< Prio) and (Prio =< 15)) and
+%% ((Em == true) or (Em == false) or (Em == asn1_NOVALUE)) ->
+%% #'ContextRequest'{priority = Prio,
+%% emergency = Em};
+%% cre_ContextRequest(Prio, Top)
+%% when integer(Prio), 0 =< Prio, Prio =< 15, list(Top) ->
+%% #'ContextRequest'{priority = Prio,
+%% topologyReq = Top}.
+
+%% cre_ContextRequest(Prio, Em, Top)
+%% when (is_integer(Prio) and (0 =< Prio) and (Prio =< 15)) and
+%% ((Em == true) or (Em == false) or (Em == asn1_NOVALUE)) and
+%% is_list(Top) ->
+%% #'ContextRequest'{priority = Prio,
+%% emergency = Em,
+%% topologyReq = Top}.
+
+%% cre_ContextAttrAuditRequest() ->
+%% #'ContextAttrAuditRequest'{}.
+
+%% cre_ContextAttrAuditRequest(Top, Em, Prio)
+%% when ((Top == 'NULL') or (Top == asn1_NOVALUE)) and
+%% ((Em == 'NULL') or (Em == asn1_NOVALUE)) and
+%% ((Prio == 'NULL') or (Prio == asn1_NOVALUE)) ->
+%% #'ContextAttrAuditRequest'{topology = Top,
+%% emergency = Em,
+%% priority = Prio}.
+
+%% cre_CommandRequest(Cmd) ->
+%% #'CommandRequest'{command = Cmd}.
+
+%% cre_CommandRequest(Cmd, Opt)
+%% when ((Opt == 'NULL') or (Opt == asn1_NOVALUE)) ->
+%% #'CommandRequest'{command = Cmd,
+%% optional = Opt}.
+
+%% cre_CommandRequest(Cmd, Opt, WR)
+%% when ((Opt == 'NULL') or (Opt == asn1_NOVALUE)) and
+%% ((WR == 'NULL') or (WR == asn1_NOVALUE)) ->
+%% #'CommandRequest'{command = Cmd,
+%% optional = Opt,
+%% wildcardReturn = WR}.
+
+%% cre_Command(addReq = Tag, Req)
+%% when record(Req, 'AmmRequest') ->
+%% {Tag, Req};
+%% cre_Command(moveReq = Tag, Req)
+%% when record(Req, 'AmmRequest') ->
+%% {Tag, Req};
+%% cre_Command(modReq = Tag, Req)
+%% when record(Req, 'AmmRequest') ->
+%% {Tag, Req};
+%% cre_Command(subtractReq = Tag, Req)
+%% when record(Req, 'SubtractRequest') ->
+%% {Tag, Req};
+%% cre_Command(auditCapRequest = Tag, Req)
+%% when record(Req, 'AuditRequest') ->
+%% {Tag, Req};
+%% cre_Command(auditValueRequest = Tag, Req)
+%% when record(Req, 'AuditRequest') ->
+%% {Tag, Req};
+%% cre_Command(notifyReq = Tag, Req)
+%% when record(Req, 'NotifyRequest') ->
+%% {Tag, Req};
+%% cre_Command(serviceChangeReq = Tag, Req)
+%% when record(Req, 'ServiceChangeRequest') ->
+%% {Tag, Req}.
+
+%% cre_CommandReply(addReply = Tag, Rep)
+%% when record(Rep, 'AmmsReply') ->
+%% {Tag, Rep};
+%% cre_CommandReply(moveReply = Tag, Rep)
+%% when record(Rep, 'AmmsReply') ->
+%% {Tag, Rep};
+%% cre_CommandReply(modReply = Tag, Rep)
+%% when record(Rep, 'AmmsReply') ->
+%% {Tag, Rep};
+%% cre_CommandReply(subtractReply = Tag, Rep)
+%% when record(Rep, 'AmmsReply') ->
+%% {Tag, Rep};
+%% cre_CommandReply(auditCapReply = Tag, Rep)
+%% when tuple(Rep) ->
+%% {Tag, Rep};
+%% cre_CommandReply(auditValueReply = Tag, Rep)
+%% when tuple(Rep) ->
+%% {Tag, Rep};
+%% cre_CommandReply(notifyReply = Tag, Rep)
+%% when record(Rep, 'NotifyReply') ->
+%% {Tag, Rep};
+%% cre_CommandReply(serviceChangeReply = Tag, Rep)
+%% when record(Rep, 'ServiceChangeReply') ->
+%% {Tag, Rep}.
+
+%% cre_TopologyRequest(From, To, Dir)
+%% when is_record(From, 'TerminationID') and
+%% is_record(To, 'TerminationID') and
+%% ((Dir == bothway) or (Dir == isolate) or (Dir == oneway)) ->
+%% #'TopologyRequest'{terminationFrom = From,
+%% terminationTo = To,
+%% topologyDirection = Dir}.
+
+%% cre_TopologyRequest(From, To, Dir, SID)
+%% when is_record(From, 'TerminationID') and
+%% is_record(To, 'TerminationID') and
+%% ((Dir == bothway) or (Dir == isolate) or (Dir == oneway)) and
+%% (is_integer(SID) or (SID == asn1_NOVALUE)) ->
+%% #'TopologyRequest'{terminationFrom = From,
+%% terminationTo = To,
+%% topologyDirection = Dir,
+%% streamID = SID}.
+
+%% cre_AmmRequest(TermIDs, Descs) when list(TermIDs), list(Descs) ->
+%% #'AmmRequest'{terminationID = TermIDs,
+%% descriptors = Descs}.
+
+cre_AmmDescriptor(D) when is_record(D, 'MediaDescriptor') ->
+ {mediaDescriptor, D};
+cre_AmmDescriptor(D) when is_record(D, 'ModemDescriptor') ->
+ {modemDescriptor, D};
+cre_AmmDescriptor(D) when is_record(D, 'MuxDescriptor') ->
+ {muxDescriptor, D};
+cre_AmmDescriptor(D) when is_record(D, 'EventsDescriptor') ->
+ {eventsDescriptor, D};
+cre_AmmDescriptor(D) when is_record(D, 'DigitMapDescriptor') ->
+ {digitMapDescriptor, D};
+cre_AmmDescriptor(D) when is_record(D, 'AuditDescriptor') ->
+ {auditDescriptor, D};
+cre_AmmDescriptor(D) when is_list(D) ->
+ case is_EventBufferDescriptor(D) of
+ true ->
+ {eventBufferDescriptor, D};
+ false ->
+ case is_SignalsDescriptor(D) of
+ true ->
+ {signalsDescriptor, D};
+ false ->
+ error({invalid_AmmDescriptor, D})
+ end
+ end.
+
+%% cre_AmmsReply(TermIDs) when list(TermIDs) ->
+%% #'AmmsReply'{terminationID = TermIDs}.
+
+%% cre_AmmsReply(TermIDs, TAs) when list(TermIDs), list(TAs) ->
+%% #'AmmsReply'{terminationID = TermIDs,
+%% terminationAudit = TAs}.
+
+%% cre_SubtractRequest(TermIDs) when list(TermIDs) ->
+%% #'SubtractRequest'{terminationID = TermIDs}.
+
+%% cre_SubtractRequest(TermIDs, Audit)
+%% when list(TermIDs), record(Audit, 'AuditDescriptor') ->
+%% #'SubtractRequest'{terminationID = TermIDs,
+%% auditDescriptor = Audit}.
+
+%% cre_AuditRequest(TermID, Audit)
+%% when record(TermID, megaco_term_id), record(Audit, 'AuditDescriptor') ->
+%% #'AuditRequest'{terminationID = TermID,
+%% auditDescriptor = Audit}.
+
+%% cre_AuditReply(TermIDs) when list(TermIDs) ->
+%% {contextAuditResult, TermIDs};
+%% cre_AuditReply(ED) when record(ED, 'ErrorDescriptor') ->
+%% {error, ED};
+%% cre_AuditReply(Audit) when record(Audit, 'AuditResult') ->
+%% {auditResult, Audit}.
+
+%% cre_AuditResult(TermID, TAs)
+%% when record(TermID, megaco_term_id), list(TAs) ->
+%% #'AuditResult'{terminationID = TermID,
+%% terminationAuditResult = TAs}.
+
+%% cre_AuditReturnParameter(D) when record(D, 'ErrorDescriptor') ->
+%% {errorDescriptor, D};
+%% cre_AuditReturnParameter(D) when record(D, 'MediaDescriptor') ->
+%% {mediaDescriptor, D};
+%% cre_AuditReturnParameter(D) when record(D, 'ModemDescriptor') ->
+%% {modemDescriptor, D};
+%% cre_AuditReturnParameter(D) when record(D, 'MuxDescriptor') ->
+%% {muxDescriptor, D};
+%% cre_AuditReturnParameter(D) when record(D, 'EventsDescriptor') ->
+%% {eventsDescriptor, D};
+%% cre_AuditReturnParameter([H|_] = D) when record(H, 'EventSpec') ->
+%% {eventBufferDescriptor, D};
+%% cre_AuditReturnParameter(D) when record(D, 'DigitMapDescriptor') ->
+%% {digitMapDescriptor, D};
+%% cre_AuditReturnParameter(D) when record(D, 'ObservedEventsDescriptor') ->
+%% {observedEventsDescriptor, D};
+%% cre_AuditReturnParameter([H|_] = D) when record(H, 'StatisticsParameter') ->
+%% {statisticsDescriptor, D};
+%% cre_AuditReturnParameter([H|_] = D) when record(H, 'PackagesItem') ->
+%% {packagesDescriptor, D};
+%% cre_AuditReturnParameter(D) when record(D, 'AuditDescriptor') ->
+%% {emptyDescriptors, D};
+%% cre_AuditReturnParameter([H|_] = D) when tuple(H) ->
+%% {signalsDescriptor, D}.
+
+%% cre_AuditDescriptor() ->
+%% #'AuditDescriptor'{}.
+
+%% cre_AuditDescriptor([H|_] = AT) when atom(H) ->
+%% #'AuditDescriptor'{auditToken = AT};
+%% cre_AuditDescriptor(APT) ->
+%% #'AuditDescriptor'{auditPropertyToken = APT}.
+
+%% cre_AuditDescriptor(AT, APT) ->
+%% #'AuditDescriptor'{auditToken = AT,
+%% auditPropertyToken = APT}.
+
+%% cre_IndAuditParameter(D) when record(D, 'IndAudMediaDescriptor') ->
+%% {indAudMediaDescriptor, D};
+%% cre_IndAuditParameter(D) when record(D, 'IndAudEventsDescriptor') ->
+%% {indAudEventsDescriptor, D};
+%% cre_IndAuditParameter(D) when record(D, 'IndAudEventBufferDescriptor') ->
+%% {indAudEventBufferDescriptor, D};
+%% cre_IndAuditParameter({signal, _} = D) ->
+%% {indAudSignalsDescriptor, D};
+%% cre_IndAuditParameter({seqSigList, _} = D) ->
+%% {indAudSignalsDescriptor, D};
+%% cre_IndAuditParameter(D) when record(D, 'IndAudDigitMapDescriptor') ->
+%% {indAudDigitMapDescriptor, D};
+%% cre_IndAuditParameter(D) when record(D, 'IndAudStatisticsDescriptor') ->
+%% {indAudStatisticsDescriptor, D};
+%% cre_IndAuditParameter(D) when record(D, 'IndAudPackagesDescriptor') ->
+%% {indAudPackagesDescriptor, D}.
+
+%% cre_IndAudMediaDescriptor() ->
+%% #'IndAudMediaDescriptor'{}.
+
+%% cre_IndAudMediaDescriptor(TSD)
+%% when record(TSD, 'IndAudTerminationStateDescriptor') ->
+%% #'IndAudMediaDescriptor'{termStateDescr = TSD};
+%% cre_IndAudMediaDescriptor(Parms) when record(Parms, 'IndAudStreamParms') ->
+%% Streams = {oneStream, Parms},
+%% #'IndAudMediaDescriptor'{streams = Streams};
+%% cre_IndAudMediaDescriptor(Descs) when list(Descs) ->
+%% Streams = {multiStream, Descs},
+%% #'IndAudMediaDescriptor'{streams = Streams}.
+
+%% cre_IndAudMediaDescriptor(TSD, Parms)
+%% when record(TSD, 'IndAudTerminationStateDescriptor'),
+%% record(Parms, 'IndAudStreamParms') ->
+%% Streams = {oneStream, Parms},
+%% #'IndAudMediaDescriptor'{termStateDescr = TSD,
+%% streams = Streams};
+%% cre_IndAudMediaDescriptor(TSD, Descs)
+%% when record(TSD, 'IndAudTerminationStateDescriptor'), list(Descs) ->
+%% Streams = {multiStream, Descs},
+%% #'IndAudMediaDescriptor'{termStateDescr = TSD,
+%% streams = Streams}.
+
+%% cre_IndAudStreamDescriptor(SID, Parms)
+%% when integer(SID), record(Parms, 'IndAudStreamParms') ->
+%% #'IndAudStreamDescriptor'{streamID = SID,
+%% streamParms = Parms}.
+
+%% cre_IndAudStreamParms() ->
+%% #'IndAudStreamParms'{}.
+
+%% cre_IndAudStreamParms(LCD) when record(LCD, 'IndAudLocalControlDescriptor') ->
+%% #'IndAudStreamParms'{localControlDescriptor = LCD}.
+
+%% cre_IndAudStreamParms(LCD, L, R)
+%% when record(LCD, 'IndAudLocalControlDescriptor'),
+%% record(L, 'IndAudLocalRemoteDescriptor'),
+%% record(R, 'IndAudLocalRemoteDescriptor') ->
+%% #'IndAudStreamParms'{localControlDescriptor = LCD,
+%% localDescriptor = L,
+%% remoteDescriptor = R}.
+
+%% cre_IndAudLocalControlDescriptor() ->
+%% #'IndAudLocalControlDescriptor'{}.
+
+%% cre_IndAudLocalControlDescriptor(SM, RV, RG, PP)
+%% when ((SM == 'NULL') or (SM == asn1_NOVALUE)) and
+%% ((RV == 'NULL') or (RV == asn1_NOVALUE)) and
+%% ((RG == 'NULL') or (RG == asn1_NOVALUE)) and
+%% (is_list(PP) or (PP == asn1_NOVALUE)) ->
+%% #'IndAudLocalControlDescriptor'{streamMode = SM,
+%% reserveValue = RV,
+%% reserveGroup = RG,
+%% propertyParms = PP}.
+
+%% cre_IndAudPropertyParm(PkgdName) when list(PkgdName) ->
+%% #'IndAudPropertyParm'{name = PkgdName}.
+
+%% cre_IndAudLocalRemoteDescriptor(Grps)
+%% when list(Grps) ->
+%% #'IndAudLocalRemoteDescriptor'{propGrps = Grps}.
+
+%% cre_IndAudLocalRemoteDescriptor(GrpID, Grps)
+%% when integer(GrpID), 0 =< GrpID, GrpID =< 65535, list(Grps) ->
+%% #'IndAudLocalRemoteDescriptor'{propGroupID = GrpID,
+%% propGrps = Grps}.
+
+%% cre_IndAudPropertyGroup([]) ->
+%% [];
+%% cre_IndAudPropertyGroup([H|_] = PG)
+%% when record(H, 'IndAudPropertyParm') ->
+%% PG.
+
+%% cre_IndAudTerminationStateDescriptor([] = PP) ->
+%% #'IndAudTerminationStateDescriptor'{propertyParms = PP};
+%% cre_IndAudTerminationStateDescriptor([H|_] = PP)
+%% when record(H, 'IndAudPropertyParm') ->
+%% #'IndAudTerminationStateDescriptor'{propertyParms = PP}.
+
+%% cre_IndAudTerminationStateDescriptor([] = PP, EBC, SS)
+%% when ((EBC == 'NULL') or (EBC == asn1_NOVALUE)) and
+%% ((SS == 'NULL') or (SS == asn1_NOVALUE)) ->
+%% #'IndAudTerminationStateDescriptor'{propertyParms = PP,
+%% eventBufferControl = EBC,
+%% serviceState = SS};
+%% cre_IndAudTerminationStateDescriptor([H|_] = PP, EBC, SS)
+%% when is_record(H, 'IndAudPropertyParm') and
+%% ((EBC == 'NULL') or (EBC == asn1_NOVALUE)) and
+%% ((SS == 'NULL') or (SS == asn1_NOVALUE)) ->
+%% #'IndAudTerminationStateDescriptor'{propertyParms = PP,
+%% eventBufferControl = EBC,
+%% serviceState = SS}.
+
+%% cre_IndAudEventsDescriptor(PkgdName)
+%% when list(PkgdName) ->
+%% #'IndAudEventsDescriptor'{pkgdName = PkgdName}.
+
+%% cre_IndAudEventsDescriptor(RID, PkgdName)
+%% when integer(RID), list(PkgdName) ->
+%% #'IndAudEventsDescriptor'{requestID = RID, pkgdName = PkgdName};
+%% cre_IndAudEventsDescriptor(PkgdName, SID)
+%% when list(PkgdName), integer(SID) ->
+%% #'IndAudEventsDescriptor'{pkgdName = PkgdName, streamID = SID}.
+
+%% cre_IndAudEventsDescriptor(RID, PkgdName, SID)
+%% when integer(RID), list(PkgdName), integer(SID) ->
+%% #'IndAudEventsDescriptor'{requestID = RID,
+%% pkgdName = PkgdName,
+%% streamID = SID}.
+
+%% cre_IndAudEventBufferDescriptor(EventName) when list(EventName) ->
+%% #'IndAudEventBufferDescriptor'{eventName = EventName}.
+
+%% cre_IndAudEventBufferDescriptor(EventName, SID)
+%% when list(EventName), integer(SID) ->
+%% #'IndAudEventBufferDescriptor'{eventName = EventName, streamID = SID}.
+
+%% cre_IndAudSignalsDescriptor(S) when record(S, 'IndAudSignal') ->
+%% {signal, S};
+%% cre_IndAudSignalsDescriptor(S) when record(S, 'IndAudSeqSigList') ->
+%% {seqSigList, S}.
+
+%% cre_IndAudSeqSigList(ID) when integer(ID), 0=< ID, ID =< 65535 ->
+%% #'IndAudSeqSigList'{id = ID}.
+
+%% cre_IndAudSeqSigList(ID, S)
+%% when integer(ID), 0=< ID, ID =< 65535,
+%% record(S, 'IndAudSignal') ->
+%% #'IndAudSeqSigList'{id = ID, signalList = S}.
+
+%% cre_IndAudSignal(SigName) when list(SigName) ->
+%% #'IndAudSignal'{signalName = SigName}.
+
+%% cre_IndAudSignal(SigName, SID) when list(SigName), integer(SID) ->
+%% #'IndAudSignal'{signalName = SigName, streamID = SID}.
+
+%% cre_IndAudDigitMapDescriptor() ->
+%% #'IndAudDigitMapDescriptor'{}.
+
+%% cre_IndAudDigitMapDescriptor(DMN) when list(DMN) ->
+%% #'IndAudDigitMapDescriptor'{digitMapName = DMN}.
+
+%% cre_IndAudStatisticsDescriptor(StatName) when list(StatName) ->
+%% #'IndAudStatisticsDescriptor'{statName = StatName}.
+
+%% cre_IndAudPackagesDescriptor(N, V)
+%% when list(N),
+%% integer(V), 0 =< V, V =< 99 ->
+%% #'IndAudPackagesDescriptor'{packageName = N,
+%% packageVersion = V}.
+
+%% cre_NotifyRequest(TermIDs, D)
+%% when list(TermIDs), record(D, 'ObservedEventsDescriptor') ->
+%% #'NotifyRequest'{terminationID = TermIDs,
+%% observedEventsDescriptor = D}.
+
+%% cre_NotifyRequest(TermIDs, D, ED)
+%% when list(TermIDs),
+%% record(D, 'ObservedEventsDescriptor'),
+%% record(ED, 'ErrorDescriptor') ->
+%% #'NotifyRequest'{terminationID = TermIDs,
+%% observedEventsDescriptor = D,
+%% errorDescriptor = ED}.
+
+%% cre_NotifyReply(TermIDs) when list(TermIDs) ->
+%% #'NotifyReply'{terminationID = TermIDs}.
+
+%% cre_NotifyReply(TermIDs, ED)
+%% when list(TermIDs),
+%% record(ED, 'ErrorDescriptor') ->
+%% #'NotifyReply'{terminationID = TermIDs,
+%% errorDescriptor = ED}.
+
+%% cre_ObservedEventsDescriptor(RID, [H|_] = L)
+%% when integer(RID), record(H, 'ObservedEvent') ->
+%% #'ObservedEventsDescriptor'{requestId = RID,
+%% observedEventLst = L}.
+
+%% cre_ObservedEvent(EN, EPL) when list(EN), list(EPL) ->
+%% #'ObservedEvent'{eventName = EN,
+%% eventParList = EPL};
+%% cre_ObservedEvent(EN, TN) when list(EN), record(TN, 'TimeNotation') ->
+%% #'ObservedEvent'{eventName = EN,
+%% timeNotation = TN}.
+
+%% cre_ObservedEvent(EN, SID, EPL) when list(EN), integer(SID), list(EPL) ->
+%% #'ObservedEvent'{eventName = EN,
+%% streamID = SID,
+%% eventParList = EPL};
+%% cre_ObservedEvent(EN, EPL, TN)
+%% when list(EN), list(EPL), record(TN, 'TimeNotation') ->
+%% #'ObservedEvent'{eventName = EN,
+%% eventParList = EPL,
+%% timeNotation = TN}.
+
+%% cre_ObservedEvent(EN, SID, EPL, TN)
+%% when list(EN), integer(SID), list(EPL), record(TN, 'TimeNotation') ->
+%% #'ObservedEvent'{eventName = EN,
+%% streamID = SID,
+%% eventParList = EPL,
+%% timeNotation = TN}.
+
+cre_EventName(N) when is_list(N) ->
+ N.
+
+cre_EventParameter(N, V) when is_list(N) andalso is_list(V) ->
+ #'EventParameter'{eventParameterName = N,
+ value = V}.
+
+cre_EventParameter(N, V, relation = Tag, R)
+ when is_list(N) andalso is_list(V) andalso is_atom(R) ->
+ EI = {Tag, R},
+ #'EventParameter'{eventParameterName = N,
+ value = V,
+ extraInfo = EI};
+cre_EventParameter(N, V, range = Tag, B)
+ when is_list(N) andalso is_list(V) andalso is_atom(B) ->
+ EI = {Tag, B},
+ #'EventParameter'{eventParameterName = N,
+ value = V,
+ extraInfo = EI};
+cre_EventParameter(N, V, sublist = Tag, B)
+ when is_list(N) andalso is_list(V) andalso is_atom(B) ->
+ EI = {Tag, B},
+ #'EventParameter'{eventParameterName = N,
+ value = V,
+ extraInfo = EI}.
+
+%% cre_ServiceChangeRequest(TermIDs, SCP)
+%% when list(TermIDs),
+%% record(SCP, 'ServiceChangeParm') ->
+%% #'ServiceChangeRequest'{terminationID = TermIDs,
+%% serviceChangeParms = SCP}.
+
+%% cre_ServiceChangeReply(TermIDs, {Tag, R} = SCR)
+%% when list(TermIDs), atom(Tag), tuple(R) ->
+%% #'ServiceChangeReply'{terminationID = TermIDs,
+%% serviceChangeResult = SCR}.
+
+%% cre_ServiceChangeResult(ED) when record(ED, 'ErrorDescriptor') ->
+%% {errorDescriptor, ED};
+%% cre_ServiceChangeResult(SCRP) when record(SCRP, 'ServiceChangeResParm') ->
+%% {serviceChangeResParms, SCRP}.
+
+%% %% cre_WildcardField(L) when list(L), length(L) == 1 -> L.
+
+%% cre_TerminationID(W, ID)
+%% when list(W),
+%% list(ID), 1 =< length(ID), length(ID) =< 8 ->
+%% #'TerminationID'{wildcard = W,
+%% id = ID}.
+
+%% cre_TerminationIDList(L) when list(L) ->
+%% L.
+
+%% cre_MediaDescriptor() ->
+%% #'MediaDescriptor'{}.
+
+%% cre_MediaDescriptor(TSD) when record(TSD, 'TerminationStateDescriptor') ->
+%% #'MediaDescriptor'{termStateDescr = TSD};
+%% cre_MediaDescriptor(SP) when record(SP, 'StreamParms') ->
+%% Streams = {oneStream, SP},
+%% #'MediaDescriptor'{streams = Streams};
+%% cre_MediaDescriptor([H|_] = SDs) when record(H, 'StreamDescriptor') ->
+%% Streams = {multiStream, SDs},
+%% #'MediaDescriptor'{streams = Streams}.
+
+%% cre_MediaDescriptor(TSD, SP)
+%% when record(TSD, 'TerminationStateDescriptor'),
+%% record(SP, 'StreamParms') ->
+%% Streams = {oneStream, SP},
+%% #'MediaDescriptor'{termStateDescr = TSD,
+%% streams = Streams};
+%% cre_MediaDescriptor(TSD, [H|_] = SDs)
+%% when record(TSD, 'TerminationStateDescriptor'),
+%% record(H, 'StreamDescriptor') ->
+%% Streams = {multiStream, SDs},
+%% #'MediaDescriptor'{termStateDescr = TSD,
+%% streams = Streams}.
+
+%% cre_StreamDescriptor(SID, SP) when integer(SID), record(SP, 'StreamParms') ->
+%% #'StreamDescriptor'{streamID = SID,
+%% streamParms = SP}.
+
+%% cre_StreamParms() ->
+%% #'StreamParms'{}.
+
+%% cre_StreamParms(LCD) when record(LCD, 'LocalControlDescriptor') ->
+%% #'StreamParms'{localControlDescriptor = LCD};
+%% cre_StreamParms(LD) when record(LD, 'LocalRemoteDescriptor') ->
+%% #'StreamParms'{localDescriptor = LD}.
+
+%% cre_StreamParms(LCD, LD)
+%% when (is_record(LCD, 'LocalControlDescriptor') or (LCD == asn1_NOVALUE)) and
+%% (is_record(LD, 'LocalRemoteDescriptor') or (LD == asn1_NOVALUE)) ->
+%% #'StreamParms'{localControlDescriptor = LCD,
+%% localDescriptor = LD}.
+
+%% cre_StreamParms(LCD, LD, RD)
+%% when (is_record(LCD, 'LocalControlDescriptor') or (LCD == asn1_NOVALUE)) and
+%% (is_record(LD, 'LocalRemoteDescriptor') or (LD == asn1_NOVALUE)) and
+%% (is_record(RD, 'LocalRemoteDescriptor') or (RD == asn1_NOVALUE)) ->
+%% #'StreamParms'{localControlDescriptor = LCD,
+%% localDescriptor = LD,
+%% remoteDescriptor = RD}.
+
+%% cre_LocalControlDescriptor(SM) when atom(SM) ->
+%% #'LocalControlDescriptor'{streamMode = SM, propertyParms = []};
+%% cre_LocalControlDescriptor([H|_] = PP) when record(H, 'PropertyParm') ->
+%% #'LocalControlDescriptor'{propertyParms = PP}.
+
+%% cre_LocalControlDescriptor(SM, [H|_] = PP)
+%% when atom(SM), record(H, 'PropertyParm') ->
+%% #'LocalControlDescriptor'{streamMode = SM,
+%% propertyParms = PP}.
+
+%% cre_LocalControlDescriptor(SM, RV, RG, [H|_] = PP)
+%% when is_atom(SM) and
+%% ((RV == true) or (RV == false) or (RV == asn1_NOVALUE)) and
+%% ((RG == true) or (RG == false) or (RG == asn1_NOVALUE)) and
+%% is_record(H, 'PropertyParm') ->
+%% #'LocalControlDescriptor'{streamMode = SM,
+%% reserveValue = RV,
+%% reserveGroup = RG,
+%% propertyParms = PP}.
+
+%% cre_StreamMode(sendOnly = M) ->
+%% M;
+%% cre_StreamMode(recvOnly = M) ->
+%% M;
+%% cre_StreamMode(sendRecv = M) ->
+%% M;
+%% cre_StreamMode(inactive = M) ->
+%% M;
+%% cre_StreamMode(loopBack = M) ->
+%% M.
+
+%% cre_PropertyParm(N, [H|_] = V) when list(N), list(H) ->
+%% #'PropertyParm'{name = N, value = V}.
+
+%% cre_PropertyParm(N, [H|_] = V, relation = Tag, R)
+%% when list(N), list(H), atom(R) ->
+%% EI = {Tag, R},
+%% #'PropertyParm'{name = N, value = V, extraInfo = EI};
+%% cre_PropertyParm(N, [H|_] = V, range = Tag, B)
+%% when list(N), list(H), atom(B) ->
+%% EI = {Tag, B},
+%% #'PropertyParm'{name = N, value = V, extraInfo = EI};
+%% cre_PropertyParm(N, [H|_] = V, sublist = Tag, B)
+%% when list(N), list(H), atom(B) ->
+%% EI = {Tag, B},
+%% #'PropertyParm'{name = N, value = V, extraInfo = EI}.
+
+
+%% cre_Name(N) when list(N), length(N) == 2 ->
+%% N.
+
+cre_PkgdName(N) when is_list(N) ->
+ case string:tokens(N, [$\\]) of
+ [_PkgName, _ItemID] ->
+ N;
+ _ ->
+ error({invalid_PkgdName, N})
+ end.
+cre_PkgdName(root, root) ->
+ "*/*";
+cre_PkgdName(PackageName, root)
+ when is_list(PackageName) and (length(PackageName) =< 64) ->
+ PackageName ++ "/*";
+cre_PkgdName(PackageName, ItemID)
+ when ((is_list(PackageName) and (length(PackageName) =< 64)) and
+ (is_list(ItemID) and (length(ItemID) =< 64))) ->
+ PackageName ++ "/" ++ ItemID;
+cre_PkgdName(PackageName, ItemID) ->
+ error({invalid_PkgdName, {PackageName, ItemID}}).
+
+%% cre_Relation(greaterThan = R) ->
+%% R;
+%% cre_Relation(smallerThan = R) ->
+%% R;
+%% cre_Relation(unequalTo = R) ->
+%% R.
+
+%% cre_LocalRemoteDescriptor([H|_] = PGs) when list(H) ->
+%% #'LocalRemoteDescriptor'{propGrps = PGs}.
+
+%% cre_PropertyGroup([H|_] = PG) when record(H, 'PropertyParm') ->
+%% PG.
+
+%% cre_TerminationStateDescriptor([H|_] = PPs) when record(H, 'PropertyParm') ->
+%% #'TerminationStateDescriptor'{propertyParms = PPs}.
+
+%% cre_TerminationStateDescriptor([H|_] = PPs, off = EBC)
+%% when record(H, 'PropertyParm') ->
+%% #'TerminationStateDescriptor'{propertyParms = PPs,
+%% eventBufferControl = EBC};
+%% cre_TerminationStateDescriptor([H|_] = PPs, lockStep = EBC)
+%% when record(H, 'PropertyParm') ->
+%% #'TerminationStateDescriptor'{propertyParms = PPs,
+%% eventBufferControl = EBC};
+%% cre_TerminationStateDescriptor([H|_] = PPs, test = SS)
+%% when record(H, 'PropertyParm') ->
+%% #'TerminationStateDescriptor'{propertyParms = PPs,
+%% serviceState = SS};
+%% cre_TerminationStateDescriptor([H|_] = PPs, outOfSvc = SS)
+%% when record(H, 'PropertyParm') ->
+%% #'TerminationStateDescriptor'{propertyParms = PPs,
+%% serviceState = SS};
+%% cre_TerminationStateDescriptor([H|_] = PPs, inSvc = SS)
+%% when record(H, 'PropertyParm') ->
+%% #'TerminationStateDescriptor'{propertyParms = PPs,
+%% serviceState = SS}.
+
+%% cre_TerminationStateDescriptor([H|_] = PPs, EMC, SS)
+%% when record(H, 'PropertyParm'),
+%% ((EMC == off) or (EMC == lockStep)) and
+%% ((SS == test) or (SS == outOfSvc) or (SS == inSvc)) ->
+%% #'TerminationStateDescriptor'{propertyParms = PPs,
+%% eventBufferControl = EMC,
+%% serviceState = SS}.
+
+%% cre_EventBufferControl(off = EBC) ->
+%% EBC;
+%% cre_EventBufferControl(lockStep = EBC) ->
+%% EBC.
+
+%% cre_ServiceState(test = SS) ->
+%% SS;
+%% cre_ServiceState(outOfSvc = SS) ->
+%% SS;
+%% cre_ServiceState(inSvc = SS) ->
+%% SS.
+
+%% cre_MuxDescriptor(MT, [H|_] = TL)
+%% when atom(MT), record(H, 'TerminationID') ->
+%% #'MuxDescriptor'{muxType = MT, termList = TL}.
+
+%% %% cre_MuxDescriptor(MT, [H|_] = TL, NSD)
+%% %% when atom(MT), record(H, 'TerminationID'), record(NSD, 'NonStandardData') ->
+%% %% #'MuxDescriptor'{muxType = MT, termList = TL, nonStandardData = NSD}.
+
+%% cre_MuxType(h221 = MT) ->
+%% MT;
+%% cre_MuxType(h223 = MT) ->
+%% MT;
+%% cre_MuxType(h226 = MT) ->
+%% MT;
+%% cre_MuxType(v76 = MT) ->
+%% MT;
+%% cre_MuxType(nx64k = MT) ->
+%% MT.
+
+%% cre_StreamID(Val) when 0 =< Val, Val =< 65535 ->
+%% Val;
+%% cre_StreamID(Val) ->
+%% exit({invalid_ContextID, Val}).
+
+%% %% RequestID must be present if eventList is non empty
+%% cre_EventsDescriptor() ->
+%% #'EventsDescriptor'{eventList = []}.
+
+%% cre_EventsDescriptor(RID, [H|_] = EL)
+%% when integer(RID), record(H, 'RequestedEvent') ->
+%% #'EventsDescriptor'{requestID = RID, eventList = EL}.
+
+%% cre_RequestedEvent(N) ->
+%% #'RequestedEvent'{pkgdName = N}.
+
+%% cre_RequestedEvent(N, [H|_] = EPL)
+%% when list(N),
+%% record(H, 'EventParameter') ->
+%% #'RequestedEvent'{pkgdName = N,
+%% evParList = EPL};
+%% cre_RequestedEvent(N, EA)
+%% when list(N),
+%% record(EA, 'RequestedActions')->
+%% #'RequestedEvent'{pkgdName = N,
+%% eventAction = EA}.
+
+
+%% cre_RequestedEvent(N, SID, [H|_] = EPL)
+%% when list(N),
+%% integer(SID),
+%% record(H, 'EventParameter') ->
+%% #'RequestedEvent'{pkgdName = N,
+%% streamID = SID,
+%% evParList = EPL};
+%% cre_RequestedEvent(N, EA, [H|_] = EPL)
+%% when list(N),
+%% record(EA, 'RequestedActions'),
+%% record(H, 'EventParameter') ->
+%% #'RequestedEvent'{pkgdName = N,
+%% eventAction = EA,
+%% evParList = EPL}.
+
+%% cre_RequestedEvent(N, SID, EA, [H|_] = EPL)
+%% when list(N),
+%% integer(SID),
+%% record(EA, 'RequestedActions'),
+%% record(H, 'EventParameter') ->
+%% #'RequestedEvent'{pkgdName = N,
+%% streamID = SID,
+%% eventAction = EA,
+%% evParList = EPL}.
+
+%% cre_RequestedActions() ->
+%% #'RequestedActions'{}.
+
+%% cre_RequestedActions(KA)
+%% when (KA == true) or (KA == true) or (KA == asn1_NOVALUE) ->
+%% #'RequestedActions'{keepActive = KA};
+%% cre_RequestedActions(SE)
+%% when is_record(SE, 'SecondEventsDescriptor') or (SE == asn1_NOVALUE) ->
+%% #'RequestedActions'{secondEvent = SE};
+%% cre_RequestedActions(SD)
+%% when is_list(SD) or (SD == asn1_NOVALUE) ->
+%% #'RequestedActions'{signalsDescriptor = SD};
+%% cre_RequestedActions({Tag, _} = EDM)
+%% when is_atom(Tag) or (EDM == asn1_NOVALUE) ->
+%% #'RequestedActions'{eventDM = EDM}.
+
+%% cre_RequestedActions(KA, {Tag, _} = EDM, SE, SD)
+%% when ((KA == true) or (KA == true) or (KA == asn1_NOVALUE)) and
+%% (is_atom(Tag) or (EDM == asn1_NOVALUE)) and
+%% (is_record(SE, 'SecondEventsDescriptor') or (SE == asn1_NOVALUE)) and
+%% (is_list(SD) or (SD == asn1_NOVALUE)) ->
+%% #'RequestedActions'{keepActive = KA,
+%% eventDM = EDM,
+%% secondEvent = SE,
+%% signalsDescriptor = SD}.
+
+%% cre_EventDM(N) when list(N) ->
+%% {digitMapName, N};
+%% cre_EventDM(V) when record(V, 'DigitMapValue') ->
+%% {digitMapValue, V}.
+
+%% cre_SecondEventsDescriptor([H|_] = EL)
+%% when record(H, 'SecondRequestedEvent') ->
+%% #'SecondEventsDescriptor'{eventList = EL}.
+
+%% cre_SecondEventsDescriptor(RID, [H|_] = EL)
+%% when integer(RID), record(H, 'SecondRequestedEvent') ->
+%% #'SecondEventsDescriptor'{requestID = RID, eventList = EL}.
+
+%% cre_SecondRequestedEvent(N, [H|_] = EPL)
+%% when list(N),
+%% record(H, 'EventParameter') ->
+%% #'SecondRequestedEvent'{pkgdName = N,
+%% evParList = EPL}.
+
+%% cre_SecondRequestedEvent(N, SID, [H|_] = EPL)
+%% when list(N),
+%% integer(SID),
+%% record(H, 'EventParameter') ->
+%% #'SecondRequestedEvent'{pkgdName = N,
+%% streamID = SID,
+%% evParList = EPL};
+%% cre_SecondRequestedEvent(N, EA, [H|_] = EPL)
+%% when list(N),
+%% record(EA, 'SecondRequestedActions'),
+%% record(H, 'EventParameter') ->
+%% #'SecondRequestedEvent'{pkgdName = N,
+%% eventAction = EA,
+%% evParList = EPL}.
+
+%% cre_SecondRequestedEvent(N, SID, EA, [H|_] = EPL)
+%% when list(N),
+%% integer(SID),
+%% record(EA, 'SecondRequestedActions'),
+%% record(H, 'EventParameter') ->
+%% #'SecondRequestedEvent'{pkgdName = N,
+%% streamID = SID,
+%% eventAction = EA,
+%% evParList = EPL}.
+
+%% cre_SecondRequestedActions() ->
+%% #'SecondRequestedActions'{}.
+
+%% cre_SecondRequestedActions(KA)
+%% when ((KA == true) or (KA == false) or (KA == asn1_NOVALUE)) ->
+%% #'SecondRequestedActions'{keepActive = KA};
+%% cre_SecondRequestedActions(SD) when list(SD) ->
+%% #'SecondRequestedActions'{signalsDescriptor = SD};
+%% cre_SecondRequestedActions({Tag, _} = EDM) when atom(Tag) ->
+%% #'SecondRequestedActions'{eventDM = EDM}.
+
+%% cre_SecondRequestedActions(KA, SD)
+%% when ((KA == true) or (KA == false) or (KA == asn1_NOVALUE)) and
+%% is_list(SD) ->
+%% #'SecondRequestedActions'{keepActive = KA, signalsDescriptor = SD};
+%% cre_SecondRequestedActions(KA, {Tag, _} = EDM)
+%% when ((KA == true) or (KA == false) or (KA == asn1_NOVALUE)) and
+%% is_atom(Tag) ->
+%% #'SecondRequestedActions'{keepActive = KA, eventDM = EDM}.
+
+%% cre_SecondRequestedActions(KA, {Tag, _} = EDM, SD)
+%% when ((KA == true) or (KA == false) or (KA == asn1_NOVALUE)) and
+%% is_atom(Tag),
+%% is_list(SD) ->
+%% #'SecondRequestedActions'{keepActive = KA,
+%% eventDM = EDM,
+%% signalsDescriptor = SD}.
+
+cre_EventBufferDescriptor([H|_] = D)
+ when is_record(H, 'EventSpec') ->
+ D.
+
+cre_EventSpec(N, [H|_] = EPL)
+ when is_list(N) andalso is_record(H, 'EventParameter') ->
+ #'EventSpec'{eventName = N, eventParList = EPL}.
+
+cre_EventSpec(N, SID, [H|_] = EPL)
+ when is_list(N) andalso is_integer(SID) andalso is_record(H, 'EventParameter') ->
+ #'EventSpec'{eventName = N, streamID = SID, eventParList = EPL}.
+
+%% cre_SignalsDescriptor(D) when list(D) ->
+%% D.
+
+%% cre_SignalRequest(S) when record(S, 'Signal') ->
+%% {signal, S};
+%% cre_SignalRequest(S) when record(S, 'SeqSigList') ->
+%% {seqSigList, S}.
+
+%% cre_SeqSigList(ID, [H|_] = SL)
+%% when integer(ID), 0 =< ID, ID =< 65535, record(H, 'Signal') ->
+%% #'SeqSigList'{id = ID, signalList = SL}.
+
+%% cre_Signal(N) when list(N) ->
+%% #'Signal'{signalName = N}.
+
+%% cre_Signal(N, [H|_] = SPL) when list(N), record(H, 'SigParameter') ->
+%% #'Signal'{signalName = N,
+%% sigParList = SPL}.
+
+%% cre_Signal(N, SID, ST, Dur, NC, KA, [H|_] = SPL)
+%% when is_list(N) and
+%% (is_integer(SID) or (SID == asn1_NOVALUE)) and
+%% ((ST == brief) or (ST == onOff) or (ST == timeOut) or
+%% (ST == asn1_NOVALUE)) and
+%% ((is_integer(Dur) and (0 =< Dur) and (Dur =< 65535)) or
+%% (Dur == asm1_NOVALUE)) and
+%% is_list(NC) and
+%% ((KA == true) or (KA == false) or (KA == asn1_NOVALUE)) and
+%% is_record(H, 'SigParameter') ->
+%% #'Signal'{signalName = N,
+%% streamID = SID,
+%% sigType = ST,
+%% duration = Dur,
+%% notifyCompletion = NC,
+%% keepActive = KA,
+%% sigParList = SPL}.
+
+%% cre_SignalType(brief = ST) ->
+%% ST;
+%% cre_SignalType(onOff = ST) ->
+%% ST;
+%% cre_SignalType(timeOut = ST) ->
+%% ST.
+
+%% cre_SignalName(N) ->
+%% cre_PkgdName(N).
+
+%% cre_NotifyCompletion(L) when list(L) ->
+%% Vals = [onTimeOut, onInterruptByEvent,
+%% onInterruptByNewSignalDescr, otherReason],
+%% F = fun(E) -> case lists:member(E, Vals) of
+%% true ->
+%% ok;
+%% false ->
+%% exit({invalid_NotifyCompletion, E})
+%% end
+%% end,
+%% lists:foreach(F, L),
+%% L.
+
+%% cre_SigParameter(N, V) when list(N), list(V) ->
+%% #'SigParameter'{sigParameterName = N, value = V}.
+
+%% cre_SigParameter(N, V, relation = Tag, R)
+%% when is_list(N) and is_list(V) and is_atom(R) ->
+%% EI = {Tag, R},
+%% #'SigParameter'{sigParameterName = N, value = V, extraInfo = EI};
+%% cre_SigParameter(N, V, range = Tag, B)
+%% when is_list(N) and is_list(V) and is_atom(B) ->
+%% EI = {Tag, B},
+%% #'SigParameter'{sigParameterName = N, value = V, extraInfo = EI};
+%% cre_SigParameter(N, V, sublist = Tag, B)
+%% when is_list(N) and is_list(V) and is_atom(B) ->
+%% EI = {Tag, B},
+%% #'SigParameter'{sigParameterName = N, value = V, extraInfo = EI}.
+
+%% cre_RequestID(Val) when 0 =< Val, Val =< 4294967295 ->
+%% Val;
+%% cre_RequestID(Val) ->
+%% exit({invalid_RequestID, Val}).
+
+%% cre_ModemDescriptor(MTL, MPL) when list(MTL), list(MPL) ->
+%% #'ModemDescriptor'{mtl = MTL, mpl = MPL}.
+
+%% %% cre_ModemDescriptor(MTL, MPL, NSD)
+%% %% when list(MTL), list(MPL), record(NSD, 'NonStandardData') ->
+%% %% #'ModemDescriptor'{mtl = MTL, mpl = MPL}.
+
+%% cre_ModemType(v18 = MT) ->
+%% MT;
+%% cre_ModemType(v22 = MT) ->
+%% MT;
+%% cre_ModemType(v22bis = MT) ->
+%% MT;
+%% cre_ModemType(v32 = MT) ->
+%% MT;
+%% cre_ModemType(v32bis = MT) ->
+%% MT;
+%% cre_ModemType(v34 = MT) ->
+%% MT;
+%% cre_ModemType(v90 = MT) ->
+%% MT;
+%% cre_ModemType(v91 = MT) ->
+%% MT;
+%% cre_ModemType(synchISDN = MT) ->
+%% MT.
+
+%% cre_DigitMapDescriptor() ->
+%% #'DigitMapDescriptor'{}.
+
+%% cre_DigitMapDescriptor(N) when list(N) ->
+%% #'DigitMapDescriptor'{digitMapName = N};
+%% cre_DigitMapDescriptor(V) when record(V, 'DigitMapValue') ->
+%% #'DigitMapDescriptor'{digitMapValue = V}.
+
+%% cre_DigitMapDescriptor(N, V) when list(N), record(V, 'DigitMapValue') ->
+%% #'DigitMapDescriptor'{digitMapName = N, digitMapValue = V}.
+
+%% cre_DigitMapName(N) ->
+%% cre_Name(N).
+
+%% cre_DigitMapValue(DMB) when list(DMB) ->
+%% #'DigitMapValue'{digitMapBody = DMB}.
+
+%% cre_DigitMapValue(Start, Short, Long, DMB) ->
+%% cre_DigitMapValue(Start, Short, Long, DMB, asn1_NOVALUE).
+
+%% cre_DigitMapValue(Start, Short, Long, DMB, Dur)
+%% when ((is_integer(Start) and (0 =< Start) and (Start =< 99)) or
+%% (Start == asn1_NOVALUE)) and
+%% ((is_integer(Short) and (0 =< Short) and (Short =< 99)) or
+%% (Short == asn1_NOVALUE)) and
+%% ((is_integer(Long) and (0 =< Long) and (Long =< 99)) or
+%% (Long == asn1_NOVALUE)) and
+%% is_list(DMB) and
+%% ((is_integer(Dur) and (0 =< Dur) and (Dur =< 99)) or
+%% (Dur == asn1_NOVALUE)) ->
+%% #'DigitMapValue'{startTimer = Start,
+%% shortTimer = Short,
+%% longTimer = Long,
+%% digitMapBody = DMB,
+%% durationTimer = Dur}.
+
+%% cre_ServiceChangeParm(M, R) when atom(M), list(R) ->
+%% #'ServiceChangeParm'{serviceChangeMethod = M,
+%% serviceChangeReason = R}.
+
+%% cre_ServiceChangeParm(M, Addr, Prof, Reason) ->
+%% cre_ServiceChangeParm(M, Addr, asn1_NOVALUE, Prof, Reason, asn1_NOVALUE,
+%% asn1_NOVALUE, asn1_NOVALUE, asn1_NOVALUE).
+
+%% %% Addr = asn1_NOVALUE | {AddrTag, AddrVal}
+%% cre_ServiceChangeParm(M, Addr, Ver, Prof, R, D, Mid, TS, I)
+%% when is_atom(M) and
+%% ((is_integer(Ver) and (0 =< Ver) and (Ver =< 99)) or
+%% (Ver == asn1_NOVALUE)) and
+%% (is_record(Prof, 'ServiceChangeProfile') or (Prof == asn1_NOVALUE)) and
+%% is_list(R) and
+%% ((is_integer(D) and (0 =< D) and (D =< 4294967295)) or
+%% (D == asn1_NOVALUE)) and
+%% (is_record(TS, 'TimeNotation') or (TS == asn1_NOVALUE)) and
+%% (is_record(I, 'AuditDescriptor') or (I == asn1_NOVALUE)) ->
+%% F = fun(A) ->
+%% (A == asn1_NOVALUE) orelse
+%% (is_tuple(A)
+%% andalso is_atom(element(1, A)))
+%% end,
+%% case (F(Addr) andalso F(Mid)) of
+%% true ->
+%% #'ServiceChangeParm'{serviceChangeMethod = M,
+%% serviceChangeAddress = Addr,
+%% serviceChangeVersion = Ver,
+%% serviceChangeProfile = Prof,
+%% serviceChangeReason = R,
+%% serviceChangeDelay = D,
+%% serviceChangeMgcId = Mid,
+%% timeStamp = TS,
+%% serviceChangeInfo = I};
+%% _ ->
+%% exit({invalid_ServiceChangeParm_args, {Addr, Mid}})
+%% end.
+
+%% cre_ServiceChangeAddress(portNumber = Tag, P)
+%% when integer(P), 0 =< P, P =< 65535 ->
+%% {Tag, P};
+%% cre_ServiceChangeAddress(ip4Address = Tag, A) when record(A, 'IP4Address') ->
+%% {Tag, A};
+%% cre_ServiceChangeAddress(ip6Address = Tag, A) when record(A, 'IP6Address') ->
+%% {Tag, A};
+%% cre_ServiceChangeAddress(domainName = Tag, N) when record(N, 'DomainName') ->
+%% {Tag, N};
+%% cre_ServiceChangeAddress(deviceName = Tag, N) when list(N) ->
+%% {Tag, N};
+%% cre_ServiceChangeAddress(mtpAddress = Tag, A) when list(A) ->
+%% {Tag, A}.
+
+%% cre_ServiceChangeResParm() ->
+%% #'ServiceChangeResParm'{}.
+%% cre_ServiceChangeResParm(Addr, Prof) ->
+%% cre_ServiceChangeResParm(asn1_NOVALUE, Addr, asn1_NOVALUE,
+%% Prof, asn1_NOVALUE).
+%% cre_ServiceChangeResParm(Mid, Addr, Ver, Prof, TS)
+%% when ((is_integer(Ver) and (0 =< Ver) and (Ver =< 99)) or
+%% (Ver == asn1_NOVALUE)) and
+%% (is_record(Prof, 'ServiceChangeProfile') or (Prof == asn1_NOVALUE)) and
+%% (is_record(TS, 'TimeNotation') or (TS == asn1_NOVALUE)) ->
+%% F = fun(A) ->
+%% (A == asn1_NOVALUE) orelse
+%% (is_tuple(A)
+%% andalso is_atom(element(1, A)))
+%% end,
+%% case (F(Addr) andalso F(Mid)) of
+%% true ->
+%% #'ServiceChangeResParm'{serviceChangeMgcId = Mid,
+%% serviceChangeAddress = Addr,
+%% serviceChangeVersion = Ver,
+%% serviceChangeProfile = Prof,
+%% timeStamp = TS};
+%% _ ->
+%% exit({invalid_ServiceChangeResParm_args, {Addr, Mid}})
+%% end.
+
+%% cre_ServiceChangeMethod(failover = M) ->
+%% M;
+%% cre_ServiceChangeMethod(forced = M) ->
+%% M;
+%% cre_ServiceChangeMethod(graceful = M) ->
+%% M;
+%% cre_ServiceChangeMethod(restart = M) ->
+%% M;
+%% cre_ServiceChangeMethod(disconnected = M) ->
+%% M;
+%% cre_ServiceChangeMethod(handOff = M) ->
+%% M.
+
+%% %% The version field is added to make it look more like ABNF
+%% cre_ServiceChangeProfile(N) ->
+%% cre_ServiceChangeProfile(N, 1).
+
+%% cre_ServiceChangeProfile(N, V)
+%% when is_list(N) and is_integer(V) and (0 =< V) and (V =< 99) ->
+%% #'ServiceChangeProfile'{profileName = N, version = V}.
+
+%% cre_PackagesDescriptor([H|_] = D) when record(H, 'PackagesItem') ->
+%% D.
+
+%% cre_PackagesItem(N, Ver) when list(N), integer(Ver), 0 =< Ver, Ver =< 99 ->
+%% #'PackagesItem'{packageName = N,
+%% packageVersion = Ver}.
+
+%% cre_StatisticsDescriptor([H|_] = D) when record(H, 'StatisticsParameter') ->
+%% D.
+
+%% cre_StatisticsParameter(N) when list(N) ->
+%% #'StatisticsParameter'{statName = N}.
+
+%% cre_StatisticsParameter(N, V) when list(N), list(V) ->
+%% #'StatisticsParameter'{statName = N, statValue = V}.
+
+%% %% cre_NonStandardData({Tag, _} = Id, Data) when atom(Tag), list(Data) ->
+%% %% #'NonStandardData'{nonStandardIdentifier = Id, data = Data}.
+
+%% %% cre_NonStandardIdentifier(H221) when record(H221, 'H221NonStandard') ->
+%% %% {h221NonStandard, H221};
+%% %% cre_NonStandardIdentifier(Obj) when tuple(Obj) ->
+%% %% {object, Obj};
+%% %% cre_NonStandardIdentifier(Exp) when list(Exp), length(Exp) == 8 ->
+%% %% {experimental, Exp}.
+
+%% %% cre_H221NonStandard(CC1, CC2, Ext, MC)
+%% %% when (is_integer(CC1) and (0 =< CC1) and (CC1 =< 255)) and
+%% %% (is_integer(CC2) and (0 =< CC2) and (CC2 =< 255)) and
+%% %% (is_integer(Ext) and (0 =< Ext) and (Ext =< 255)) and
+%% %% (is_integer(MC) and (0 =< MC) and (MC =< 255)) ->
+%% %% #'H221NonStandard'{t35CountryCode1 = CC1,
+%% %% t35CountryCode2 = CC2,
+%% %% t35Extension = Ext,
+%% %% manufacturerCode = MC}.
+
+%% cre_TimeNotation(D, T)
+%% when list(D), length(D) == 8, list(T), length(T) == 8 ->
+%% #'TimeNotation'{date = D, time = T}.
+
+%% cre_Value([H|_] = V) when list(H) ->
+%% V.
+
+cre_BOOLEAN(true = B) ->
+ B;
+cre_BOOLEAN(false = B) ->
+ B.
+
+
+%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%% %% -- MegacoMessage --
+
+%% is_MegacoMessage(#'MegacoMessage'{authHeader = Auth,
+%% mess = Mess}) ->
+%% is_opt_AuthenticationHeader(Auth) andalso is_Message(Mess);
+%% is_MegacoMessage(_) ->
+%% false.
+
+
+%% chk_MegacoMessage(M, M) ->
+%% chk_type(fun is_MegacoMessage/1, 'MegacoMessage', M);
+%% chk_MegacoMessage(#'MegacoMessage'{authHeader = Auth1,
+%% mess = Mess1},
+%% #'MegacoMessage'{authHeader = Auth2,
+%% mess = Mess2}) ->
+%% chk_opt_AuthenticationHeader(Auth1,Auth2),
+%% chk_Message(Mess1,Mess2),
+%% ok;
+%% chk_MegacoMessage(M1, M2) ->
+%% wrong_type('MegacoMessage', M1, M2).
+
+
+%% %% -- AuthenticationHeader --
+
+%% is_opt_AuthenticationHeader(AH) ->
+%% is_OPTIONAL(fun is_AuthenticationHeader/1, AH).
+
+%% is_AuthenticationHeader(#'AuthenticationHeader'{secParmIndex = SPI,
+%% seqNum = SN,
+%% ad = AD}) ->
+%% is_SecurityParmIndex(SPI) andalso
+%% is_SequenceNum(SN) andalso
+%% is_AuthData(AD);
+%% is_AuthenticationHeader(_) ->
+%% false.
+
+%% %% This stuff is not really used, so make it simple...
+%% chk_opt_AuthenticationHeader(A1, A2) ->
+%% chk_OPTIONAL('AuthenticationHeader', A1, A2,
+%% fun is_AuthenticationHeader/1,
+%% fun chk_AuthenticationHeader/2).
+
+%% chk_AuthenticationHeader(A, A) ->
+%% chk_type(fun is_AuthenticationHeader/1, 'AuthenticationHeader', A);
+%% chk_AuthenticationHeader(A1, A2) ->
+%% case (is_AuthenticationHeader(A1) andalso is_AuthenticationHeader(A2)) of
+%% true ->
+%% not_equal('AuthenticationHeader', A1, A2);
+%% false ->
+%% wrong_type('AuthenticationHeader', A1, A2)
+%% end.
+
+
+%% %% -- SecurityParmIndex --
+
+%% is_SecurityParmIndex(V) -> is_OCTET_STRING(V, {exact, 4}).
+
+
+%% %% -- SequenceNum --
+
+%% is_SequenceNum(V) -> is_OCTET_STRING(V, {exact, 4}).
+
+
+%% %% -- AuthData --
+
+%% is_AuthData(V) -> is_OCTET_STRING(V, {range, 12, 32}).
+
+
+%% %% -- Message --
+
+%% is_Message(#'Message'{version = V,
+%% mId = MID,
+%% messageBody = Body}) ->
+%% is_INTEGER(V, {range, 0, 99}) andalso
+%% is_MId(MID) andalso
+%% is_Message_messageBody(Body);
+%% is_Message(_) ->
+%% false.
+
+%% chk_Message(M,M) when record(M,'Message') ->
+%% ok;
+%% chk_Message(#'Message'{version = V1,
+%% mId = MID1,
+%% messageBody = Body1},
+%% #'Message'{version = V2,
+%% mId = MID2,
+%% messageBody = Body2}) ->
+%% validate(fun() -> chk_INTEGER(V1, V2, {range, 0, 99}) end, 'Message'),
+%% validate(fun() -> chk_MId(MID1, MID2) end, 'Message'),
+%% chk_Message_messageBody(Body1, Body2),
+%% ok;
+%% chk_Message(M1, M2) ->
+%% wrong_type('Message', M1, M2).
+
+
+%% is_Message_messageBody({Tag, Val}) ->
+%% is_Message_messageBody_tag(Tag) andalso
+%% is_Message_messageBody_val(Tag, Val);
+%% is_Message_messageBody(_) ->
+%% false.
+
+%% is_Message_messageBody_tag(Tag) ->
+%% Tags = [messageError, transactions],
+%% lists:member(Tag, Tags).
+
+%% is_Message_messageBody_val(messageError, Val) ->
+%% is_ErrorDescriptor(Val);
+%% is_Message_messageBody_val(transactions, Val) ->
+%% is_Message_messageBody_transactions(Val).
+
+%% is_Message_messageBody_transactions([]) ->
+%% true;
+%% is_Message_messageBody_transactions([H|T]) ->
+%% is_Transaction(H) andalso is_Message_messageBody_transactions(T);
+%% is_Message_messageBody_transactions(_) ->
+%% false.
+
+%% chk_Message_messageBody(B, B) ->
+%% chk_type(fun is_Message_messageBody/1, 'Message_messageBody', B);
+%% chk_Message_messageBody({Tag, Val1} = B1, {Tag, Val2} = B2) ->
+%% case (is_Message_messageBody_tag(Tag) andalso
+%% is_Message_messageBody_val(Tag, Val1) andalso
+%% is_Message_messageBody_val(Tag, Val2)) of
+%% true ->
+%% chk_Message_messageBody_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('Message_messageBody', B1, B2)
+%% end;
+%% chk_Message_messageBody({Tag1, Val1} = B1, {Tag2, Val2} = B2) ->
+%% case ((is_Message_messageBody_tag(Tag1) andalso
+%% is_Message_messageBody_val(Tag1, Val1)) andalso
+%% (is_Message_messageBody_tag(Tag2) andalso
+%% is_Message_messageBody_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('Message_messageBody', B1, B2);
+%% false ->
+%% wrong_type('Message_messageBody', B1, B2)
+%% end;
+%% chk_Message_messageBody(B1, B2) ->
+%% wrong_type('Message_messageBody', B1, B2).
+
+%% chk_Message_messageBody_val(messageError, Val1, Val2) ->
+%% validate(fun() -> chk_ErrorDescriptor(Val1, Val2) end,
+%% 'Message_messageBody');
+%% chk_Message_messageBody_val(transactions, Val1, Val2) ->
+%% chk_Message_messageBody_transactions(Val1, Val2).
+
+%% chk_Message_messageBody_transactions([], []) ->
+%% ok;
+%% chk_Message_messageBody_transactions([] = T1, T2) ->
+%% not_equal('Message_messageBody_transactions', T1, T2);
+%% chk_Message_messageBody_transactions(T1, [] = T2) ->
+%% not_equal('Message_messageBody_transactions', T1, T2);
+%% chk_Message_messageBody_transactions([H|T1], [H|T2]) ->
+%% case is_Transaction(H) of
+%% true ->
+%% chk_Message_messageBody_transactions(T1, T2);
+%% false ->
+%% wrong_type('Message_messageBody_transactions_val', H)
+%% end;
+%% chk_Message_messageBody_transactions([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_Transaction(H1, H2) end,
+%% 'Message_messageBody_transactions_val'),
+%% chk_Message_messageBody_transactions(T1, T2);
+%% chk_Message_messageBody_transactions(T1, T2) ->
+%% wrong_type('Message_messageBody_transactions', T1, T2).
+
+
+%% %% -- MId --
+
+%% is_opt_MId(M) ->
+%% is_OPTIONAL(fun is_MId/1, M).
+
+%% is_MId({Tag, Val}) ->
+%% is_MId_tag(Tag) andalso is_MId_val(Tag, Val);
+%% is_MId(_) ->
+%% false.
+
+%% is_MId_tag(Tag) ->
+%% Tags = [ip4Address, ip6Address, domainName, deviceName, mtpAddress],
+%% lists:member(Tag, Tags).
+
+%% is_MId_val(ip4Address, Val) -> is_IP4Address(Val);
+%% is_MId_val(ip6Address, Val) -> is_IP6Address(Val);
+%% is_MId_val(domainName, Val) -> is_DomainName(Val);
+%% is_MId_val(deviceName, Val) -> is_PathName(Val);
+%% is_MId_val(mtpAddress, Val) -> is_OCTET_STRING(Val, {range, 2, 4}).
+
+%% chk_opt_MId(M1, M2) ->
+%% chk_OPTIONAL('MId', M1, M2, fun is_MId/1, fun chk_MId/2).
+
+%% chk_MId(M, M) ->
+%% chk_type(fun is_MId/1, 'MId', M);
+%% chk_MId({Tag, Val1} = M1, {Tag, Val2} = M2) ->
+%% case (is_MId_tag(Tag) andalso
+%% is_MId_val(Tag, Val1) andalso
+%% is_MId_val(Tag, Val2)) of
+%% true ->
+%% chk_MId_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('MId', M1, M2)
+%% end;
+%% chk_MId({Tag1, Val1} = M1, {Tag2, Val2} = M2) ->
+%% case ((is_MId_tag(Tag1) andalso
+%% is_MId_val(Tag1, Val1)) andalso
+%% (is_MId_tag(Tag2) andalso
+%% is_MId_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('MId', M1, M2);
+%% false ->
+%% wrong_type('MId', M1, M2)
+%% end;
+%% chk_MId(M1, M2) ->
+%% wrong_type('MId', M1, M2).
+
+%% chk_MId_val(ip4Address, M1, M2) -> chk_IP4Address(M1, M2);
+%% chk_MId_val(ip6Address, M1, M2) -> chk_IP6Address(M1, M2);
+%% chk_MId_val(domainName, M1, M2) -> chk_DomainName(M1, M2);
+%% chk_MId_val(deviceName, M1, M2) -> chk_PathName(M1, M2);
+%% chk_MId_val(mtpAddress, M1, M2) -> chk_OCTET_STRING(M1, M2, {range, 2, 4}).
+
+
+%% %% -- DomainName --
+
+%% is_DomainName(#'DomainName'{name = N, portNumber = PN}) ->
+%% is_IA5String(N) andalso is_opt_INTEGER(PN, {range, 0, 65535});
+%% is_DomainName(_) ->
+%% false.
+
+%% chk_DomainName(N, N) ->
+%% ok;
+%% chk_DomainName(N1, N2) ->
+%% not_equal('DomainName', N1, N2).
+
+
+%% %% -- IP4Address --
+
+%% is_IP4Address(#'IP4Address'{address = A, portNumber = PN}) ->
+%% is_OCTET_STRING(A, {exact, 4}) andalso
+%% is_opt_INTEGER(PN, {range, 0, 65535});
+%% is_IP4Address(_) ->
+%% false.
+
+%% chk_IP4Address(A, A) ->
+%% ok;
+%% chk_IP4Address(A1, A2) ->
+%% not_equal('IP4Address', A1, A2).
+
+
+%% %% -- IP6Address --
+
+%% is_IP6Address(#'IP6Address'{address = A, portNumber = PN}) ->
+%% is_OCTET_STRING(A, {exact, 16}) andalso
+%% is_opt_INTEGER(PN, {range, 0, 65535});
+%% is_IP6Address(_) ->
+%% false.
+
+%% chk_IP6Address(A, A) ->
+%% ok;
+%% chk_IP6Address(A1, A2) ->
+%% not_equal('IP6Address', A1, A2).
+
+
+%% %% -- PathName --
+
+%% is_PathName(N) -> is_IA5String(N, {range, 1, 64}).
+
+%% chk_PathName(N, N) ->
+%% ok;
+%% chk_PathName(N1, N2) ->
+%% not_equal('PathName', N1, N2).
+
+
+%% %% -- Transaction --
+
+%% is_Transaction({Tag, Val}) ->
+%% is_Transaction_tag(Tag) andalso is_Transaction_val(Tag, Val);
+%% is_Transaction(_) ->
+%% false.
+
+%% is_Transaction_tag(Tag) ->
+%% Tags = [transactionRequest,
+%% transactionPending,
+%% transactionReply,
+%% transactionResponseAck],
+%% lists:member(Tag, Tags).
+
+%% is_Transaction_val(transactionRequest, V) -> is_TransactionRequest(V);
+%% is_Transaction_val(transactionPending, V) -> is_TransactionPending(V);
+%% is_Transaction_val(transactionReply, V) -> is_TransactionReply(V);
+%% is_Transaction_val(transactionResponseAck, V) -> is_TransactionResponseAck(V).
+
+
+%% chk_Transaction({Tag, Val} = Trans, {Tag, Val}) ->
+%% case (is_Transaction_tag(Tag) andalso is_Transaction_val(Tag, Val)) of
+%% true ->
+%% ok;
+%% false ->
+%% wrong_type('Transaction', Trans, Trans)
+%% end;
+%% chk_Transaction({Tag, Val1} = Trans1, {Tag, Val2} = Trans2) ->
+%% case (is_Transaction_tag(Tag) and
+%% is_Transaction_val(Tag, Val1) and
+%% is_Transaction_val(Tag, Val2)) of
+%% true ->
+%% chk_Transaction_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('Transaction', Trans1, Trans2)
+%% end;
+%% chk_Transaction({Tag1, Val1} = Trans1, {Tag2, Val2} = Trans2) ->
+%% case ((is_Transaction_tag(Tag1) andalso
+%% is_Transaction_val(Tag1, Val1)) andalso
+%% (is_Transaction_tag(Tag2) andalso
+%% is_Transaction_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('Transaction', Trans1, Trans2);
+%% false ->
+%% wrong_type('Transaction', Trans1, Trans2)
+%% end;
+%% chk_Transaction(Trans1, Trans2) ->
+%% wrong_type('Transaction', Trans1, Trans2).
+
+%% chk_Transaction_val(transactionRequest, T1, T2) ->
+%% chk_TransactionRequest(T1, T2);
+%% chk_Transaction_val(transactionPending, T1, T2) ->
+%% chk_TransactionPending(T1, T2);
+%% chk_Transaction_val(transactionReply, T1, T2) ->
+%% chk_TransactionReply(T1,T2);
+%% chk_Transaction_val(transactionResponseAck, T1, T2) ->
+%% chk_TransactionResponseAck(T1, T2).
+
+
+%% %% -- TransactionId --
+
+%% is_opt_TransactionId(TID) ->
+%% is_OPTIONAL(fun is_TransactionId/1, TID).
+
+%% is_TransactionId(TID) -> is_INTEGER(TID, {range, 0, 4294967295}).
+
+%% chk_opt_TransactionId(TID1, TID2) ->
+%% chk_OPTIONAL('TransactionId', TID1, TID2,
+%% fun is_TransactionId/1, fun chk_TransactionId/2).
+
+%% chk_TransactionId(TID, TID) ->
+%% chk_type(fun is_TransactionId/1, 'TransactionId', TID);
+%% chk_TransactionId(TID1, TID2) ->
+%% case (is_TransactionId(TID1) andalso is_TransactionId(TID2)) of
+%% true ->
+%% not_equal('TransactionId', TID1, TID2);
+%% false ->
+%% wrong_type('TransactionId', TID1, TID2)
+%% end.
+
+
+%% %% -- TransactionRequest --
+
+%% is_TransactionRequest(#'TransactionRequest'{transactionId = TID,
+%% actions = Acts}) ->
+%% is_TransactionId(TID) andalso is_TransactionRequest_actions(Acts);
+%% is_TransactionRequest(_) ->
+%% false.
+
+%% chk_TransactionRequest(T, T) ->
+%% chk_type(fun is_TransactionRequest/1, 'TransactionRequest', T);
+%% chk_TransactionRequest(#'TransactionRequest'{transactionId = TID1,
+%% actions = Acts1},
+%% #'TransactionRequest'{transactionId = TID2,
+%% actions = Acts2}) ->
+%% validate(fun() -> chk_TransactionId(TID1, TID2) end, 'TransactionRequest'),
+%% chk_TransactionRequest_actions(Acts1, Acts2),
+%% ok;
+%% chk_TransactionRequest(T1, T2) ->
+%% wrong_type('TransactionRequest', T1, T2).
+
+%% is_TransactionRequest_actions([]) ->
+%% true;
+%% is_TransactionRequest_actions([H|T]) ->
+%% is_ActionRequest(H) andalso is_TransactionRequest_actions(T);
+%% is_TransactionRequest_actions(_) ->
+%% false.
+
+%% chk_TransactionRequest_actions([], []) ->
+%% ok;
+%% chk_TransactionRequest_actions([] = Acts1, Acts2) ->
+%% not_equal('TransactionRequest_actions', Acts1, Acts2);
+%% chk_TransactionRequest_actions(Acts1, [] = Acts2) ->
+%% not_equal('TransactionRequest_actions', Acts1, Acts2);
+%% chk_TransactionRequest_actions([H|T1], [H|T2]) ->
+%% case is_ActionRequest(H) of
+%% true ->
+%% chk_TransactionRequest_actions(T1, T2);
+%% false ->
+%% wrong_type('TransactionRequest_actions_val', H)
+%% end;
+%% chk_TransactionRequest_actions([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_ActionRequest(H1, H2) end,
+%% 'TransactionRequest_actions_val'),
+%% chk_TransactionRequest_actions(T1, T2);
+%% chk_TransactionRequest_actions(Acts1, Acts2) ->
+%% wrong_type('TransactionRequest_actions', Acts1, Acts2).
+
+
+%% %% -- TransactionPending --
+
+%% is_TransactionPending(#'TransactionPending'{transactionId = TID}) ->
+%% is_TransactionId(TID);
+%% is_TransactionPending(_) ->
+%% false.
+
+%% chk_TransactionPending(T, T) ->
+%% chk_type(fun is_TransactionPending/1, 'TransactionPending', T);
+%% chk_TransactionPending(#'TransactionPending'{transactionId = TID1},
+%% #'TransactionPending'{transactionId = TID2}) ->
+%% validate(fun() -> chk_TransactionId(TID1, TID2) end, 'TransactionPending'),
+%% ok;
+%% chk_TransactionPending(T1, T2) ->
+%% wrong_type('TransactionPending', T1, T2).
+
+
+%% %% -- TransactionReply --
+
+%% is_TransactionReply(#'TransactionReply'{transactionId = TID,
+%% immAckRequired = IAR,
+%% transactionResult = TR}) ->
+%% is_TransactionId(TID) andalso
+%% is_opt_NULL(IAR) andalso
+%% is_TransactionReply_transactionResult(TR);
+%% is_TransactionReply(_) ->
+%% false.
+
+%% chk_TransactionReply(T, T) ->
+%% chk_type(fun is_TransactionReply/1, 'TransactionReply', T);
+%% chk_TransactionReply(#'TransactionReply'{transactionId = TID1,
+%% immAckRequired = IAR1,
+%% transactionResult = TR1},
+%% #'TransactionReply'{transactionId = TID2,
+%% immAckRequired = IAR2,
+%% transactionResult = TR2}) ->
+%% validate(fun() -> chk_TransactionId(TID1, TID2) end, 'TransactionReply'),
+%% validate(fun() -> chk_opt_NULL(IAR1, IAR2) end, 'TransactionReply'),
+%% chk_TransactionReply_transactionResult(TR1, TR2),
+%% ok;
+%% chk_TransactionReply(T1, T2) ->
+%% wrong_type('TransactionReply', T1, T2).
+
+%% is_TransactionReply_transactionResult({Tag, Val}) ->
+%% is_TransactionReply_transactionResult_tag(Tag) andalso
+%% is_TransactionReply_transactionResult_val(Tag, Val);
+%% is_TransactionReply_transactionResult(_) ->
+%% false.
+
+%% is_TransactionReply_transactionResult_tag(T) ->
+%% lists:member(T, [transactionError, actionReplies]).
+
+%% is_TransactionReply_transactionResult_val(transactionError, V) ->
+%% is_ErrorDescriptor(V);
+%% is_TransactionReply_transactionResult_val(actionReplies, V) ->
+%% is_TransactionReply_actionReplies(V).
+
+%% chk_TransactionReply_transactionResult(Res, Res) ->
+%% chk_type(fun is_TransactionReply_transactionResult/1,
+%% 'TransactionReply_transactionResult', Res);
+%% chk_TransactionReply_transactionResult({Tag, Val1} = Res1,
+%% {Tag, Val2} = Res2) ->
+%% case (is_TransactionReply_transactionResult_tag(Tag) and
+%% is_TransactionReply_transactionResult_val(Tag, Val1) and
+%% is_TransactionReply_transactionResult_val(Tag, Val2)) of
+%% true ->
+%% chk_TransactionReply_transactionResult_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('TransactionReply_transactionResult', Res1, Res2)
+%% end;
+%% chk_TransactionReply_transactionResult({Tag1, Val1} = Res1,
+%% {Tag2, Val2} = Res2) ->
+%% case ((is_TransactionReply_transactionResult_tag(Tag1) and
+%% is_TransactionReply_transactionResult_val(Tag1, Val1)) and
+%% (is_TransactionReply_transactionResult_tag(Tag2) and
+%% is_TransactionReply_transactionResult_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('TransactionReply_transactionResult', Res1, Res2);
+%% false ->
+%% wrong_type('TransactionReply_transactionResult', Res1, Res2)
+%% end;
+%% chk_TransactionReply_transactionResult(Res1, Res2) ->
+%% wrong_type('TransactionReply_transactionResult', Res1, Res2).
+
+%% chk_TransactionReply_transactionResult_val(transactionError, E1, E2) ->
+%% validate(fun() -> chk_ErrorDescriptor(E1, E2) end,
+%% 'TransactionReply_transactionResult');
+%% chk_TransactionReply_transactionResult_val(actionReplies, R1, R2) ->
+%% validate(fun() -> chk_TransactionReply_actionReplies(R1, R2) end,
+%% 'TransactionReply_transactionResult').
+
+%% is_TransactionReply_actionReplies([]) ->
+%% true;
+%% is_TransactionReply_actionReplies([H|T]) ->
+%% is_ActionReply(H) andalso is_TransactionReply_actionReplies(T);
+%% is_TransactionReply_actionReplies(_) ->
+%% false.
+
+%% chk_TransactionReply_actionReplies([], []) ->
+%% ok;
+%% chk_TransactionReply_actionReplies([] = AR1, AR2) ->
+%% not_equal('TransactionReply_actionReplies', AR1, AR2);
+%% chk_TransactionReply_actionReplies(AR1, [] = AR2) ->
+%% not_equal('TransactionReply_actionReplies', AR1, AR2);
+%% chk_TransactionReply_actionReplies([H|T1], [H|T2]) ->
+%% case is_ActionReply(H) of
+%% true ->
+%% chk_TransactionReply_actionReplies(T1, T2);
+%% false ->
+%% wrong_type('TransactionReply_actionReplies_val', H)
+%% end;
+%% chk_TransactionReply_actionReplies([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_ActionReply(H1, H2) end,
+%% 'TransactionReply_actionReplies_val'),
+%% chk_TransactionReply_actionReplies(T1, T2);
+%% chk_TransactionReply_actionReplies(AR1, AR2) ->
+%% wrong_type('TransactionReply_actionReplies', AR1, AR2).
+
+
+%% %% -- TransactionResponseAck --
+
+%% is_TransactionResponseAck([]) ->
+%% true;
+%% is_TransactionResponseAck([H|T]) ->
+%% is_TransactionAck(H) andalso is_TransactionResponseAck(T);
+%% is_TransactionResponseAck(_) ->
+%% false.
+
+%% chk_TransactionResponseAck([], []) ->
+%% ok;
+%% chk_TransactionResponseAck([] = AR1, AR2) ->
+%% not_equal('TransactionResponseAck', AR1, AR2);
+%% chk_TransactionResponseAck(AR1, [] = AR2) ->
+%% not_equal('TransactionResponseAck', AR1, AR2);
+%% chk_TransactionResponseAck([H|T1], [H|T2]) ->
+%% case is_TransactionAck(H) of
+%% true ->
+%% chk_TransactionResponseAck(T1, T2);
+%% false ->
+%% wrong_type('TransactionResponseAck_val', H)
+%% end;
+%% chk_TransactionResponseAck([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_TransactionAck(H1, H2) end,
+%% 'TransactionResponseAck'),
+%% chk_TransactionResponseAck(T1, T2);
+%% chk_TransactionResponseAck(AR1, AR2) ->
+%% wrong_type('TransactionResponseAck', AR1, AR2).
+
+
+%% %% -- TransactionAck --
+
+%% is_TransactionAck(#'TransactionAck'{firstAck = F,
+%% lastAck = L}) ->
+%% is_TransactionId(F) andalso is_opt_TransactionId(L);
+%% is_TransactionAck(_) ->
+%% false.
+
+%% chk_TransactionAck(T, T) ->
+%% chk_type(fun is_TransactionAck/1, 'TransactionAck', T);
+%% chk_TransactionAck(#'TransactionAck'{firstAck = F1,
+%% lastAck = L1},
+%% #'TransactionAck'{firstAck = F2,
+%% lastAck = L2}) ->
+%% validate(fun() -> chk_TransactionId(F1, F2) end, 'TransactionAck'),
+%% validate(fun() -> chk_opt_TransactionId(L1, L2) end, 'TransactionAck'),
+%% ok;
+%% chk_TransactionAck(T1, T2) ->
+%% wrong_type('TransactionAck', T1, T2).
+
+
+%% %% -- ErrorDescriptor --
+
+%% is_opt_ErrorDescriptor(V) ->
+%% is_OPTIONAL(fun is_ErrorDescriptor/1, V).
+
+%% is_ErrorDescriptor(#'ErrorDescriptor'{errorCode = Code,
+%% errorText = Text}) ->
+%% is_ErrorCode(Code) andalso is_opt_ErrorText(Text);
+%% is_ErrorDescriptor(_) ->
+%% false.
+
+%% chk_opt_ErrorDescriptor(E1, E2) ->
+%% chk_OPTIONAL('ErrorDescriptor', E1, E2,
+%% fun is_ErrorDescriptor/1, fun chk_ErrorDescriptor/2).
+
+%% chk_ErrorDescriptor(E, E) ->
+%% chk_type(fun is_ErrorDescriptor/1, 'ErrorDescriptor', E);
+%% chk_ErrorDescriptor(#'ErrorDescriptor'{errorCode = Code1,
+%% errorText = Text1},
+%% #'ErrorDescriptor'{errorCode = Code2,
+%% errorText = Text2}) ->
+%% chk_ErrorCode(Code1, Code2),
+%% chk_opt_ErrorText(Text1, Text2),
+%% ok;
+%% chk_ErrorDescriptor(E1, E2) ->
+%% wrong_type('ErrorDescriptor', E1, E2).
+
+
+%% %% -- ErrorCode --
+
+%% is_ErrorCode(C) -> is_INTEGER(C, {range, 0, 65535}).
+
+%% chk_ErrorCode(C, C) ->
+%% case is_ErrorCode(C) of
+%% true ->
+%% ok;
+%% false ->
+%% wrong_type(errorCode, C, C)
+%% end;
+%% chk_ErrorCode(C1, C2) ->
+%% case (is_ErrorCode(C1) andalso is_ErrorCode(C2)) of
+%% true ->
+%% not_equal(errorCode, C1, C2);
+%% false ->
+%% wrong_type(errorCode, C1, C2)
+%% end.
+
+
+%% %% -- ErrorText --
+
+%% is_opt_ErrorText(V) ->
+%% is_OPTIONAL(fun is_ErrorText/1, V).
+
+%% is_ErrorText(V) -> is_IA5String(V).
+
+%% chk_opt_ErrorText(T1, T2) ->
+%% chk_OPTIONAL('ErrorText', T1, T2, fun is_ErrorText/1, fun chk_ErrorText/2).
+
+%% chk_ErrorText(T, T) ->
+%% chk_type(fun is_ErrorText/1, 'ErrorText', T);
+%% chk_ErrorText(T1, T2) ->
+%% case (is_ErrorText(T1) andalso is_ErrorText(T2)) of
+%% true ->
+%% case {to_lower(T1), to_lower(T2)} of
+%% {T, T} ->
+%% ok;
+%% _ ->
+%% not_equal('ErrorText', T1, T2)
+%% end;
+%% false ->
+%% wrong_type('ErrorText', T1, T2)
+%% end.
+
+
+%% %% -- ContextID --
+
+%% is_ContextID(Id) -> is_INTEGER(Id, {range, 0, 4294967295}).
+
+%% chk_ContextID(Id, Id) ->
+%% chk_type(fun is_ContextID/1, 'ContextID', Id);
+%% chk_ContextID(Id1, Id2) ->
+%% case (is_ContextID(Id1) andalso is_ContextID(Id2)) of
+%% true ->
+%% not_equal('ContextID', Id1, Id2);
+%% false ->
+%% wrong_type('ContextID', Id1, Id2)
+%% end.
+
+
+%% %% -- ActionRequest --
+
+%% is_ActionRequest(#'ActionRequest'{contextId = Id,
+%% contextRequest = CtxReq,
+%% contextAttrAuditReq = AuditReq,
+%% commandRequests = CmdReqs}) ->
+%% is_ContextID(Id) andalso
+%% is_opt_ContextRequest(CtxReq) andalso
+%% is_opt_ContextAttrAuditRequest(AuditReq) andalso
+%% is_ActionRequest_commandRequests(CmdReqs);
+%% is_ActionRequest(_) ->
+%% false.
+
+%% chk_ActionRequest(A, A) ->
+%% chk_type(fun is_ActionRequest/1, 'ActionRequest', A);
+%% chk_ActionRequest(#'ActionRequest'{contextId = Id1,
+%% contextRequest = Req1,
+%% contextAttrAuditReq = AuditReq1,
+%% commandRequests = CmdReqs1},
+%% #'ActionRequest'{contextId = Id2,
+%% contextRequest = Req2,
+%% contextAttrAuditReq = AuditReq2,
+%% commandRequests = CmdReqs2}) ->
+%% validate(fun() -> chk_ContextID(Id1, Id2) end, 'ActionRequest'),
+%% validate(fun() -> chk_opt_ContextRequest(Req1, Req2) end, 'ActionRequest'),
+%% validate(fun() ->
+%% chk_opt_ContextAttrAuditRequest(AuditReq1, AuditReq2)
+%% end,
+%% 'ActionRequest'),
+%% chk_ActionRequest_commandRequests(CmdReqs1, CmdReqs2),
+%% ok.
+
+
+%% is_ActionRequest_commandRequests([]) ->
+%% true;
+%% is_ActionRequest_commandRequests([H|T]) ->
+%% is_CommandRequest(H) andalso is_ActionRequest_commandRequests(T);
+%% is_ActionRequest_commandRequests(_) ->
+%% false.
+
+%% chk_ActionRequest_commandRequests([], []) ->
+%% ok;
+%% chk_ActionRequest_commandRequests([] = CmdReqs1, CmdReqs2) ->
+%% not_equal('ActionRequest_commandRequests', CmdReqs1, CmdReqs2);
+%% chk_ActionRequest_commandRequests(CmdReqs1, [] = CmdReqs2) ->
+%% not_equal('ActionRequest_commandRequests', CmdReqs1, CmdReqs2);
+%% chk_ActionRequest_commandRequests([H|T1], [H|T2]) ->
+%% case is_CommandRequest(H) of
+%% true ->
+%% chk_ActionRequest_commandRequests(T1, T2);
+%% false ->
+%% wrong_type('ActionRequest_commandRequest_val', H)
+%% end;
+%% chk_ActionRequest_commandRequests([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_CommandRequest(H1, H2) end,
+%% 'ActionRequest_commandRequests_val'),
+%% chk_ActionRequest_commandRequests(T1, T2);
+%% chk_ActionRequest_commandRequests(R1, R2) ->
+%% wrong_type('ActionRequest_commandRequests', R1, R2).
+
+
+%% %% -- ActionReply --
+
+%% is_ActionReply(#'ActionReply'{contextId = Id,
+%% errorDescriptor = ED,
+%% contextReply = CtxRep,
+%% commandReply = CmdRep}) ->
+%% is_ContextID(Id) andalso
+%% is_opt_ErrorDescriptor(ED) andalso
+%% is_opt_ContextRequest(CtxRep) andalso
+%% is_ActionReply_commandReply(CmdRep);
+%% is_ActionReply(_) ->
+%% false.
+
+%% is_ActionReply_commandReply([]) ->
+%% true;
+%% is_ActionReply_commandReply([H|T]) ->
+%% is_CommandReply(H) andalso is_ActionReply_commandReply(T);
+%% is_ActionReply_commandReply(_) ->
+%% false.
+
+%% chk_ActionReply(A, A) ->
+%% chk_type(fun is_ActionReply/1, 'ActionReply', A);
+%% chk_ActionReply(#'ActionReply'{contextId = Id1,
+%% errorDescriptor = ED1,
+%% contextReply = CtxRep1,
+%% commandReply = CmdRep1},
+%% #'ActionReply'{contextId = Id2,
+%% errorDescriptor = ED2,
+%% contextReply = CtxRep2,
+%% commandReply = CmdRep2}) ->
+%% chk_ContextID(Id1, Id2),
+%% chk_opt_ErrorDescriptor(ED1, ED2),
+%% chk_opt_ContextRequest(CtxRep1, CtxRep2),
+%% chk_ActionReply_commandReply(CmdRep1, CmdRep2).
+
+%% chk_ActionReply_commandReply([], []) ->
+%% ok;
+%% chk_ActionReply_commandReply([] = Reps1, Reps2) ->
+%% not_equal('ActionReply_commandReply', Reps1, Reps2);
+%% chk_ActionReply_commandReply(Reps1, [] = Reps2) ->
+%% not_equal('ActionReply_commandReply', Reps1, Reps2);
+%% chk_ActionReply_commandReply([H|T1], [H|T2]) ->
+%% case is_CommandReply(H) of
+%% true ->
+%% chk_ActionReply_commandReply(T1, T2);
+%% false ->
+%% wrong_type('ActionReply_commandReply_val', H)
+%% end;
+%% chk_ActionReply_commandReply([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_CommandReply(H1, H2) end,
+%% 'ActionReply_commandReply_val'),
+%% chk_ActionReply_commandReply(T1, T2);
+%% chk_ActionReply_commandReply(R1, R2) ->
+%% wrong_type('ActionReply_commandReply', R1, R2).
+
+
+%% %% -- ContextRequest --
+
+%% is_opt_ContextRequest(asn1_NOVALUE) ->
+%% true;
+%% is_opt_ContextRequest(V) ->
+%% is_ContextRequest(V).
+
+%% is_ContextRequest(#'ContextRequest'{priority = Prio,
+%% emergency = Em,
+%% topologyReq = TopReq}) ->
+%% is_ContextRequest_priority(Prio) andalso
+%% is_ContextRequest_emergency(Em) andalso
+%% is_ContextRequest_topologyReq(TopReq);
+%% is_ContextRequest(_) ->
+%% false.
+
+%% is_ContextRequest_priority(asn1_NOVALUE) ->
+%% true;
+%% is_ContextRequest_priority(V) ->
+%% is_INTEGER(V, {range, 1, 15}).
+
+%% is_ContextRequest_emergency(asn1_NOVALUE) ->
+%% true;
+%% is_ContextRequest_emergency(V) ->
+%% is_BOOLEAN(V).
+
+%% is_ContextRequest_topologyReq(asn1_NOVALUE) ->
+%% true;
+%% is_ContextRequest_topologyReq([]) ->
+%% true;
+%% is_ContextRequest_topologyReq([H|T]) ->
+%% is_TopologyRequest(H) andalso is_ContextRequest_topologyReq(T);
+%% is_ContextRequest_topologyReq(_) ->
+%% false.
+
+%% chk_opt_ContextRequest(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_ContextRequest(R, R) ->
+%% chk_ContextRequest(R, R).
+
+%% chk_ContextRequest(R, R) ->
+%% chk_type(fun is_ContextRequest/1, 'ContextRequest', R);
+%% chk_ContextRequest(#'ContextRequest'{priority = Prio1,
+%% emergency = Em1,
+%% topologyReq = TopReq1},
+%% #'ContextRequest'{priority = Prio2,
+%% emergency = Em2,
+%% topologyReq = TopReq2}) ->
+%% chk_ContextRequest_priority(Prio1, Prio2),
+%% chk_ContextRequest_emergency(Em1, Em2),
+%% chk_ContextRequest_topologyReq(TopReq1, TopReq2),
+%% ok;
+%% chk_ContextRequest(R1, R2) ->
+%% wrong_type('ContextRequest', R1, R2).
+
+
+%% chk_ContextRequest_priority(asn1_NOVALUE,asn1_NOVALUE) ->
+%% ok;
+%% chk_ContextRequest_priority(P, P) ->
+%% chk_type(fun is_ContextRequest_priority/1, 'ContextRequest_priority', P);
+%% chk_ContextRequest_priority(P1, P2) ->
+%% case (is_ContextRequest_priority(P1) andalso
+%% is_ContextRequest_priority(P2)) of
+%% true ->
+%% not_equal('ContextRequest_priority', P1, P2);
+%% false ->
+%% wrong_type(contextRequest_priority, P1, P2)
+%% end.
+
+
+%% chk_ContextRequest_emergency(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_ContextRequest_emergency(E, E) ->
+%% chk_type(fun is_ContextRequest_emergency/1, 'ContextRequest_emergency', E);
+%% chk_ContextRequest_emergency(E1, E2) ->
+%% case (is_ContextRequest_emergency(E1) andalso
+%% is_ContextRequest_emergency(E2)) of
+%% true ->
+%% not_equal('ContextRequest_emergency', E1, E2);
+%% false ->
+%% wrong_type('ContextRequest_emergency', E1, E2)
+%% end.
+
+%% chk_ContextRequest_topologyReq(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_ContextRequest_topologyReq([], []) ->
+%% ok;
+%% chk_ContextRequest_topologyReq([] = T1, T2) ->
+%% not_equal('ContextRequest_topologyReq', T1, T2);
+%% chk_ContextRequest_topologyReq(T1, [] = T2) ->
+%% not_equal('ContextRequest_topologyReq', T1, T2);
+%% chk_ContextRequest_topologyReq([H|T1], [H|T2]) ->
+%% case is_TopologyRequest(H) of
+%% true ->
+%% chk_ContextRequest_topologyReq(T1, T2);
+%% false ->
+%% wrong_type('ContextRequest_topologyReq_val', H)
+%% end;
+%% chk_ContextRequest_topologyReq([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_TopologyRequest(H1, H2) end,
+%% 'ContextRequest_topologyReq_val'),
+%% chk_ContextRequest_topologyReq(T1, T2);
+%% chk_ContextRequest_topologyReq(T1, T2) ->
+%% wrong_type('ContextRequest_topologyReq', T1, T2).
+
+
+%% %% -- ContextAttrAuditRequest --
+
+%% is_opt_ContextAttrAuditRequest(asn1_NOVALUE) ->
+%% true;
+%% is_opt_ContextAttrAuditRequest(V) ->
+%% is_ContextAttrAuditRequest(V).
+
+%% is_ContextAttrAuditRequest(#'ContextAttrAuditRequest'{topology = T,
+%% emergency = E,
+%% priority = P}) ->
+%% is_opt_NULL(T) andalso is_opt_NULL(E) andalso is_opt_NULL(P);
+%% is_ContextAttrAuditRequest(_) ->
+%% false.
+
+%% chk_opt_ContextAttrAuditRequest(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_ContextAttrAuditRequest(R1, R2) ->
+%% chk_ContextAttrAuditRequest(R1, R2).
+
+%% chk_ContextAttrAuditRequest(R, R) ->
+%% chk_type(fun is_ContextAttrAuditRequest/1, 'ContextAttrAuditRequest', R);
+%% chk_ContextAttrAuditRequest(#'ContextAttrAuditRequest'{topology = T1,
+%% emergency = E1,
+%% priority = P1},
+%% #'ContextAttrAuditRequest'{topology = T2,
+%% emergency = E2,
+%% priority = P2}) ->
+%% validate(fun() -> chk_opt_NULL(T1, T2) end,
+%% 'ContextAttrAuditRequest_topology'),
+%% validate(fun() -> chk_opt_NULL(E1, E2) end,
+%% 'ContextAttrAuditRequest_emergency'),
+%% validate(fun() -> chk_opt_NULL(P1, P2) end,
+%% 'ContextAttrAuditRequest_priority'),
+%% ok.
+
+
+%% %% -- CommandRequest --
+
+%% is_CommandRequest(#'CommandRequest'{command = Cmd,
+%% optional = Opt,
+%% wildcardReturn = WR}) ->
+%% is_Command(Cmd) andalso is_opt_NULL(Opt) andalso is_opt_NULL(WR);
+%% is_CommandRequest(_) ->
+%% false.
+
+%% chk_CommandRequest(C, C) ->
+%% chk_type(fun is_CommandRequest/1, 'CommandRequest', C);
+%% chk_CommandRequest(#'CommandRequest'{command = Cmd1,
+%% optional = Opt1,
+%% wildcardReturn = WR1},
+%% #'CommandRequest'{command = Cmd2,
+%% optional = Opt2,
+%% wildcardReturn = WR2}) ->
+%% validate(fun() -> chk_Command(Cmd1, Cmd2) end, 'CommandRequest'),
+%% validate(fun() -> chk_opt_NULL(Opt1, Opt2) end, 'CommandRequest'),
+%% validate(fun() -> chk_opt_NULL(WR1, WR2) end, 'CommandRequest'),
+%% ok;
+%% chk_CommandRequest(R1, R2) ->
+%% wrong_type('CommandRequest', R1, R2).
+
+
+%% %% -- Command --
+
+%% is_Command({Tag, Val}) ->
+%% is_Command_tag(Tag) andalso is_Command_val(Tag, Val);
+%% is_Command(_) ->
+%% false.
+
+%% is_Command_tag(Tag) ->
+%% Tags = [addReq, moveReq, modReq, subtractReq, auditCapRequest,
+%% auditValueRequest, notifyReq, serviceChangeReq],
+%% lists:member(Tag, Tags).
+
+%% is_Command_val(addReq, V) -> is_AmmRequest(V);
+%% is_Command_val(moveReq, V) -> is_AmmRequest(V);
+%% is_Command_val(modReq, V) -> is_AmmRequest(V);
+%% is_Command_val(subtractReq, V) -> is_SubtractRequest(V);
+%% is_Command_val(auditCapRequest, V) -> is_AuditRequest(V);
+%% is_Command_val(auditValueRequest, V) -> is_AuditRequest(V);
+%% is_Command_val(notifyReq, V) -> is_NotifyRequest(V);
+%% is_Command_val(serviceChangeReq, V) -> is_ServiceChangeRequest(V).
+
+%% chk_Command(Cmd, Cmd) ->
+%% chk_type(fun is_Command/1, 'Command', Cmd);
+%% chk_Command({Tag, Val1} = Cmd1, {Tag, Val2} = Cmd2) ->
+%% case (is_Command_tag(Tag) andalso
+%% is_Command_val(Tag, Val1) andalso
+%% is_Command_val(Tag, Val2)) of
+%% true ->
+%% chk_Command_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('Command', Cmd1, Cmd2)
+%% end;
+%% chk_Command({Tag1, Val1} = Cmd1, {Tag2, Val2} = Cmd2) ->
+%% case ((is_Command_tag(Tag1) andalso is_Command_val(Tag1, Val1)) andalso
+%% (is_Command_tag(Tag2) andalso is_Command_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('Command', Cmd1, Cmd2);
+%% false ->
+%% wrong_type('Command', Cmd1, Cmd2)
+%% end;
+%% chk_Command(Cmd1, Cmd2) ->
+%% wrong_type('Command', Cmd1, Cmd2).
+
+
+%% chk_Command_val(addReq, R1, R2) ->
+%% validate(fun() -> chk_AmmRequest(R1, R2) end, 'Command_addReq');
+%% chk_Command_val(moveReq, R1, R2) ->
+%% validate(fun() -> chk_AmmRequest(R1, R2) end, 'Command_moveReq');
+%% chk_Command_val(modReq, R1, R2) ->
+%% validate(fun() -> chk_AmmRequest(R1, R2) end, 'Command_modReq');
+%% chk_Command_val(subtractReq, R1, R2) ->
+%% validate(fun() -> chk_SubtractRequest(R1, R2) end, 'Command_subtractReq');
+%% chk_Command_val(auditCapRequest, R1, R2) ->
+%% validate(fun() -> chk_AuditRequest(R1, R2) end, 'Command_auditCapRequest');
+%% chk_Command_val(auditValueRequest, R1, R2) ->
+%% validate(fun() -> chk_AuditRequest(R1, R2) end,
+%% 'Command_auditValueRequest');
+%% chk_Command_val(notifyReq, R1, R2) ->
+%% validate(fun() -> chk_NotifyRequest(R1, R2) end, 'Command_notifyReq');
+%% chk_Command_val(serviceChangeReq, R1, R2) ->
+%% validate(fun() -> chk_ServiceChangeRequest(R1, R2) end,
+%% 'Command_serviceChangeReq').
+
+
+%% %% -- CommandReply --
+
+%% is_CommandReply({Tag, Val}) ->
+%% is_CommandReply_tag(Tag) andalso is_CommandReply_val(Tag, Val);
+%% is_CommandReply(_) ->
+%% false.
+
+%% is_CommandReply_tag(Tag) ->
+%% Tags = [addReply, moveReply, modReply, subtractReply,
+%% auditCapReply, auditValueReply, notifyReply, serviceChangeReply],
+%% lists:member(Tag, Tags).
+
+%% is_CommandReply_val(addReply, V) -> is_AmmsReply(V);
+%% is_CommandReply_val(moveReply, V) -> is_AmmsReply(V);
+%% is_CommandReply_val(modReply, V) -> is_AmmsReply(V);
+%% is_CommandReply_val(subtractReply, V) -> is_AmmsReply(V);
+%% is_CommandReply_val(auditCapReply, V) -> is_AuditReply(V);
+%% is_CommandReply_val(auditValueReply, V) -> is_AuditReply(V);
+%% is_CommandReply_val(notifyReply, V) -> is_NotifyReply(V);
+%% is_CommandReply_val(serviceChangeReply, V) -> is_ServiceChangeReply(V).
+
+%% chk_CommandReply({Tag, Val} = Cmd, Cmd) ->
+%% case (is_CommandReply_tag(Tag) andalso is_CommandReply_val(Tag, Val)) of
+%% true ->
+%% ok;
+%% false ->
+%% wrong_type('CommandReply', Cmd)
+%% end;
+%% chk_CommandReply({Tag, Val1} = Cmd1, {Tag, Val2} = Cmd2) ->
+%% case (is_CommandReply_tag(Tag) andalso
+%% is_CommandReply_val(Tag, Val1) andalso
+%% is_CommandReply_val(Tag, Val2)) of
+%% true ->
+%% chk_CommandReply_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('CommandReply', Cmd1, Cmd2)
+%% end;
+%% chk_CommandReply({Tag1, Val1} = Cmd1, {Tag2, Val2} = Cmd2) ->
+%% case ((is_CommandReply_tag(Tag1) andalso
+%% is_CommandReply_val(Tag1, Val1)) andalso
+%% (is_CommandReply_tag(Tag2) andalso
+%% is_CommandReply_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('CommandReply', Cmd1, Cmd2);
+%% false ->
+%% wrong_type('CommandReply', Cmd1, Cmd2)
+%% end;
+%% chk_CommandReply(Cmd1, Cmd2) ->
+%% wrong_type('CommandReply', Cmd1, Cmd2).
+
+%% chk_CommandReply_val(addReply, V1, V2) ->
+%% validate(fun() -> chk_AmmsReply(V1, V2) end, 'CommandReply_addReply');
+%% chk_CommandReply_val(moveReply, V1, V2) ->
+%% validate(fun() -> chk_AmmsReply(V1, V2) end, 'CommandReply_moveReply');
+%% chk_CommandReply_val(modReply, V1, V2) ->
+%% validate(fun() -> chk_AmmsReply(V1, V2) end, 'CommandReply_modReply');
+%% chk_CommandReply_val(subtractReply, V1, V2) ->
+%% validate(fun() -> chk_AmmsReply(V1, V2) end, 'CommandReply_subtractReply');
+%% chk_CommandReply_val(auditCapReply, V1, V2) ->
+%% validate(fun() -> chk_AuditReply(V1, V2) end,
+%% 'CommandReply_auditCapReply');
+%% chk_CommandReply_val(auditValueReply, V1, V2) ->
+%% validate(fun() -> chk_AuditReply(V1, V2) end,
+%% 'CommandReply_auditValueReply');
+%% chk_CommandReply_val(notifyReply, V1, V2) ->
+%% validate(fun() -> chk_NotifyReply(V1, V2) end, 'CommandReply_notifyReply');
+%% chk_CommandReply_val(serviceChangeReply, V1, V2) ->
+%% validate(fun() -> chk_ServiceChangeReply(V1, V2) end,
+%% 'CommandReply_serviceChangeReply').
+
+
+%% %% -- TopologyRequest --
+
+%% is_TopologyRequest(#'TopologyRequest'{terminationFrom = F,
+%% terminationTo = T,
+%% topologyDirection = D,
+%% streamID = S}) ->
+%% is_TerminationID(F) andalso
+%% is_TerminationID(T) andalso
+%% is_TopologyRequest_topologyDirection(D) andalso
+%% is_opt_StreamID(S);
+%% is_TopologyRequest(_) ->
+%% false.
+
+%% is_TopologyRequest_topologyDirection(D) ->
+%% lists:member(D, [bothway, isolate, oneway]).
+
+
+%% chk_TopologyRequest(T, T) when record(T,'TopologyRequest') ->
+%% ok;
+%% chk_TopologyRequest(#'TopologyRequest'{terminationFrom = F1,
+%% terminationTo = T1,
+%% topologyDirection = D1,
+%% streamID = S1},
+%% #'TopologyRequest'{terminationFrom = F2,
+%% terminationTo = T2,
+%% topologyDirection = D2,
+%% streamID = S2}) ->
+%% validate(fun() -> chk_TerminationID(F1, F2) end,
+%% 'TopologyRequest_terminationFrom'),
+%% validate(fun() -> chk_TerminationID(T1, T2) end,
+%% 'TopologyRequest_terminationTo'),
+%% chk_TopologyRequest_topologyDirection(D1,D2),
+%% validate(fun() -> chk_StreamID(S1, S2) end, 'TopologyRequest_streamID'),
+%% ok.
+
+%% chk_TopologyRequest_topologyDirection(D, D) ->
+%% case is_TopologyRequest_topologyDirection(D) of
+%% true ->
+%% ok;
+%% false ->
+%% wrong_type('TopologyRequest_topologyDirection', D)
+%% end;
+%% chk_TopologyRequest_topologyDirection(D1, D2) ->
+%% case (is_TopologyRequest_topologyDirection(D1) andalso
+%% is_TopologyRequest_topologyDirection(D1)) of
+%% true ->
+%% not_equal('TopologyRequest_topologyDirection', D1, D2);
+%% false ->
+%% wrong_type('TopologyRequest_topologyDirection', D1, D2)
+%% end.
+
+
+%% %% -- AmmRequest --
+
+%% is_AmmRequest(#'AmmRequest'{terminationID = Tids,
+%% descriptors = Descs}) ->
+%% d("is_AmmRequest -> entry with"
+%% "~n Tids: ~p", [Tids]),
+%% is_TerminationIDList(Tids) andalso is_AmmRequest_descriptors(Descs);
+%% is_AmmRequest(_) ->
+%% false.
+
+%% is_AmmRequest_descriptors(Descs) ->
+%% is_AmmRequest_descriptors(Descs, []).
+
+%% is_AmmRequest_descriptors([], _) ->
+%% true;
+%% is_AmmRequest_descriptors([{Tag, _} = Desc|Descs], FoundDescs) ->
+%% d("is_AmmRequest_descriptors -> entry with"
+%% "~n Tag: ~p"
+%% "~n FoundDescs: ~p", [Tag, FoundDescs]),
+%% case lists:member(Tag, FoundDescs) of
+%% true ->
+%% atmost_once('AmmRequest_descriptors', Tag);
+%% false ->
+%% case is_AmmDescriptor(Desc) of
+%% true ->
+%% is_AmmRequest_descriptors(Descs, [Tag|FoundDescs]);
+%% false ->
+%% wrong_type('AmmRequest_descriptors', Desc)
+%% end
+%% end;
+%% is_AmmRequest_descriptors(Descs, _) ->
+%% d("is_AmmRequest_descriptors -> entry with WRONG TYPE"
+%% "~n Descs: ~p", [Descs]),
+%% wrong_type('AmmRequest_descriptors', Descs).
+
+
+%% chk_AmmRequest(R, R) when record(R, 'AmmRequest') ->
+%% d("chk_AmmRequest -> entry when equal"),
+%% chk_type(fun is_AmmRequest/1, 'AmmRequest', R);
+%% chk_AmmRequest(#'AmmRequest'{terminationID = Tids1,
+%% descriptors = Descs1},
+%% #'AmmRequest'{terminationID = Tids2,
+%% descriptors = Descs2}) ->
+%% d("chk_AmmRequest -> entry with not equal"
+%% "~n Tids1: ~p"
+%% "~n Tids2: ~p", [Tids1, Tids2]),
+%% validate(
+%% fun() -> chk_TerminationIDList(Tids1, Tids2) end,
+%% 'AmmRequest'),
+%% validate(
+%% fun() -> chk_AmmRequest_descriptors(Descs1, Descs2) end,
+%% 'AmmRequest'),
+%% ok.
+
+
+%% chk_AmmRequest_descriptors([], []) ->
+%% d("chk_AmmRequest_descriptors -> done when OK"),
+%% ok;
+%% chk_AmmRequest_descriptors([] = Descs1, Descs2) ->
+%% d("chk_AmmRequest_descriptors -> done when NOT EQUAL:"
+%% "~n Descs1: ~p"
+%% "~n Descs1: ~p", [Descs1, Descs2]),
+%% not_equal('AmmRequest_descriptors', Descs1, Descs2);
+%% chk_AmmRequest_descriptors(Descs1, [] = Descs2) ->
+%% d("chk_AmmRequest_descriptors -> done when NOT EQUAL:"
+%% "~n Descs1: ~p"
+%% "~n Descs1: ~p", [Descs1, Descs2]),
+%% not_equal('AmmRequest_descriptors', Descs1, Descs2);
+%% chk_AmmRequest_descriptors([H|T1], [H|T2]) ->
+%% d("chk_AmmRequest_descriptors -> entry when equal"),
+%% case is_AmmDescriptor(H) of
+%% true ->
+%% chk_AmmRequest_descriptors(T1, T2);
+%% false ->
+%% wrong_type('AmmRequest_descriptors_val', H)
+%% end;
+%% chk_AmmRequest_descriptors([H1|T1], [H2|T2]) ->
+%% d("chk_AmmRequest_descriptors -> entry when not equal"),
+%% validate(fun() -> chk_AmmDescriptor(H1, H2) end,
+%% 'AmmRequest_descriptors_val'),
+%% chk_AmmRequest_descriptors(T1, T2);
+%% chk_AmmRequest_descriptors(Descs1, Descs2) ->
+%% d("chk_AmmRequest_descriptors -> done when WRONG TYPE:"
+%% "~n Descs1: ~p"
+%% "~n Descs1: ~p", [Descs1, Descs2]),
+%% wrong_type('AmmRequest_descriptors', Descs1, Descs2).
+
+
+%% %% -- AmmDescriptor --
+
+%% is_AmmDescriptor({Tag, Val}) ->
+%% d("is_AmmDescriptor -> entry with"
+%% "~n Tag: ~p"
+%% "~n Val: ~p",[Tag, Val]),
+%% is_AmmDescriptor_tag(Tag) andalso is_AmmDescriptor_val(Tag, Val);
+%% is_AmmDescriptor(_) ->
+%% false.
+
+%% is_AmmDescriptor_tag(Tag) ->
+%% Tags = [mediaDescriptor, modemDescriptor, muxDescriptor, eventsDescriptor,
+%% eventBufferDescriptor, signalsDescriptor, digitMapDescriptor,
+%% auditDescriptor],
+%% lists:member(Tag, Tags).
+
+%% is_AmmDescriptor_val(mediaDescriptor, D) ->
+%% is_MediaDescriptor(D);
+%% is_AmmDescriptor_val(modemDescriptor, D) ->
+%% is_ModemDescriptor(D);
+%% is_AmmDescriptor_val(muxDescriptor, D) ->
+%% is_MuxDescriptor(D);
+%% is_AmmDescriptor_val(eventsDescriptor, D) ->
+%% is_EventsDescriptor(D);
+%% is_AmmDescriptor_val(eventBufferDescriptor, D) ->
+%% is_EventBufferDescriptor(D);
+%% is_AmmDescriptor_val(signalsDescriptor, D) ->
+%% is_SignalsDescriptor(D);
+%% is_AmmDescriptor_val(digitMapDescriptor, D) ->
+%% is_DigitMapDescriptor(D);
+%% is_AmmDescriptor_val(auditDescriptor, D) ->
+%% is_AuditDescriptor(D).
+
+%% chk_AmmDescriptor(D, D) ->
+%% chk_type(fun is_AmmDescriptor_tag/1, 'AmmDescriptor', D);
+%% chk_AmmDescriptor({Tag, Val1} = Cmd1, {Tag, Val2} = Cmd2) ->
+%% case (is_AmmDescriptor_tag(Tag) andalso
+%% is_AmmDescriptor_val(Tag, Val1) andalso
+%% is_AmmDescriptor_val(Tag, Val2)) of
+%% true ->
+%% chk_AmmDescriptor_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('AmmDescriptor', Cmd1, Cmd2)
+%% end;
+%% chk_AmmDescriptor({Tag1, Val1} = Cmd1, {Tag2, Val2} = Cmd2) ->
+%% case ((is_AmmDescriptor_tag(Tag1) andalso
+%% is_AmmDescriptor_val(Tag1, Val1)) andalso
+%% (is_AmmDescriptor_tag(Tag2) andalso
+%% is_AmmDescriptor_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('AmmDescriptor', Cmd1, Cmd2);
+%% false ->
+%% wrong_type('AmmDescriptor', Cmd1, Cmd2)
+%% end;
+%% chk_AmmDescriptor(Cmd1, Cmd2) ->
+%% wrong_type('AmmDescriptor', Cmd1, Cmd2).
+
+%% chk_AmmDescriptor_val(mediaDescriptor, D1, D2) ->
+%% validate(fun() -> chk_MediaDescriptor(D1, D2) end, 'AmmDescriptor');
+%% chk_AmmDescriptor_val(modemDescriptor, D1, D2) ->
+%% validate(fun() -> chk_ModemDescriptor(D1, D2) end, 'AmmDescriptor');
+%% chk_AmmDescriptor_val(muxDescriptor, D1, D2) ->
+%% validate(fun() -> chk_MuxDescriptor(D1, D2) end, 'AmmDescriptor');
+%% chk_AmmDescriptor_val(eventsDescriptor, D1, D2) ->
+%% validate(fun() -> chk_EventsDescriptor(D1, D2) end, 'AmmDescriptor');
+%% chk_AmmDescriptor_val(eventBufferDescriptor, D1, D2) ->
+%% validate(fun() -> chk_EventBufferDescriptor(D1, D2) end, 'AmmDescriptor');
+%% chk_AmmDescriptor_val(signalsDescriptor, D1, D2) ->
+%% validate(fun() -> chk_SignalsDescriptor(D1, D2) end, 'AmmDescriptor');
+%% chk_AmmDescriptor_val(digitMapDescriptor, D1, D2) ->
+%% validate(fun() -> chk_DigitMapDescriptor(D1, D2) end, 'AmmDescriptor');
+%% chk_AmmDescriptor_val(auditDescriptor, D1, D2) ->
+%% validate(fun() -> chk_AuditDescriptor(D1, D2) end, 'AmmDescriptor').
+
+
+%% %% -- AmmsReply --
+
+%% is_AmmsReply(#'AmmsReply'{terminationID = Tids,
+%% terminationAudit = TA}) ->
+%% is_TerminationIDList(Tids) andalso is_opt_TerminationAudit(TA);
+%% is_AmmsReply(_) ->
+%% false.
+
+%% chk_AmmsReply(R, R) ->
+%% is_AmmsReply(R);
+%% chk_AmmsReply(#'AmmsReply'{terminationID = TID1,
+%% terminationAudit = TA1},
+%% #'AmmsReply'{terminationID = TID2,
+%% terminationAudit = TA2}) ->
+%% validate(fun() -> chk_TerminationIDList(TID1, TID2) end, 'AmmsReply'),
+%% validate(fun() -> chk_opt_TerminationAudit(TA1, TA2) end, 'AmmsReply'),
+%% ok;
+%% chk_AmmsReply(R1, R2) ->
+%% wrong_type('AmmsReply', R1, R2).
+
+
+%% %% -- SubtractRequest --
+
+%% is_SubtractRequest(#'SubtractRequest'{terminationID = Tids,
+%% auditDescriptor = AD}) ->
+%% is_TerminationIDList(Tids) andalso is_opt_AuditDescriptor(AD);
+%% is_SubtractRequest(_) ->
+%% false.
+
+%% chk_SubtractRequest(R, R) ->
+%% chk_type(fun is_SubtractRequest/1, 'SubtractRequest', R);
+%% chk_SubtractRequest(#'SubtractRequest'{terminationID = Tids1,
+%% auditDescriptor = AD1},
+%% #'SubtractRequest'{terminationID = Tids2,
+%% auditDescriptor = AD2}) ->
+%% validate(fun() -> chk_TerminationIDList(Tids1, Tids2) end,
+%% 'SubtractRequest'),
+%% validate(fun() -> chk_opt_AuditDescriptor(AD1, AD2) end,
+%% 'SubtractRequest'),
+%% ok;
+%% chk_SubtractRequest(SR1, SR2) ->
+%% wrong_type('SubtractRequest', SR1, SR2).
+
+
+%% %% -- AuditRequest --
+
+%% is_AuditRequest(#'AuditRequest'{terminationID = Tid,
+%% auditDescriptor = AD}) ->
+%% is_TerminationID(Tid) andalso is_AuditDescriptor(AD);
+%% is_AuditRequest(_) ->
+%% false.
+
+%% chk_AuditRequest(R, R) ->
+%% chk_type(fun is_AuditRequest/1, 'AuditRequest', R);
+%% chk_AuditRequest(#'AuditRequest'{terminationID = Tids1,
+%% auditDescriptor = AD1},
+%% #'AuditRequest'{terminationID = Tids2,
+%% auditDescriptor = AD2}) ->
+%% validate(fun() -> chk_TerminationID(Tids1, Tids2) end,
+%% 'AuditRequest'),
+%% validate(fun() -> chk_AuditDescriptor(AD1, AD2) end,
+%% 'AuditRequest'),
+%% ok;
+%% chk_AuditRequest(AR1, AR2) ->
+%% wrong_type('AuditRequest', AR1, AR2).
+
+
+%% %% -- AuditReply --
+
+%% is_AuditReply({Tag, Val}) ->
+%% is_AuditReply_tag(Tag) andalso is_AuditReply_val(Tag, Val);
+%% is_AuditReply(_) ->
+%% false.
+
+%% is_AuditReply_tag(Tag) ->
+%% Tags = [contextAuditResult, error, auditResult],
+%% lists:member(Tag, Tags).
+
+%% is_AuditReply_val(contextAuditResult, Val) ->
+%% is_TerminationIDList(Val);
+%% is_AuditReply_val(error, Val) ->
+%% is_ErrorDescriptor(Val);
+%% is_AuditReply_val(auditResult, Val) ->
+%% is_AuditResult(Val).
+
+%% chk_AuditReply(R, R) ->
+%% chk_type(fun is_AuditReply/1, 'AuditReply', R);
+%% chk_AuditReply({Tag, Val1} = R1, {Tag, Val2} = R2) ->
+%% case (is_AuditReply_tag(Tag) andalso
+%% is_AuditReply_val(Tag, Val1)andalso
+%% is_AuditReply_val(Tag, Val2)) of
+%% true ->
+%% chk_AuditReply_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('AuditReply', R1, R2)
+%% end;
+%% chk_AuditReply({Tag1, Val1} = R1, {Tag2, Val2} = R2) ->
+%% case ((is_AuditReply_tag(Tag1) andalso
+%% is_AuditReply_val(Tag1, Val1)) andalso
+%% (is_AuditReply_tag(Tag2) andalso
+%% is_AuditReply_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('AuditReply', R1, R2);
+%% false ->
+%% wrong_type('AuditReply', R1, R2)
+%% end;
+%% chk_AuditReply(AR1, AR2) ->
+%% wrong_type('AuditReply', AR1, AR2).
+
+%% chk_AuditReply_val(contextAuditResult, Val1, Val2) ->
+%% chk_TerminationIDList(Val1, Val2);
+%% chk_AuditReply_val(error, Val1, Val2) ->
+%% chk_ErrorDescriptor(Val1, Val2);
+%% chk_AuditReply_val(auditResult, Val1, Val2) ->
+%% chk_AuditResult(Val1, Val2).
+
+
+%% %% -- AuditResult --
+
+%% is_AuditResult(#'AuditResult'{terminationID = TID,
+%% terminationAuditResult = TAR}) ->
+%% is_TerminationID(TID) andalso is_TerminationAudit(TAR);
+%% is_AuditResult(_) ->
+%% false.
+
+%% chk_AuditResult(R, R) ->
+%% chk_type(fun is_AuditResult/1, 'AuditResult', R);
+%% chk_AuditResult(#'AuditResult'{terminationID = TID1,
+%% terminationAuditResult = TAR1},
+%% #'AuditResult'{terminationID = TID2,
+%% terminationAuditResult = TAR2}) ->
+%% validate(fun() -> chk_TerminationID(TID1, TID2) end, 'AuditResult'),
+%% validate(fun() -> chk_TerminationAudit(TAR1, TAR2) end, 'AuditResult'),
+%% ok;
+%% chk_AuditResult(AR1, AR2) ->
+%% wrong_type('AuditResult', AR1, AR2).
+
+
+%% %% -- TerminationAudit --
+
+%% is_opt_TerminationAudit(TA) ->
+%% is_OPTIONAL(fun is_TerminationAudit/1, TA).
+
+%% is_TerminationAudit([]) ->
+%% true;
+%% is_TerminationAudit([H|T]) ->
+%% is_AuditReturnParameter(H) andalso is_TerminationAudit(T);
+%% is_TerminationAudit(_) ->
+%% false.
+
+%% chk_opt_TerminationAudit(TA1, TA2) ->
+%% chk_OPTIONAL('TerminationAudit', TA1, TA2,
+%% fun is_TerminationAudit/1, fun chk_TerminationAudit/2).
+
+%% chk_TerminationAudit([], []) ->
+%% ok;
+%% chk_TerminationAudit([] = TA1, TA2) ->
+%% not_equal('TerminationAudit', TA1, TA2);
+%% chk_TerminationAudit(TA1, [] = TA2) ->
+%% not_equal('TerminationAudit', TA1, TA2);
+%% chk_TerminationAudit([H|T1], [H|T2]) ->
+%% case is_AuditReturnParameter(H) of
+%% true ->
+%% chk_TerminationAudit(T1, T2);
+%% false ->
+%% wrong_type('TerminationAudit', H)
+%% end;
+%% chk_TerminationAudit([H1|_], [H2|_]) ->
+%% chk_AuditReturnParameter(H1, H2),
+%% not_equal('TerminationAudit_val', H1, H2);
+%% chk_TerminationAudit(TA1, TA2) ->
+%% not_equal('TerminationAudit', TA1, TA2).
+
+
+%% %% -- AuditReturnParameter --
+
+%% is_AuditReturnParameter({Tag, Val}) ->
+%% is_AuditReturnParameter_tag(Tag) andalso
+%% is_AuditReturnParameter_val(Tag, Val);
+%% is_AuditReturnParameter(_) ->
+%% false.
+
+%% is_AuditReturnParameter_tag(Tag) ->
+%% Tags = [errorDescriptor,
+%% mediaDescriptor,
+%% modemDescriptor,
+%% muxDescriptor,
+%% eventsDescriptor,
+%% eventBufferDescriptor,
+%% signalsDescriptor,
+%% digitMapDescriptor,
+%% observedEventsDescriptor,
+%% statisticsDescriptor,
+%% packagesDescriptor,
+%% emptyDescriptors],
+%% lists:member(Tag, Tags).
+
+%% is_AuditReturnParameter_val(errorDescriptor, V) ->
+%% is_ErrorDescriptor(V);
+%% is_AuditReturnParameter_val(mediaDescriptor, V) ->
+%% is_MediaDescriptor(V);
+%% is_AuditReturnParameter_val(modemDescriptor, V) ->
+%% is_ModemDescriptor(V);
+%% is_AuditReturnParameter_val(muxDescriptor, V) ->
+%% is_MuxDescriptor(V);
+%% is_AuditReturnParameter_val(eventsDescriptor, V) ->
+%% is_EventsDescriptor(V);
+%% is_AuditReturnParameter_val(eventBufferDescriptor, V) ->
+%% is_EventBufferDescriptor(V);
+%% is_AuditReturnParameter_val(signalsDescriptor, V) ->
+%% is_SignalsDescriptor(V);
+%% is_AuditReturnParameter_val(digitMapDescriptor, V) ->
+%% is_DigitMapDescriptor(V);
+%% is_AuditReturnParameter_val(observedEventsDescriptor, V) ->
+%% is_ObservedEventsDescriptor(V);
+%% is_AuditReturnParameter_val(statisticsDescriptor, V) ->
+%% is_StatisticsDescriptor(V);
+%% is_AuditReturnParameter_val(packagesDescriptor, V) ->
+%% is_PackagesDescriptor(V);
+%% is_AuditReturnParameter_val(emptyDescriptors, V) ->
+%% is_AuditDescriptor(V).
+
+%% chk_AuditReturnParameter(ARP, ARP) ->
+%% chk_type(fun is_AuditReturnParameter/1, 'AuditReturnParameter', ARP);
+%% chk_AuditReturnParameter({Tag, Val1} = ARP1, {Tag, Val2} = ARP2) ->
+%% case (is_AuditReturnParameter_tag(Tag) andalso
+%% is_AuditReturnParameter_val(Tag, Val1) andalso
+%% is_AuditReturnParameter_val(Tag, Val2)) of
+%% true ->
+%% chk_AuditReturnParameter_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('AuditReturnParameter', ARP1, ARP2)
+%% end;
+%% chk_AuditReturnParameter({Tag1, Val1} = ARP1, {Tag2, Val2} = ARP2) ->
+%% case ((is_AuditReturnParameter_tag(Tag1) andalso
+%% is_AuditReturnParameter_val(Tag1, Val1)) andalso
+%% (is_AuditReturnParameter_tag(Tag2) andalso
+%% is_AuditReturnParameter_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('AuditReturnParameter', ARP1, ARP2);
+%% false ->
+%% wrong_type('AuditReturnParameter', ARP1, ARP2)
+%% end;
+%% chk_AuditReturnParameter(ARP1, ARP2) ->
+%% wrong_type('AuditReturnParameter', ARP1, ARP2).
+
+%% chk_AuditReturnParameter_val(errorDescriptor, V1, V2) ->
+%% validate(fun() -> chk_ErrorDescriptor(V1, V2) end,
+%% 'AuditReturnParameter');
+%% chk_AuditReturnParameter_val(mediaDescriptor, V1, V2) ->
+%% validate(fun() -> chk_MediaDescriptor(V1, V2) end,
+%% 'AuditReturnParameter');
+%% chk_AuditReturnParameter_val(modemDescriptor, V1, V2) ->
+%% validate(fun() -> chk_ModemDescriptor(V1, V2) end,
+%% 'AuditReturnParameter');
+%% chk_AuditReturnParameter_val(muxDescriptor, V1, V2) ->
+%% validate(fun() -> chk_MuxDescriptor(V1, V2) end,
+%% 'AuditReturnParameter');
+%% chk_AuditReturnParameter_val(eventsDescriptor, V1, V2) ->
+%% validate(fun() -> chk_EventsDescriptor(V1, V2) end,
+%% 'AuditReturnParameter');
+%% chk_AuditReturnParameter_val(eventBufferDescriptor, V1, V2) ->
+%% validate(fun() -> chk_EventBufferDescriptor(V1, V2) end,
+%% 'AuditReturnParameter');
+%% chk_AuditReturnParameter_val(signalsDescriptor, V1, V2) ->
+%% validate(fun() -> chk_SignalsDescriptor(V1, V2) end,
+%% 'AuditReturnParameter');
+%% chk_AuditReturnParameter_val(digitMapDescriptor, V1, V2) ->
+%% validate(fun() -> chk_DigitMapDescriptor(V1, V2) end,
+%% 'AuditReturnParameter');
+%% chk_AuditReturnParameter_val(observedEventsDescriptor, V1, V2) ->
+%% validate(fun() -> chk_ObservedEventsDescriptor(V1, V2) end,
+%% 'AuditReturnParameter');
+%% chk_AuditReturnParameter_val(statisticsDescriptor, V1, V2) ->
+%% validate(fun() -> chk_StatisticsDescriptor(V1, V2) end,
+%% 'AuditReturnParameter');
+%% chk_AuditReturnParameter_val(packagesDescriptor, V1, V2) ->
+%% validate(fun() -> chk_PackagesDescriptor(V1, V2) end,
+%% 'AuditReturnParameter');
+%% chk_AuditReturnParameter_val(emptyDescriptors, V1, V2) ->
+%% validate(fun() -> chk_AuditDescriptor(V1, V2) end,
+%% 'AuditReturnParameter').
+
+
+%% %% -- AuditDescriptor --
+
+%% is_opt_AuditDescriptor(asn1_NOVALUE) ->
+%% true;
+%% is_opt_AuditDescriptor(V) ->
+%% is_AuditDescriptor(V).
+
+%% is_AuditDescriptor(#'AuditDescriptor'{auditToken = AT,
+%% auditPropertyToken = APT}) ->
+%% is_AuditDescriptor_auditToken(AT) andalso
+%% is_AuditDescriptor_auditPropertyToken(APT);
+%% is_AuditDescriptor(_) ->
+%% false.
+
+%% is_AuditDescriptor_auditToken(asn1_NOVALUE) ->
+%% true;
+%% is_AuditDescriptor_auditToken([]) ->
+%% true;
+%% is_AuditDescriptor_auditToken([H|T]) ->
+%% is_AuditDescriptor_auditToken_val(H) andalso
+%% is_AuditDescriptor_auditToken(T);
+%% is_AuditDescriptor_auditToken(_) ->
+%% false.
+
+%% is_AuditDescriptor_auditToken_val(V) ->
+%% Toks = [muxToken, modemToken, mediaToken, eventsToken, signalsToken,
+%% digitMapToken, statsToken, observedEventsToken,
+%% packagesToken, eventBufferToken],
+%% lists:member(V, Toks).
+
+%% is_AuditDescriptor_auditPropertyToken(asn1_NOVALUE) ->
+%% true;
+%% is_AuditDescriptor_auditPropertyToken([]) ->
+%% true;
+%% is_AuditDescriptor_auditPropertyToken([H|T]) ->
+%% is_IndAuditParameter(H) andalso is_AuditDescriptor_auditPropertyToken(T);
+%% is_AuditDescriptor_auditPropertyToken(_) ->
+%% false.
+
+%% chk_opt_AuditDescriptor(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_AuditDescriptor(AD1, AD2) ->
+%% chk_AuditDescriptor(AD1, AD2).
+
+%% chk_AuditDescriptor(AD, AD) ->
+%% chk_type(fun is_AuditDescriptor/1, 'AuditDescriptor', AD);
+%% chk_AuditDescriptor(#'AuditDescriptor'{auditToken = AT1,
+%% auditPropertyToken = APT1},
+%% #'AuditDescriptor'{auditToken = AT2,
+%% auditPropertyToken = APT2}) ->
+%% chk_AuditDescriptor_auditToken(AT1, AT2),
+%% chk_AuditDescriptor_auditPropertyToken(APT1, APT2),
+%% ok;
+%% chk_AuditDescriptor(AD1, AD2) ->
+%% wrong_type('AuditDescriptor', AD1, AD2).
+
+%% chk_AuditDescriptor_auditToken(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_AuditDescriptor_auditToken([], []) ->
+%% ok;
+%% chk_AuditDescriptor_auditToken([] = AT1, AT2) ->
+%% not_equal('AuditDescriptor_auditToken', AT1, AT2);
+%% chk_AuditDescriptor_auditToken(AT1, [] = AT2) ->
+%% not_equal('AuditDescriptor_auditToken', AT1, AT2);
+%% chk_AuditDescriptor_auditToken([H|T1], [H|T2]) ->
+%% case is_AuditDescriptor_auditToken_val(H) of
+%% true ->
+%% chk_AuditDescriptor_auditToken(T1, T2);
+%% false ->
+%% wrong_type('AuditDescriptor_auditToken_val', H)
+%% end;
+%% chk_AuditDescriptor_auditToken([H1|_T1], [H2|_T2]) ->
+%% case (is_AuditDescriptor_auditToken_val(H1) andalso
+%% is_AuditDescriptor_auditToken_val(H2)) of
+%% true ->
+%% not_equal('AuditDescriptor_auditToken_val', H1, H2);
+%% false ->
+%% wrong_type('AuditDescriptor_auditToken_val', H1, H2)
+%% end;
+%% chk_AuditDescriptor_auditToken(AT1, AT2) ->
+%% wrong_type('AuditDescriptor_auditToken', AT1, AT2).
+
+%% chk_AuditDescriptor_auditPropertyToken(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_AuditDescriptor_auditPropertyToken([], []) ->
+%% ok;
+%% chk_AuditDescriptor_auditPropertyToken([] = AT1, AT2) ->
+%% not_equal('AuditDescriptor_auditPropertyToken', AT1, AT2);
+%% chk_AuditDescriptor_auditPropertyToken(AT1, [] = AT2) ->
+%% not_equal('AuditDescriptor_auditPropertyToken', AT1, AT2);
+%% chk_AuditDescriptor_auditPropertyToken([H|T1], [H|T2]) ->
+%% case is_IndAuditParameter(H) of
+%% true ->
+%% chk_AuditDescriptor_auditPropertyToken(T1, T2);
+%% false ->
+%% wrong_type('AuditDescriptor_auditPropertyToken_val', H)
+%% end;
+%% chk_AuditDescriptor_auditPropertyToken([H1|_], [H2|_]) ->
+%% chk_IndAuditParameter(H1, H2),
+%% not_equal('AuditDescriptor_auditPropertyToken_val', H1, H2);
+%% chk_AuditDescriptor_auditPropertyToken(AT1, AT2) ->
+%% wrong_type('AuditDescriptor_auditPropertyToken', AT1, AT2).
+
+
+%% %% -- IndAuditParameter --
+
+%% is_IndAuditParameter({Tag, Val}) ->
+%% is_IndAuditParameter_tag(Tag) andalso is_IndAuditParameter_val(Tag, Val);
+%% is_IndAuditParameter(_) ->
+%% false.
+
+%% is_IndAuditParameter_tag(Tag) ->
+%% Tags = [indAudMediaDescriptor,
+%% indAudEventsDescriptor,
+%% indAudEventBufferDescriptor,
+%% indAudSignalsDescriptor,
+%% indAudDigitMapDescriptor,
+%% indAudStatisticsDescriptor,
+%% indAudPackagesDescriptor],
+%% lists:member(Tag, Tags).
+
+%% is_IndAuditParameter_val(indAudMediaDescriptor, Val) ->
+%% is_IndAudMediaDescriptor(Val);
+%% is_IndAuditParameter_val(indAudEventsDescriptor, Val) ->
+%% is_IndAudEventsDescriptor(Val);
+%% is_IndAuditParameter_val(indAudEventBufferDescriptor, Val) ->
+%% is_IndAudEventBufferDescriptor(Val);
+%% is_IndAuditParameter_val(indAudSignalsDescriptor, Val) ->
+%% is_IndAudSignalsDescriptor(Val);
+%% is_IndAuditParameter_val(indAudDigitMapDescriptor, Val) ->
+%% is_IndAudDigitMapDescriptor(Val);
+%% is_IndAuditParameter_val(indAudStatisticsDescriptor, Val) ->
+%% is_IndAudStatisticsDescriptor(Val);
+%% is_IndAuditParameter_val(indAudPackagesDescriptor, Val) ->
+%% is_IndAudPackagesDescriptor(Val).
+
+%% chk_IndAuditParameter(IAP, IAP) ->
+%% chk_type(fun is_IndAuditParameter/1, 'IndAuditParameter', IAP);
+%% chk_IndAuditParameter({Tag, Val1} = IAP1, {Tag, Val2} = IAP2) ->
+%% case (is_IndAuditParameter_tag(Tag) andalso
+%% is_IndAuditParameter_val(Tag, Val1) andalso
+%% is_IndAuditParameter_val(Tag, Val2)) of
+%% true ->
+%% chk_IndAuditParameter_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('IndAuditParameter', IAP1, IAP2)
+%% end;
+%% chk_IndAuditParameter({Tag1, Val1} = IAP1, {Tag2, Val2} = IAP2) ->
+%% case ((is_IndAuditParameter_tag(Tag1) andalso
+%% is_IndAuditParameter_val(Tag1, Val1)) andalso
+%% (is_IndAuditParameter_tag(Tag2) andalso
+%% is_IndAuditParameter_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('IndAuditParameter', IAP1, IAP2);
+%% false ->
+%% wrong_type('IndAuditParameter', IAP1, IAP2)
+%% end;
+%% chk_IndAuditParameter(IAP1, IAP2) ->
+%% wrong_type('IndAuditParameter', IAP1, IAP2).
+
+%% chk_IndAuditParameter_val(indAudMediaDescriptor, Val1, Val2) ->
+%% validate(fun() -> chk_IndAudMediaDescriptor(Val1, Val2) end,
+%% 'IndAuditParameter');
+%% chk_IndAuditParameter_val(indAudEventsDescriptor, Val1, Val2) ->
+%% validate(fun() -> chk_IndAudEventsDescriptor(Val1, Val2) end,
+%% 'IndAuditParameter');
+%% chk_IndAuditParameter_val(indAudEventBufferDescriptor, Val1, Val2) ->
+%% validate(fun() -> chk_IndAudEventBufferDescriptor(Val1, Val2) end,
+%% 'IndAuditParameter');
+%% chk_IndAuditParameter_val(indAudSignalsDescriptor, Val1, Val2) ->
+%% validate(fun() -> chk_IndAudSignalsDescriptor(Val1, Val2) end,
+%% 'IndAuditParameter');
+%% chk_IndAuditParameter_val(indAudDigitMapDescriptor, Val1, Val2) ->
+%% validate(fun() -> chk_IndAudDigitMapDescriptor(Val1, Val2) end,
+%% 'IndAuditParameter');
+%% chk_IndAuditParameter_val(indAudStatisticsDescriptor, Val1, Val2) ->
+%% validate(fun() -> chk_IndAudStatisticsDescriptor(Val1, Val2) end,
+%% 'IndAuditParameter');
+%% chk_IndAuditParameter_val(indAudPackagesDescriptor, Val1, Val2) ->
+%% validate(fun() -> chk_IndAudPackagesDescriptor(Val1, Val2) end,
+%% 'IndAuditParameter').
+
+
+%% %% -- IndAudMediaDescriptor --
+
+%% is_IndAudMediaDescriptor(#'IndAudMediaDescriptor'{termStateDescr = TSD,
+%% streams = S}) ->
+%% is_opt_IndAudTerminationStateDescriptor(TSD) andalso
+%% is_IndAudMediaDescriptor_streams(S);
+%% is_IndAudMediaDescriptor(_) ->
+%% false.
+
+%% is_IndAudMediaDescriptor_streams(asn1_NOVALUE) ->
+%% true;
+%% is_IndAudMediaDescriptor_streams({Tag, Val}) ->
+%% is_IndAudMediaDescriptor_streams_tag(Tag) andalso
+%% is_IndAudMediaDescriptor_streams_val(Tag, Val);
+%% is_IndAudMediaDescriptor_streams(_) ->
+%% false.
+
+%% is_IndAudMediaDescriptor_streams_tag(Tag) ->
+%% Tags = [oneStream, multiStream],
+%% lists:member(Tag, Tags).
+
+%% is_IndAudMediaDescriptor_streams_val(oneStream, Val) ->
+%% is_IndAudStreamParms(Val);
+%% is_IndAudMediaDescriptor_streams_val(multiStream, Val) ->
+%% is_IndAudMediaDescriptor_multiStream(Val).
+
+%% is_IndAudMediaDescriptor_multiStream([]) ->
+%% true;
+%% is_IndAudMediaDescriptor_multiStream([H|T]) ->
+%% is_IndAudStreamDescriptor(H) andalso
+%% is_IndAudMediaDescriptor_multiStream(T);
+%% is_IndAudMediaDescriptor_multiStream(_) ->
+%% false.
+
+%% chk_IndAudMediaDescriptor(IAMD, IAMD) ->
+%% chk_type(fun is_IndAudMediaDescriptor/1, 'IndAudMediaDescriptor', IAMD);
+%% chk_IndAudMediaDescriptor(#'IndAudMediaDescriptor'{termStateDescr = TSD1,
+%% streams = S1},
+%% #'IndAudMediaDescriptor'{termStateDescr = TSD2,
+%% streams = S2}) ->
+%% validate(fun() -> chk_opt_IndAudTerminationStateDescriptor(TSD1, TSD2) end,
+%% 'IndAudMediaDescriptor'),
+%% validate(fun() -> chk_IndAudMediaDescriptor_streams(S1, S2) end,
+%% 'IndAudMediaDescriptor'),
+%% ok;
+%% chk_IndAudMediaDescriptor(IAMD1, IAMD2) ->
+%% wrong_type('IndAudMediaDescriptor', IAMD1, IAMD2).
+
+%% chk_IndAudMediaDescriptor_streams(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_IndAudMediaDescriptor_streams({Tag, Val1} = S1,
+%% {Tag, Val2} = S2) ->
+%% case (is_IndAudMediaDescriptor_streams_tag(Tag) andalso
+%% is_IndAudMediaDescriptor_streams_val(Tag, Val1) andalso
+%% is_IndAudMediaDescriptor_streams_val(Tag, Val2)) of
+%% true ->
+%% chk_IndAudMediaDescriptor_streams_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('IndAudMediaDescriptor_streams', S1, S2)
+%% end;
+%% chk_IndAudMediaDescriptor_streams({Tag1, Val1} = S1,
+%% {Tag2, Val2} = S2) ->
+%% case ((is_IndAudMediaDescriptor_streams_tag(Tag1) andalso
+%% is_IndAudMediaDescriptor_streams_val(Tag1, Val1)) andalso
+%% (is_IndAudMediaDescriptor_streams_tag(Tag2) andalso
+%% is_IndAudMediaDescriptor_streams_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('IndAudMediaDescriptor_streams', S1, S2);
+%% false ->
+%% wrong_type('IndAudMediaDescriptor_streams', S1, S2)
+%% end;
+%% chk_IndAudMediaDescriptor_streams(S1, S2) ->
+%% wrong_type('IndAudMediaDescriptor_streams', S1, S2).
+
+%% chk_IndAudMediaDescriptor_streams_val(oneStream, Val1, Val2) ->
+%% validate(fun() -> chk_IndAudStreamParms(Val1, Val2) end,
+%% 'IndAudMediaDescriptor_streams');
+%% chk_IndAudMediaDescriptor_streams_val(multiStream, Val1, Val2) ->
+%% validate(fun() -> chk_IndAudMediaDescriptor_multiStream(Val1, Val2) end,
+%% 'IndAudMediaDescriptor_streams').
+
+%% chk_IndAudMediaDescriptor_multiStream([], []) ->
+%% ok;
+%% chk_IndAudMediaDescriptor_multiStream([] = MS1, MS2) ->
+%% not_equal('IndAudMediaDescriptor_multiStream', MS1, MS2);
+%% chk_IndAudMediaDescriptor_multiStream(MS1, [] = MS2) ->
+%% not_equal('IndAudMediaDescriptor_multiStream', MS1, MS2);
+%% chk_IndAudMediaDescriptor_multiStream([H|T1], [H|T2]) ->
+%% case is_IndAudStreamDescriptor(H) of
+%% true ->
+%% chk_IndAudMediaDescriptor_multiStream(T1, T2);
+%% false ->
+%% wrong_type('IndAudMediaDescriptor_multiStream_val', H)
+%% end;
+%% chk_IndAudMediaDescriptor_multiStream([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_IndAudStreamDescriptor(H1, H2) end,
+%% 'IndAudMediaDescriptor_multiStream_val'),
+%% chk_IndAudMediaDescriptor_multiStream(T1, T2);
+%% chk_IndAudMediaDescriptor_multiStream(MS1, MS2) ->
+%% wrong_type('IndAudMediaDescriptor_multiStream', MS1, MS2).
+
+
+%% %% -- IndAudStreamDescriptor --
+
+%% is_IndAudStreamDescriptor(#'IndAudStreamDescriptor'{streamID = SID,
+%% streamParms = Parms}) ->
+%% is_StreamID(SID) andalso is_IndAudStreamParms(Parms);
+%% is_IndAudStreamDescriptor(_) ->
+%% false.
+
+%% chk_IndAudStreamDescriptor(D, D) ->
+%% chk_type(fun is_IndAudStreamDescriptor/1, 'IndAudStreamDescriptor', D);
+%% chk_IndAudStreamDescriptor(#'IndAudStreamDescriptor'{streamID = SID1,
+%% streamParms = Parms1},
+%% #'IndAudStreamDescriptor'{streamID = SID2,
+%% streamParms = Parms2}) ->
+%% validate(fun() -> chk_StreamID(SID1, SID2) end, 'IndAudStreamDescriptor'),
+%% validate(fun() -> chk_IndAudStreamParms(Parms1, Parms2) end,
+%% 'IndAudStreamDescriptor'),
+%% ok;
+%% chk_IndAudStreamDescriptor(D1, D2) ->
+%% wrong_type('IndAudStreamDescriptor', D1, D2).
+
+
+%% %% -- IndAudStreamParms --
+
+%% is_IndAudStreamParms(#'IndAudStreamParms'{localControlDescriptor = LCD,
+%% localDescriptor = LD,
+%% remoteDescriptor = RD}) ->
+%% is_opt_IndAudLocalControlDescriptor(LCD) andalso
+%% is_opt_IndAudLocalRemoteDescriptor(LD) andalso
+%% is_opt_IndAudLocalRemoteDescriptor(RD);
+%% is_IndAudStreamParms(_) ->
+%% false.
+
+%% chk_IndAudStreamParms(#'IndAudStreamParms'{localControlDescriptor = LCD1,
+%% localDescriptor = LD1,
+%% remoteDescriptor = RD1},
+%% #'IndAudStreamParms'{localControlDescriptor = LCD2,
+%% localDescriptor = LD2,
+%% remoteDescriptor = RD2}) ->
+%% validate(fun() -> chk_opt_IndAudLocalControlDescriptor(LCD1, LCD2) end,
+%% 'IndAudStreamParms'),
+%% validate(fun() -> chk_opt_IndAudLocalRemoteDescriptor(LD1, LD2) end,
+%% 'IndAudStreamParms'),
+%% validate(fun() -> chk_opt_IndAudLocalRemoteDescriptor(RD1, RD2) end,
+%% 'IndAudStreamParms'),
+%% ok;
+%% chk_IndAudStreamParms(D1, D2) ->
+%% wrong_type('IndAudStreamParms', D1, D2).
+
+
+%% %% -- IndAudLocalControlDescriptor --
+
+%% is_opt_IndAudLocalControlDescriptor(asn1_NOVALUE) ->
+%% true;
+%% is_opt_IndAudLocalControlDescriptor(D) ->
+%% is_IndAudLocalControlDescriptor(D).
+
+%% is_IndAudLocalControlDescriptor(
+%% #'IndAudLocalControlDescriptor'{streamMode = SM,
+%% reserveValue = RV,
+%% reserveGroup = RG,
+%% propertyParms = PPs}) ->
+%% is_opt_NULL(SM) andalso is_opt_NULL(RV) andalso is_opt_NULL(RG) andalso
+%% is_IndAudLocalControlDescriptor_propertyParms(PPs);
+%% is_IndAudLocalControlDescriptor(_) ->
+%% false.
+
+%% is_IndAudLocalControlDescriptor_propertyParms(asn1_NOVALUE) ->
+%% true;
+%% is_IndAudLocalControlDescriptor_propertyParms([]) ->
+%% true;
+%% is_IndAudLocalControlDescriptor_propertyParms([H|T]) ->
+%% is_IndAudPropertyParm(H) andalso
+%% is_IndAudLocalControlDescriptor_propertyParms(T);
+%% is_IndAudLocalControlDescriptor_propertyParms(_) ->
+%% false.
+
+%% chk_opt_IndAudLocalControlDescriptor(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_IndAudLocalControlDescriptor(
+%% #'IndAudLocalControlDescriptor'{streamMode = SM1,
+%% reserveValue = RV1,
+%% reserveGroup = RG1,
+%% propertyParms = PPs1},
+%% #'IndAudLocalControlDescriptor'{streamMode = SM2,
+%% reserveValue = RV2,
+%% reserveGroup = RG2,
+%% propertyParms = PPs2}) ->
+%% chk_opt_NULL(SM1, SM2),
+%% chk_opt_NULL(RV1, RV2),
+%% chk_opt_NULL(RG1, RG2),
+%% chk_IndAudLocalControlDescriptor_propertyParms(PPs1, PPs2),
+%% ok;
+%% chk_opt_IndAudLocalControlDescriptor(D1, D2) ->
+%% wrong_type('IndAudLocalControlDescriptor', D1, D2).
+
+%% chk_IndAudLocalControlDescriptor_propertyParms(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_IndAudLocalControlDescriptor_propertyParms([], []) ->
+%% ok;
+%% chk_IndAudLocalControlDescriptor_propertyParms([] = PPs1, PPs2) ->
+%% not_equal('IndAudLocalControlDescriptor_propertyParms', PPs1, PPs2);
+%% chk_IndAudLocalControlDescriptor_propertyParms(PPs1, [] = PPs2) ->
+%% not_equal('IndAudLocalControlDescriptor_propertyParms', PPs1, PPs2);
+%% chk_IndAudLocalControlDescriptor_propertyParms([H|T1], [H|T2]) ->
+%% case is_IndAudPropertyParm(H) of
+%% true ->
+%% chk_IndAudLocalControlDescriptor_propertyParms(T1, T2);
+%% false ->
+%% wrong_type('IndAudLocalControlDescriptor_propertyParms_val', H)
+%% end;
+%% chk_IndAudLocalControlDescriptor_propertyParms([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_IndAudPropertyParm(H1, H2) end,
+%% 'IndAudLocalControlDescriptor_propertyParms_val'),
+%% chk_IndAudLocalControlDescriptor_propertyParms(T1, T2);
+%% chk_IndAudLocalControlDescriptor_propertyParms(PPs1, PPs2) ->
+%% wrong_type('IndAudLocalControlDescriptor_propertyParms', PPs1, PPs2).
+
+
+%% %% -- IndAudPropertyParm --
+
+%% is_IndAudPropertyParm(#'IndAudPropertyParm'{name = Name}) ->
+%% is_PkgdName(Name);
+%% is_IndAudPropertyParm(_) ->
+%% false.
+
+%% chk_IndAudPropertyParm(#'IndAudPropertyParm'{name = Name1},
+%% #'IndAudPropertyParm'{name = Name2}) ->
+%% chk_PkgdName(Name1, Name2),
+%% ok;
+%% chk_IndAudPropertyParm(P1, P2) ->
+%% wrong_type('IndAudPropertyParm', P1, P2).
+
+
+%% %% -- IndAudLocalRemoteDescriptor --
+
+%% is_opt_IndAudLocalRemoteDescriptor(asn1_NOVALUE) ->
+%% true;
+%% is_opt_IndAudLocalRemoteDescriptor(D) ->
+%% is_IndAudLocalRemoteDescriptor(D).
+
+%% is_IndAudLocalRemoteDescriptor(
+%% #'IndAudLocalRemoteDescriptor'{propGroupID = ID,
+%% propGrps = Grps}) ->
+%% is_IndAudLocalRemoteDescriptor_propGroupID(ID) andalso
+%% is_IndAudPropertyGroup(Grps);
+%% is_IndAudLocalRemoteDescriptor(_) ->
+%% false.
+
+%% is_IndAudLocalRemoteDescriptor_propGroupID(asn1_NOVALUE) ->
+%% true;
+%% is_IndAudLocalRemoteDescriptor_propGroupID(V) ->
+%% is_INTEGER(V, {range, 0, 65535}).
+
+%% chk_opt_IndAudLocalRemoteDescriptor(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_IndAudLocalRemoteDescriptor(D1, D2) ->
+%% chk_IndAudLocalRemoteDescriptor(D1, D2).
+
+%% chk_IndAudLocalRemoteDescriptor(D, D) ->
+%% chk_type(fun is_IndAudLocalRemoteDescriptor/1,
+%% 'IndAudLocalRemoteDescriptor', D);
+%% chk_IndAudLocalRemoteDescriptor(
+%% #'IndAudLocalRemoteDescriptor'{propGroupID = ID1,
+%% propGrps = Grps1},
+%% #'IndAudLocalRemoteDescriptor'{propGroupID = ID2,
+%% propGrps = Grps2}) ->
+%% chk_IndAudLocalRemoteDescriptor_propGroupID(ID1, ID2),
+%% chk_IndAudPropertyGroup(Grps1, Grps2),
+%% ok;
+%% chk_IndAudLocalRemoteDescriptor(D1, D2) ->
+%% wrong_type('IndAudLocalRemoteDescriptor', D1, D2).
+
+%% chk_IndAudLocalRemoteDescriptor_propGroupID(ID, ID) ->
+%% chk_type(fun is_IndAudLocalRemoteDescriptor_propGroupID/1,
+%% 'IndAudLocalRemoteDescriptor_propGroupID', ID);
+%% chk_IndAudLocalRemoteDescriptor_propGroupID(ID1, ID2) ->
+%% case (is_IndAudLocalRemoteDescriptor_propGroupID(ID1) andalso
+%% is_IndAudLocalRemoteDescriptor_propGroupID(ID2)) of
+%% true ->
+%% not_equal('IndAudLocalRemoteDescriptor_propGroupID', ID1, ID2);
+%% false ->
+%% wrong_type('IndAudLocalRemoteDescriptor_propGroupID', ID1, ID2)
+%% end.
+
+
+%% %% -- IndAudPropertyGroup --
+
+%% is_IndAudPropertyGroup([]) ->
+%% true;
+%% is_IndAudPropertyGroup([H|T]) ->
+%% is_IndAudPropertyParm(H) andalso is_IndAudPropertyGroup(T);
+%% is_IndAudPropertyGroup(_) ->
+%% false.
+
+%% chk_IndAudPropertyGroup([], []) ->
+%% ok;
+%% chk_IndAudPropertyGroup([] = PG1, PG2) ->
+%% not_equal('IndAudPropertyGroup', PG1, PG2);
+%% chk_IndAudPropertyGroup(PG1, [] = PG2) ->
+%% not_equal('IndAudPropertyGroup', PG1, PG2);
+%% chk_IndAudPropertyGroup([H|T1], [H|T2]) ->
+%% case is_IndAudPropertyParm(H) of
+%% true ->
+%% chk_IndAudPropertyGroup(T1, T2);
+%% false ->
+%% wrong_type('IndAudPropertyGroup_val', H)
+%% end;
+%% chk_IndAudPropertyGroup([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_IndAudPropertyParm(H1, H2) end,
+%% 'IndAudPropertyGroup_val'),
+%% chk_IndAudPropertyGroup(T1, T2);
+%% chk_IndAudPropertyGroup(P1, P2) ->
+%% wrong_type('IndAudPropertyGroup', P1, P2).
+
+
+%% %% -- IndAudTerminationStateDescriptor --
+
+%% is_opt_IndAudTerminationStateDescriptor(asn1_NOVALUE) ->
+%% true;
+%% is_opt_IndAudTerminationStateDescriptor(D) ->
+%% is_IndAudTerminationStateDescriptor(D).
+
+%% is_IndAudTerminationStateDescriptor(
+%% #'IndAudTerminationStateDescriptor'{propertyParms = Parms,
+%% eventBufferControl = EBC,
+%% serviceState = SS}) ->
+%% is_IndAudTerminationStateDescriptor_propertyParms(Parms) andalso
+%% is_opt_NULL(EBC) andalso is_opt_NULL(SS);
+%% is_IndAudTerminationStateDescriptor(_) ->
+%% false.
+
+%% is_IndAudTerminationStateDescriptor_propertyParms([]) ->
+%% true;
+%% is_IndAudTerminationStateDescriptor_propertyParms([H|T]) ->
+%% is_IndAudPropertyParm(H) andalso
+%% is_IndAudTerminationStateDescriptor_propertyParms(T);
+%% is_IndAudTerminationStateDescriptor_propertyParms(_) ->
+%% false.
+
+%% chk_opt_IndAudTerminationStateDescriptor(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_IndAudTerminationStateDescriptor(D1, D2) ->
+%% chk_IndAudTerminationStateDescriptor(D1, D2).
+
+%% chk_IndAudTerminationStateDescriptor(
+%% #'IndAudTerminationStateDescriptor'{propertyParms = Parms1,
+%% eventBufferControl = EBC1,
+%% serviceState = SS1},
+%% #'IndAudTerminationStateDescriptor'{propertyParms = Parms2,
+%% eventBufferControl = EBC2,
+%% serviceState = SS2}) ->
+%% chk_IndAudTerminationStateDescriptor_propertyParms(Parms1, Parms2),
+%% validate(fun() -> chk_opt_NULL(EBC1, EBC2) end,
+%% 'IndAudTerminationStateDescriptor'),
+%% validate(fun() -> chk_opt_NULL(SS1, SS2) end,
+%% 'IndAudTerminationStateDescriptor'),
+%% ok;
+%% chk_IndAudTerminationStateDescriptor(D1, D2) ->
+%% wrong_type('IndAudTerminationStateDescriptor', D1, D2).
+
+%% chk_IndAudTerminationStateDescriptor_propertyParms([], []) ->
+%% ok;
+%% chk_IndAudTerminationStateDescriptor_propertyParms([] = PP1, PP2) ->
+%% not_equal('IndAudTerminationStateDescriptor_propertyParms', PP1, PP2);
+%% chk_IndAudTerminationStateDescriptor_propertyParms(PP1, [] = PP2) ->
+%% not_equal('IndAudTerminationStateDescriptor_propertyParms', PP1, PP2);
+%% chk_IndAudTerminationStateDescriptor_propertyParms([H|T1], [H|T2]) ->
+%% case is_IndAudPropertyParm(H) of
+%% true ->
+%% chk_IndAudTerminationStateDescriptor_propertyParms(T1, T2);
+%% false ->
+%% wrong_type('IndAudTerminationStateDescriptor_propertyParms', H)
+%% end;
+%% chk_IndAudTerminationStateDescriptor_propertyParms([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_IndAudPropertyParm(H1, H2) end,
+%% 'IndAudTerminationStateDescriptor_propertyParms'),
+%% chk_IndAudTerminationStateDescriptor_propertyParms(T1, T2);
+%% chk_IndAudTerminationStateDescriptor_propertyParms(PP1, PP2) ->
+%% wrong_type('IndAudTerminationStateDescriptor_propertyParms', PP1, PP2).
+
+
+%% %% -- IndAudEventsDescriptor --
+
+%% is_IndAudEventsDescriptor(#'IndAudEventsDescriptor'{requestID = RID,
+%% pkgdName = Name,
+%% streamID = SID}) ->
+%% is_opt_RequestID(RID) andalso
+%% is_PkgdName(Name) andalso
+%% is_opt_StreamID(SID);
+%% is_IndAudEventsDescriptor(_) ->
+%% false.
+
+%% chk_IndAudEventsDescriptor(#'IndAudEventsDescriptor'{requestID = RID1,
+%% pkgdName = Name1,
+%% streamID = SID1},
+%% #'IndAudEventsDescriptor'{requestID = RID2,
+%% pkgdName = Name2,
+%% streamID = SID2}) ->
+%% chk_opt_RequestID(RID1, RID2),
+%% chk_PkgdName(Name1, Name2),
+%% chk_opt_StreamID(SID1, SID2),
+%% ok;
+%% chk_IndAudEventsDescriptor(D1, D2) ->
+%% wrong_type('IndAudEventsDescriptor', D1, D2).
+
+
+%% %% -- IndAudEventBufferDescriptor --
+
+%% is_IndAudEventBufferDescriptor(
+%% #'IndAudEventBufferDescriptor'{eventName = Name,
+%% streamID = SID}) ->
+%% is_PkgdName(Name) andalso is_opt_StreamID(SID);
+%% is_IndAudEventBufferDescriptor(_) ->
+%% false.
+
+%% chk_IndAudEventBufferDescriptor(
+%% #'IndAudEventBufferDescriptor'{eventName = Name1,
+%% streamID = SID1},
+%% #'IndAudEventBufferDescriptor'{eventName = Name2,
+%% streamID = SID2}) ->
+%% chk_PkgdName(Name1, Name2),
+%% chk_opt_StreamID(SID1, SID2),
+%% ok;
+%% chk_IndAudEventBufferDescriptor(D1, D2) ->
+%% wrong_type('IndAudEventBufferDescriptor', D1, D2).
+
+
+%% %% -- IndAudSignalsDescriptor --
+
+%% is_IndAudSignalsDescriptor({Tag, Val}) ->
+%% is_IndAudSignalsDescriptor_tag(Tag) andalso
+%% is_IndAudSignalsDescriptor_val(Tag, Val);
+%% is_IndAudSignalsDescriptor(_) ->
+%% false.
+
+%% is_IndAudSignalsDescriptor_tag(Tag) ->
+%% Tags = [signal, seqSigList],
+%% lists:member(Tag, Tags).
+
+%% is_IndAudSignalsDescriptor_val(signal, Val) ->
+%% is_IndAudSignal(Val);
+%% is_IndAudSignalsDescriptor_val(seqSigList, Val) ->
+%% is_IndAudSeqSigList(Val).
+
+%% chk_IndAudSignalsDescriptor(D, D) ->
+%% chk_type(fun is_IndAudSignalsDescriptor/1, 'IndAudSignalsDescriptor', D);
+%% chk_IndAudSignalsDescriptor({Tag, Val1} = D1, {Tag, Val2} = D2) ->
+%% case (is_IndAudSignalsDescriptor_tag(Tag) andalso
+%% is_IndAudSignalsDescriptor_val(Tag, Val1) andalso
+%% is_IndAudSignalsDescriptor_val(Tag, Val2)) of
+%% true ->
+%% chk_IndAudSignalsDescriptor_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('IndAudSignalsDescriptor', D1, D2)
+%% end;
+%% chk_IndAudSignalsDescriptor({Tag1, Val1} = D1, {Tag2, Val2} = D2) ->
+%% case ((is_IndAudSignalsDescriptor_tag(Tag1) andalso
+%% is_IndAudSignalsDescriptor_val(Tag1, Val1)) andalso
+%% (is_IndAudSignalsDescriptor_tag(Tag2) andalso
+%% is_IndAudSignalsDescriptor_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('IndAudSignalsDescriptor', D1, D2);
+%% false ->
+%% wrong_type('IndAudSignalsDescriptor', D1, D2)
+%% end;
+%% chk_IndAudSignalsDescriptor(D1, D2) ->
+%% wrong_type('IndAudSignalsDescriptor', D1, D2).
+
+%% chk_IndAudSignalsDescriptor_val(signal, Val1, Val2) ->
+%% chk_IndAudSignal(Val1, Val2);
+%% chk_IndAudSignalsDescriptor_val(seqSigList, Val1, Val2) ->
+%% chk_IndAudSeqSigList(Val1, Val2).
+
+
+%% %% -- IndAudSeqSigList --
+
+%% is_IndAudSeqSigList(#'IndAudSeqSigList'{id = ID,
+%% signalList = SL}) ->
+%% is_IndAudSeqSigList_id(ID) andalso is_opt_IndAudSignal(SL);
+%% is_IndAudSeqSigList(_) ->
+%% false.
+
+%% is_IndAudSeqSigList_id(ID) -> is_INTEGER(ID, {range, 0, 65535}).
+
+%% chk_IndAudSeqSigList(L, L) ->
+%% chk_type(fun is_IndAudSeqSigList/1, 'IndAudSeqSigList', L);
+%% chk_IndAudSeqSigList(#'IndAudSeqSigList'{id = ID1,
+%% signalList = SL1},
+%% #'IndAudSeqSigList'{id = ID2,
+%% signalList = SL2}) ->
+%% chk_IndAudSeqSigList_id(ID1, ID2),
+%% chk_opt_IndAudSignal(SL1, SL2),
+%% ok;
+%% chk_IndAudSeqSigList(L1, L2) ->
+%% wrong_type('IndAudSeqSigList', L1, L2).
+
+%% chk_IndAudSeqSigList_id(ID, ID) ->
+%% chk_type(fun is_IndAudSeqSigList_id/1, 'IndAudSeqSigList_id', ID);
+%% chk_IndAudSeqSigList_id(ID1, ID2) ->
+%% case (is_IndAudSeqSigList_id(ID1) andalso
+%% is_IndAudSeqSigList_id(ID2)) of
+%% true ->
+%% not_equal('IndAudSeqSigList_id', ID1, ID2);
+%% false ->
+%% wrong_type('IndAudSeqSigList_id', ID1, ID2)
+%% end.
+
+
+%% %% -- IndAudSignal --
+
+%% is_opt_IndAudSignal(asn1_NOVALUE) ->
+%% true;
+%% is_opt_IndAudSignal(V) ->
+%% is_IndAudSignal(V).
+
+%% is_IndAudSignal(#'IndAudSignal'{signalName = Name,
+%% streamID = SID}) ->
+%% is_PkgdName(Name) andalso is_opt_StreamID(SID);
+%% is_IndAudSignal(_) ->
+%% false.
+
+%% chk_opt_IndAudSignal(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_IndAudSignal(S1, S2) ->
+%% chk_IndAudSignal(S1, S2).
+
+%% chk_IndAudSignal(S, S) ->
+%% chk_type(fun is_IndAudSignal/1, 'IndAudSignal', S);
+%% chk_IndAudSignal(#'IndAudSignal'{signalName = Name1,
+%% streamID = SID1},
+%% #'IndAudSignal'{signalName = Name2,
+%% streamID = SID2}) ->
+%% chk_PkgdName(Name1, Name2),
+%% chk_opt_StreamID(SID1, SID2),
+%% ok;
+%% chk_IndAudSignal(S1, S2) ->
+%% wrong_type('IndAudSignal', S1, S2).
+
+
+%% %% -- IndAudDigitMapDescriptor --
+
+%% is_IndAudDigitMapDescriptor(
+%% #'IndAudDigitMapDescriptor'{digitMapName = Name}) ->
+%% is_opt_DigitMapName(Name);
+%% is_IndAudDigitMapDescriptor(_) ->
+%% false.
+
+%% chk_IndAudDigitMapDescriptor(D, D) ->
+%% chk_type(fun is_IndAudDigitMapDescriptor/1, 'IndAudDigitMapDescriptor', D);
+%% chk_IndAudDigitMapDescriptor(
+%% #'IndAudDigitMapDescriptor'{digitMapName = Name1},
+%% #'IndAudDigitMapDescriptor'{digitMapName = Name2}) ->
+%% validate(fun() -> chk_opt_DigitMapName(Name1, Name2) end,
+%% 'IndAudDigitMapDescriptor'),
+%% ok;
+%% chk_IndAudDigitMapDescriptor(D1, D2) ->
+%% wrong_type('IndAudDigitMapDescriptor', D1, D2).
+
+
+%% %% -- IndAudStatisticsDescriptor --
+
+%% is_IndAudStatisticsDescriptor(
+%% #'IndAudStatisticsDescriptor'{statName = Name}) ->
+%% is_PkgdName(Name);
+%% is_IndAudStatisticsDescriptor(_) ->
+%% false.
+
+%% chk_IndAudStatisticsDescriptor(D, D) ->
+%% chk_type(fun is_IndAudStatisticsDescriptor/1,
+%% 'IndAudStatisticsDescriptor', D);
+%% chk_IndAudStatisticsDescriptor(
+%% #'IndAudStatisticsDescriptor'{statName = Name1},
+%% #'IndAudStatisticsDescriptor'{statName = Name2}) ->
+%% validate(fun() -> chk_PkgdName(Name1, Name2) end,
+%% 'IndAudStatisticsDescriptor'),
+%% ok;
+%% chk_IndAudStatisticsDescriptor(D1, D2) ->
+%% wrong_type('IndAudStatisticsDescriptor', D1, D2).
+
+
+%% %% -- IndAudPackagesDescriptor --
+
+%% is_IndAudPackagesDescriptor(
+%% #'IndAudPackagesDescriptor'{packageName = Name,
+%% packageVersion = Ver}) ->
+%% is_Name(Name) andalso is_IndAudPackagesDescriptor_packageVersion(Ver);
+%% is_IndAudPackagesDescriptor(_) ->
+%% false.
+
+%% is_IndAudPackagesDescriptor_packageVersion(V) ->
+%% is_INTEGER(V, {range, 0, 99}).
+
+%% chk_IndAudPackagesDescriptor(
+%% #'IndAudPackagesDescriptor'{packageName = Name1,
+%% packageVersion = Ver1},
+%% #'IndAudPackagesDescriptor'{packageName = Name2,
+%% packageVersion = Ver2}) ->
+%% validate(fun() -> chk_Name(Name1, Name2) end, 'IndAudPackagesDescriptor'),
+%% chk_IndAudPackagesDescriptor_packageVersion(Ver1, Ver2),
+%% ok;
+%% chk_IndAudPackagesDescriptor(D1, D2) ->
+%% wrong_type('IndAudPackagesDescriptor', D1, D2).
+
+%% chk_IndAudPackagesDescriptor_packageVersion(V, V) ->
+%% chk_type(fun is_IndAudPackagesDescriptor_packageVersion/1,
+%% 'IndAudPackagesDescriptor_packageVersion', V);
+%% chk_IndAudPackagesDescriptor_packageVersion(V1, V2) ->
+%% case (is_IndAudPackagesDescriptor_packageVersion(V1) andalso
+%% is_IndAudPackagesDescriptor_packageVersion(V2)) of
+%% true ->
+%% not_equal('IndAudPackagesDescriptor_packageVersion', V1, V2);
+%% false ->
+%% wrong_type('IndAudPackagesDescriptor_packageVersion', V1, V2)
+%% end.
+
+
+%% %% -- NotifyRequest --
+
+%% is_NotifyRequest(#'NotifyRequest'{terminationID = Tids,
+%% observedEventsDescriptor = OED,
+%% errorDescriptor = ED}) ->
+%% is_TerminationIDList(Tids) andalso
+%% is_ObservedEventsDescriptor(OED) andalso
+%% is_opt_ErrorDescriptor(ED);
+%% is_NotifyRequest(_) ->
+%% false.
+
+%% chk_NotifyRequest(#'NotifyRequest'{terminationID = Tids1,
+%% observedEventsDescriptor = OED1,
+%% errorDescriptor = ED1},
+%% #'NotifyRequest'{terminationID = Tids2,
+%% observedEventsDescriptor = OED2,
+%% errorDescriptor = ED2}) ->
+%% validate(fun() -> chk_TerminationIDList(Tids1, Tids2) end,
+%% 'NotifyRequest'),
+%% validate(fun() -> chk_ObservedEventsDescriptor(OED1, OED2) end,
+%% 'NotifyRequest'),
+%% validate(fun() -> chk_opt_ErrorDescriptor(ED1, ED2) end,
+%% 'NotifyRequest'),
+%% ok;
+%% chk_NotifyRequest(NR1, NR2) ->
+%% wrong_type('NotifyRequest', NR1, NR2).
+
+
+%% %% -- NotifyReply --
+
+%% is_NotifyReply(#'NotifyReply'{terminationID = Tids,
+%% errorDescriptor = ED}) ->
+%% is_TerminationIDList(Tids) andalso is_opt_ErrorDescriptor(ED);
+%% is_NotifyReply(_) ->
+%% false.
+
+%% chk_NotifyReply(#'NotifyReply'{terminationID = Tids1,
+%% errorDescriptor = ED1},
+%% #'NotifyReply'{terminationID = Tids2,
+%% errorDescriptor = ED2}) ->
+%% validate(fun() -> chk_TerminationIDList(Tids1, Tids2) end, 'NotifyReply'),
+%% validate(fun() -> chk_opt_ErrorDescriptor(ED1, ED2) end, 'NotifyReply'),
+%% ok;
+%% chk_NotifyReply(NR1, NR2) ->
+%% wrong_type('NotifyReply', NR1, NR2).
+
+
+%% %% -- ObservedEventsDescriptor --
+
+%% is_ObservedEventsDescriptor(
+%% #'ObservedEventsDescriptor'{requestId = RID,
+%% observedEventLst = OEL}) ->
+%% is_RequestID(RID) andalso
+%% is_ObservedEventsDescriptor_observedEventLst(OEL);
+%% is_ObservedEventsDescriptor(_) ->
+%% false.
+
+%% is_ObservedEventsDescriptor_observedEventLst([]) ->
+%% true;
+%% is_ObservedEventsDescriptor_observedEventLst([H|T]) ->
+%% is_ObservedEvent(H) andalso
+%% is_ObservedEventsDescriptor_observedEventLst(T);
+%% is_ObservedEventsDescriptor_observedEventLst(_) ->
+%% false.
+
+%% chk_ObservedEventsDescriptor(
+%% #'ObservedEventsDescriptor'{requestId = RID1,
+%% observedEventLst = OEL1},
+%% #'ObservedEventsDescriptor'{requestId = RID2,
+%% observedEventLst = OEL2}) ->
+%% validate(fun() -> chk_RequestID(RID1, RID2) end,
+%% 'ObservedEventsDescriptor'),
+%% validate(
+%% fun() ->
+%% chk_ObservedEventsDescriptor_observedEventLst(OEL1, OEL2)
+%% end,
+%% 'ObservedEventsDescriptor'),
+%% ok;
+%% chk_ObservedEventsDescriptor(D1, D2) ->
+%% wrong_type('ObservedEventsDescriptor', D1, D2).
+
+%% chk_ObservedEventsDescriptor_observedEventLst([], []) ->
+%% ok;
+%% chk_ObservedEventsDescriptor_observedEventLst([] = L1, L2) ->
+%% not_equal('ObservedEventsDescriptor_observedEventLst', L1, L2);
+%% chk_ObservedEventsDescriptor_observedEventLst(L1, [] = L2) ->
+%% not_equal('ObservedEventsDescriptor_observedEventLst', L1, L2);
+%% chk_ObservedEventsDescriptor_observedEventLst([H|T1], [H|T2]) ->
+%% case is_ObservedEvent(H) of
+%% true ->
+%% chk_ObservedEventsDescriptor_observedEventLst(T1, T2);
+%% false ->
+%% wrong_type('ObservedEventsDescriptor_observedEventLst_val', H)
+%% end;
+%% chk_ObservedEventsDescriptor_observedEventLst([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_ObservedEvent(H1, H2) end,
+%% 'ObservedEventsDescriptor_observedEventLst_val'),
+%% chk_ObservedEventsDescriptor_observedEventLst(T1, T2);
+%% chk_ObservedEventsDescriptor_observedEventLst(L1, L2) ->
+%% wrong_type('ObservedEventsDescriptor_observedEventLst', L1, L2).
+
+
+%% %% -- ObservedEvent --
+
+%% is_ObservedEvent(#'ObservedEvent'{eventName = Name,
+%% streamID = SID,
+%% eventParList = EPL,
+%% timeNotation = TN}) ->
+%% is_EventName(Name) andalso
+%% is_opt_StreamID(SID) andalso
+%% is_ObservedEvent_eventParList(EPL) andalso
+%% is_opt_TimeNotation(TN);
+%% is_ObservedEvent(_) ->
+%% false.
+
+%% is_ObservedEvent_eventParList([]) ->
+%% true;
+%% is_ObservedEvent_eventParList([H|T]) ->
+%% is_EventParameter(H) andalso is_ObservedEvent_eventParList(T);
+%% is_ObservedEvent_eventParList(_) ->
+%% false.
+
+%% chk_ObservedEvent(E, E) ->
+%% chk_type(fun is_ObservedEvent/1, 'ObservedEvent', E);
+%% chk_ObservedEvent(#'ObservedEvent'{eventName = Name1,
+%% streamID = SID1,
+%% eventParList = EPL1,
+%% timeNotation = TN1},
+%% #'ObservedEvent'{eventName = Name2,
+%% streamID = SID2,
+%% eventParList = EPL2,
+%% timeNotation = TN2}) ->
+%% validate(fun() -> chk_EventName(Name1, Name2) end, 'ObservedEvent'),
+%% validate(fun() -> chk_opt_StreamID(SID1, SID2) end, 'ObservedEvent'),
+%% chk_ObservedEvent_eventParList(EPL1, EPL2),
+%% validate(fun() -> chk_opt_TimeNotation(TN1, TN2) end, 'ObservedEvent'),
+%% ok;
+%% chk_ObservedEvent(E1, E2) ->
+%% wrong_type('ObservedEvent', E1, E2).
+
+%% chk_ObservedEvent_eventParList([], []) ->
+%% ok;
+%% chk_ObservedEvent_eventParList([] = EPL1, EPL2) ->
+%% not_equal('ObservedEvent_eventParList', EPL1, EPL2);
+%% chk_ObservedEvent_eventParList(EPL1, [] = EPL2) ->
+%% not_equal('ObservedEvent_eventParList', EPL1, EPL2);
+%% chk_ObservedEvent_eventParList([H|T1], [H|T2]) ->
+%% case is_EventParameter(H) of
+%% true ->
+%% chk_ObservedEvent_eventParList(T1, T2);
+%% false ->
+%% wrong_type('ObservedEvent_eventParList_val', H)
+%% end;
+%% chk_ObservedEvent_eventParList([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_EventParameter(H1, H2) end,
+%% 'ObservedEvent_eventParList'),
+%% chk_ObservedEvent_eventParList(T1, T2);
+%% chk_ObservedEvent_eventParList(L1, L2) ->
+%% wrong_type('ObservedEvent_eventParList', L1, L2).
+
+
+%% %% -- EventName --
+
+is_EventName(N) -> is_PkgdName(N).
+
+%% chk_EventName(N, N) ->
+%% chk_type(fun is_EventName/1, 'EventName', N);
+%% chk_EventName(N1, N2) ->
+%% case (is_EventName(N1) andalso is_EventName(N2)) of
+%% true ->
+%% not_equal('EventName', N1, N2);
+%% false ->
+%% wrong_type('EventName', N1, N2)
+%% end.
+
+
+%% %% -- EventParameter --
+
+is_EventParameter(#'EventParameter'{eventParameterName = Name,
+ value = Val,
+ extraInfo = EI}) ->
+ d("is_EventParameter -> entery with"
+ "~n Name: ~p"
+ "~n Val: ~p"
+ "~n EI: ~p", [Name, Val, EI]),
+ is_Name(Name) andalso
+ is_Value(Val) andalso
+ is_EventParameter_extraInfo(EI);
+is_EventParameter(_) ->
+ false.
+
+is_EventParameter_extraInfo(asn1_NOVALUE) ->
+ true;
+is_EventParameter_extraInfo({Tag, Val}) ->
+ is_EventParameter_extraInfo_tag(Tag) andalso
+ is_EventParameter_extraInfo_val(Tag, Val);
+is_EventParameter_extraInfo(_) ->
+ false.
+
+is_EventParameter_extraInfo_tag(Tag) ->
+ Tags = [relation, range, sublist],
+ lists:member(Tag, Tags).
+
+is_EventParameter_extraInfo_val(relation, Val) ->
+ is_Relation(Val);
+is_EventParameter_extraInfo_val(range, Val) ->
+ is_BOOLEAN(Val);
+is_EventParameter_extraInfo_val(sublist, Val) ->
+ is_BOOLEAN(Val).
+
+%% chk_EventParameter(#'EventParameter'{eventParameterName = Name1,
+%% value = Val1,
+%% extraInfo = EI1},
+%% #'EventParameter'{eventParameterName = Name2,
+%% value = Val2,
+%% extraInfo = EI2}) ->
+%% validate(fun() -> chk_Name(Name1, Name2) end, 'EventParameter'),
+%% validate(fun() -> chk_Value(Val1, Val2) end, 'EventParameter'),
+%% chk_EventParameter_extraInfo(EI1, EI2),
+%% ok;
+%% chk_EventParameter(P1, P2) ->
+%% wrong_type('EventParameter', P1, P2).
+
+%% chk_EventParameter_extraInfo(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_EventParameter_extraInfo(EI, EI) ->
+%% chk_type(fun is_EventParameter_extraInfo/1,
+%% 'EventParameter_extraInfo', EI);
+%% chk_EventParameter_extraInfo({Tag, Val1} = EI1, {Tag, Val2} = EI2) ->
+%% case (is_EventParameter_extraInfo_tag(Tag) andalso
+%% is_EventParameter_extraInfo_val(Tag, Val1) andalso
+%% is_EventParameter_extraInfo_val(Tag, Val2)) of
+%% true ->
+%% chk_EventParameter_extraInfo_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('EventParameter_extraInfo', EI1, EI2)
+%% end;
+%% chk_EventParameter_extraInfo({Tag1, Val1} = EI1, {Tag2, Val2} = EI2) ->
+%% case ((is_EventParameter_extraInfo_tag(Tag1) andalso
+%% is_EventParameter_extraInfo_val(Tag1, Val1)) andalso
+%% (is_EventParameter_extraInfo_tag(Tag2) andalso
+%% is_EventParameter_extraInfo_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('EventParameter_extraInfo', EI1, EI2);
+%% false ->
+%% wrong_type('EventParameter_extraInfo', EI1, EI2)
+%% end;
+%% chk_EventParameter_extraInfo(EI1, EI2) ->
+%% wrong_type('EventParameter_extraInfo', EI1, EI2).
+
+%% chk_EventParameter_extraInfo_val(relation, Val1, Val2) ->
+%% validate(fun() -> chk_Relation(Val1, Val2) end,
+%% 'EventParameter_extraInfo_val');
+%% chk_EventParameter_extraInfo_val(range, Val1, Val2) ->
+%% validate(fun() -> chk_BOOLEAN(Val1, Val2) end,
+%% 'EventParameter_extraInfo_val');
+%% chk_EventParameter_extraInfo_val(sublist, Val1, Val2) ->
+%% validate(fun() -> chk_BOOLEAN(Val1, Val2) end,
+%% 'EventParameter_extraInfo_val').
+
+
+%% %% -- ServiceChangeRequest --
+
+%% is_ServiceChangeRequest(#'ServiceChangeRequest'{terminationID = Tids,
+%% serviceChangeParms = Parms}) ->
+%% is_TerminationIDList(Tids) andalso is_ServiceChangeParm(Parms);
+%% is_ServiceChangeRequest(_) ->
+%% false.
+
+%% chk_ServiceChangeRequest(R, R) ->
+%% chk_type(fun is_ServiceChangeRequest/1, 'ServiceChangeRequest', R);
+%% chk_ServiceChangeRequest(
+%% #'ServiceChangeRequest'{terminationID = Tids1,
+%% serviceChangeParms = Parms1},
+%% #'ServiceChangeRequest'{terminationID = Tids2,
+%% serviceChangeParms = Parms2}) ->
+%% validate(fun() -> chk_TerminationIDList(Tids1, Tids2) end,
+%% 'ServiceChangeRequest'),
+%% validate(fun() -> chk_ServiceChangeParm(Parms1, Parms2) end,
+%% 'ServiceChangeRequest'),
+%% ok;
+%% chk_ServiceChangeRequest(R1, R2) ->
+%% wrong_type('ServiceChangeRequest', R1, R2).
+
+
+%% %% -- ServiceChangeReply --
+
+%% is_ServiceChangeReply(#'ServiceChangeReply'{terminationID = Tids,
+%% serviceChangeResult = Res}) ->
+%% is_TerminationIDList(Tids) andalso is_ServiceChangeResult(Res);
+%% is_ServiceChangeReply(_) ->
+%% false.
+
+%% chk_ServiceChangeReply(R, R) ->
+%% chk_type(fun is_ServiceChangeReply/1, 'ServiceChangeReply', R);
+%% chk_ServiceChangeReply(
+%% #'ServiceChangeReply'{terminationID = Tids1,
+%% serviceChangeResult = Res1},
+%% #'ServiceChangeReply'{terminationID = Tids2,
+%% serviceChangeResult = Res2}) ->
+%% validate(fun() -> chk_TerminationIDList(Tids1, Tids2) end,
+%% 'ServiceChangeReply'),
+%% validate(fun() -> chk_ServiceChangeResult(Res1, Res2) end,
+%% 'ServiceChangeReply'),
+%% ok;
+%% chk_ServiceChangeReply(R1, R2) ->
+%% wrong_type('ServiceChangeReply', R1, R2).
+
+
+%% %% -- ServiceChangeResult --
+
+%% is_ServiceChangeResult({Tag, Val}) ->
+%% is_ServiceChangeResult_tag(Tag) andalso
+%% is_ServiceChangeResult_val(Tag, Val);
+%% is_ServiceChangeResult(_) ->
+%% false.
+
+%% is_ServiceChangeResult_tag(Tag) ->
+%% Tags = [errorDescriptor, serviceChangeResParms],
+%% lists:member(Tag, Tags).
+
+%% is_ServiceChangeResult_val(errorDescriptor, Val) ->
+%% is_ErrorDescriptor(Val);
+%% is_ServiceChangeResult_val(serviceChangeResParms, Val) ->
+%% is_ServiceChangeResParm(Val).
+
+%% chk_ServiceChangeResult(Res, Res) ->
+%% chk_type(fun is_ServiceChangeResult/1, 'ServiceChangeResult', Res);
+%% chk_ServiceChangeResult({Tag, Val1} = Res1, {Tag, Val2} = Res2) ->
+%% case (is_ServiceChangeResult_tag(Tag) andalso
+%% is_ServiceChangeResult_val(Tag, Val1) andalso
+%% is_ServiceChangeResult_val(Tag, Val2)) of
+%% true ->
+%% chk_ServiceChangeResult_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('ServiceChangeResult', Res1, Res2)
+%% end;
+%% chk_ServiceChangeResult({Tag1, Val1} = Res1, {Tag2, Val2} = Res2) ->
+%% case ((is_ServiceChangeResult_tag(Tag1) andalso
+%% is_ServiceChangeResult_val(Tag1, Val1)) andalso
+%% (is_ServiceChangeResult_tag(Tag2) andalso
+%% is_ServiceChangeResult_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('ServiceChangeResult', Res1, Res2);
+%% false ->
+%% wrong_type('ServiceChangeResult', Res1, Res2)
+%% end;
+%% chk_ServiceChangeResult(Res1, Res2) ->
+%% wrong_type('ServiceChangeResult', Res1, Res2).
+
+%% chk_ServiceChangeResult_val(errorDescriptor, Val1, Val2) ->
+%% validate(fun() -> chk_ErrorDescriptor(Val1, Val2) end,
+%% 'ServiceChangeResult');
+%% chk_ServiceChangeResult_val(serviceChangeResParms, Val1, Val2) ->
+%% validate(fun() -> chk_ServiceChangeResParm(Val1, Val2) end,
+%% 'ServiceChangeResult').
+
+
+%% %% -- WildcardField --
+
+%% is_WildcardField(WF) -> is_OCTET_STRING(WF, {exact, 1}).
+
+%% chk_WildcardField(WF, WF) ->
+%% case is_WildcardField(WF) of
+%% true ->
+%% ok;
+%% false ->
+%% wrong_type('WildcardField', WF)
+%% end;
+%% chk_WildcardField(WF1, WF2) ->
+%% case (is_WildcardField(WF1) andalso is_WildcardField(WF2)) of
+%% true ->
+%% not_equal('WildcardField', WF1, WF2);
+%% false ->
+%% wrong_type('WildcardField', WF1, WF2)
+%% end.
+
+
+%% %% -- TerminationID --
+
+%% is_TerminationID(#'TerminationID'{wildcard = W,
+%% id = ID}) ->
+%% is_TerminationID_wildcard(W) andalso is_TerminationID_id(ID);
+%% is_TerminationID(#megaco_term_id{contains_wildcards = _W,
+%% id = _ID}) ->
+%% true; % What are the types?
+%% is_TerminationID(_) ->
+%% false.
+
+%% is_TerminationID_wildcard([]) ->
+%% true;
+%% is_TerminationID_wildcard([H|T]) ->
+%% is_WildcardField(H) andalso is_TerminationID_wildcard(T);
+%% is_TerminationID_wildcard(_) ->
+%% false.
+
+%% is_TerminationID_id(ID) -> is_OCTET_STRING(ID, {range, 1, 8}).
+
+%% chk_TerminationID(Id,Id) ->
+%% chk_type(fun is_TerminationID/1, 'TerminationID', Id);
+%% chk_TerminationID(#'TerminationID'{wildcard = W1,
+%% id = I1},
+%% #'TerminationID'{wildcard = W2,
+%% id = I2}) ->
+%% chk_TerminationID_wildcard(W1, W2),
+%% chk_TerminationID_id(I1, I2),
+%% ok;
+%% chk_TerminationID(#megaco_term_id{contains_wildcards = W1,
+%% id = I1},
+%% #megaco_term_id{contains_wildcards = W2,
+%% id = I2}) ->
+%% chk_TerminationID_wildcard(W1, W2),
+%% chk_TerminationID_id(I1, I2),
+%% ok;
+%% chk_TerminationID(Tid1, Tid2) ->
+%% wrong_type('TerminationID', Tid1, Tid2).
+
+%% chk_TerminationID_wildcard([], []) ->
+%% ok;
+%% chk_TerminationID_wildcard([] = WF1, WF2) ->
+%% not_equal('TerminationID_wildcard', WF1, WF2);
+%% chk_TerminationID_wildcard(WF1, [] = WF2) ->
+%% not_equal('TerminationID_wildcard', WF1, WF2);
+%% chk_TerminationID_wildcard([H|T1], [H|T2]) ->
+%% case is_WildcardField(H) of
+%% true ->
+%% chk_TerminationID_wildcard(T1, T2);
+%% false ->
+%% wrong_type('TerminationID_wildcard_val', H)
+%% end;
+%% chk_TerminationID_wildcard([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_WildcardField(H1, H2) end,
+%% 'TerminationID_wildcard_val'),
+%% chk_TerminationID_wildcard(T1, T2);
+%% chk_TerminationID_wildcard(WF1,WF2) ->
+%% not_equal('TerminationId_wildcard', WF1, WF2).
+
+%% chk_TerminationID_id(Id, Id) ->
+%% case is_OCTET_STRING(Id, {range, 1, 8}) of
+%% true ->
+%% ok;
+%% false ->
+%% wrong_type('TerminationID_id', Id, Id)
+%% end;
+%% chk_TerminationID_id(Id1, Id2) ->
+%% not_equal(terminationId_id, Id1, Id2).
+
+
+%% %% -- TerminationIDList --
+
+%% is_TerminationIDList([]) ->
+%% true;
+%% is_TerminationIDList([H|T]) ->
+%% is_TerminationID(H) andalso is_TerminationIDList(T);
+%% is_TerminationIDList(_) ->
+%% false.
+
+%% chk_TerminationIDList([], []) ->
+%% ok;
+%% chk_TerminationIDList([] = L1, L2) ->
+%% not_equal('TerminationIDList', L1, L2);
+%% chk_TerminationIDList(L1, [] = L2) ->
+%% not_equal('TerminationIDList', L1, L2);
+%% chk_TerminationIDList([H|T1], [H|T2]) ->
+%% case is_TerminationID(H) of
+%% true ->
+%% chk_TerminationIDList(T1, T2);
+%% false ->
+%% wrong_type('TerminationIDList', H)
+%% end;
+%% chk_TerminationIDList([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_TerminationID(H1, H2) end, 'TerminationIDList'),
+%% chk_TerminationIDList(T1, T2);
+%% chk_TerminationIDList(L1, L2) ->
+%% wrong_type('TerminationIDList', L1, L2).
+
+
+%% %% -- MediaDescriptor --
+
+%% is_MediaDescriptor(#'MediaDescriptor'{termStateDescr = TSD,
+%% streams = S}) ->
+%% is_opt_TerminationStateDescriptor(TSD) andalso
+%% is_MediaDescriptor_streams(S);
+%% is_MediaDescriptor(_) ->
+%% false.
+
+%% is_MediaDescriptor_streams(asn1_NOVALUE) ->
+%% true;
+%% is_MediaDescriptor_streams({Tag, Val}) ->
+%% is_MediaDescriptor_streams_tag(Tag) andalso
+%% is_MediaDescriptor_streams_val(Tag, Val);
+%% is_MediaDescriptor_streams(_) ->
+%% false.
+
+%% is_MediaDescriptor_streams_tag(Tag) ->
+%% Tags = [oneStream, multiStream],
+%% lists:member(Tag, Tags).
+
+%% is_MediaDescriptor_streams_val(oneStream, SP) ->
+%% is_StreamParms(SP);
+%% is_MediaDescriptor_streams_val(multiStream, SDL) ->
+%% is_MediaDescriptor_multiStream(SDL).
+
+%% is_MediaDescriptor_multiStream([]) ->
+%% true;
+%% is_MediaDescriptor_multiStream([H|T]) ->
+%% is_StreamDescriptor(H) andalso is_MediaDescriptor_multiStream(T);
+%% is_MediaDescriptor_multiStream(_) ->
+%% false.
+
+%% chk_MediaDescriptor(D, D) ->
+%% chk_type(fun is_MediaDescriptor/1, 'MediaDescriptor', D);
+%% chk_MediaDescriptor(#'MediaDescriptor'{termStateDescr = TSD1,
+%% streams = S1},
+%% #'MediaDescriptor'{termStateDescr = TSD2,
+%% streams = S2}) ->
+%% validate(
+%% fun() ->
+%% chk_opt_TerminationStateDescriptor(TSD1, TSD2)
+%% end,
+%% 'MediaDescriptor'),
+%% validate(
+%% fun() ->
+%% chk_MediaDescriptor_streams(S1, S2)
+%% end,
+%% 'MediaDescriptor'),
+%% ok;
+%% chk_MediaDescriptor(D1, D2) ->
+%% wrong_type('MediaDescriptor', D1, D2).
+
+
+%% chk_MediaDescriptor_streams(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_MediaDescriptor_streams({oneStream, SP1}, {oneStream, SP2}) ->
+%% validate(fun() ->
+%% chk_StreamParms(SP1, SP2)
+%% end,
+%% 'MediaDescriptor_streams');
+%% chk_MediaDescriptor_streams({multiStream, SDs1}, {multiStream, SDs2}) ->
+%% validate(fun() ->
+%% chk_MediaDescriptor_multiStream(SDs1, SDs2)
+%% end,
+%% 'MediaDescriptor_streams');
+%% chk_MediaDescriptor_streams(S1, S2) ->
+%% wrong_type('MediaDescriptor_streams', S1, S2).
+
+%% chk_MediaDescriptor_multiStream([], []) ->
+%% ok;
+%% chk_MediaDescriptor_multiStream([] = MS1, MS2) ->
+%% not_equal('MediaDescriptor_multiStream', MS1, MS2);
+%% chk_MediaDescriptor_multiStream(MS1, [] = MS2) ->
+%% not_equal('MediaDescriptor_multiStream', MS1, MS2);
+%% chk_MediaDescriptor_multiStream([H|T1], [H|T2]) ->
+%% case is_StreamDescriptor(H) of
+%% true ->
+%% chk_MediaDescriptor_multiStream(T1, T2);
+%% false ->
+%% wrong_type('MediaDescriptor_multiStream_val', H)
+%% end;
+%% chk_MediaDescriptor_multiStream([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_StreamDescriptor(H1, H2) end,
+%% 'MediaDescriptor_multiStream_val'),
+%% chk_MediaDescriptor_multiStream(T1, T2);
+%% chk_MediaDescriptor_multiStream(MS1, MS2) ->
+%% wrong_type('MediaDescriptor_multiStream_val', MS1, MS2).
+
+
+%% %% -- StreamDescriptor --
+
+%% is_StreamDescriptor(#'StreamDescriptor'{streamID = SID,
+%% streamParms = Parms}) ->
+%% is_StreamID(SID) andalso is_StreamParms(Parms);
+%% is_StreamDescriptor(_) ->
+%% false.
+
+%% chk_StreamDescriptor(D, D) ->
+%% chk_type(fun is_StreamDescriptor/1, 'StreamDescriptor', D);
+%% chk_StreamDescriptor(#'StreamDescriptor'{streamID = SID1,
+%% streamParms = Parms1},
+%% #'StreamDescriptor'{streamID = SID2,
+%% streamParms = Parms2}) ->
+%% validate(fun() -> chk_StreamID(SID1, SID2) end, 'StreamDescriptor'),
+%% validate(fun() -> chk_StreamParms(Parms1, Parms2) end, 'StreamDescriptor'),
+%% ok;
+%% chk_StreamDescriptor(D1, D2) ->
+%% wrong_type('StreamDescriptor', D1, D2).
+
+
+%% %% -- StreamParms --
+
+%% is_StreamParms(#'StreamParms'{localControlDescriptor = LCD,
+%% localDescriptor = LD,
+%% remoteDescriptor = RD}) ->
+%% is_opt_LocalControlDescriptor(LCD) andalso
+%% is_opt_LocalRemoteDescriptor(LD) andalso
+%% is_opt_LocalRemoteDescriptor(RD);
+%% is_StreamParms(_) ->
+%% false.
+
+%% chk_StreamParms(SP, SP) ->
+%% chk_type(fun is_StreamParms/1, 'StreamParms', SP);
+%% chk_StreamParms(#'StreamParms'{localControlDescriptor = LCD1,
+%% localDescriptor = LD1,
+%% remoteDescriptor = RD1},
+%% #'StreamParms'{localControlDescriptor = LCD2,
+%% localDescriptor = LD2,
+%% remoteDescriptor = RD2}) ->
+%% chk_opt_LocalControlDescriptor(LCD1, LCD2),
+%% validate(fun() -> chk_opt_LocalRemoteDescriptor(LD1, LD2) end,
+%% localDescriptor),
+%% validate(fun() -> chk_opt_LocalRemoteDescriptor(RD1, RD2) end,
+%% remoteDescriptor),
+%% ok;
+%% chk_StreamParms(P1, P2) ->
+%% wrong_type('StreamParms', P1, P2).
+
+
+%% %% -- LocalControlDescriptor --
+
+%% is_opt_LocalControlDescriptor(asn1_NOVALUE) ->
+%% true;
+%% is_opt_LocalControlDescriptor(D) ->
+%% is_LocalControlDescriptor(D).
+
+%% is_LocalControlDescriptor(#'LocalControlDescriptor'{streamMode = SM,
+%% reserveValue = RV,
+%% reserveGroup = RG,
+%% propertyParms = PP}) ->
+%% is_opt_StreamMode(SM) andalso
+%% is_opt_BOOLEAN(RV) andalso
+%% is_opt_BOOLEAN(RG) andalso
+%% is_LocalControlDescriptor_propertyParms(PP);
+%% is_LocalControlDescriptor(_) ->
+%% false.
+
+%% is_LocalControlDescriptor_propertyParms([]) ->
+%% true;
+%% is_LocalControlDescriptor_propertyParms([H|T]) ->
+%% is_PropertyParm(H) andalso is_LocalControlDescriptor_propertyParms(T);
+%% is_LocalControlDescriptor_propertyParms(_) ->
+%% false.
+
+%% chk_opt_LocalControlDescriptor(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_LocalControlDescriptor(LCD1, LCD2) ->
+%% chk_LocalControlDescriptor(LCD1, LCD2).
+
+%% chk_LocalControlDescriptor(LCD, LCD) ->
+%% chk_type(fun is_LocalControlDescriptor/1, 'LocalControlDescriptor', LCD);
+%% chk_LocalControlDescriptor(#'LocalControlDescriptor'{streamMode = SM1,
+%% reserveValue = RV1,
+%% reserveGroup = RG1,
+%% propertyParms = PP1},
+%% #'LocalControlDescriptor'{streamMode = SM2,
+%% reserveValue = RV2,
+%% reserveGroup = RG2,
+%% propertyParms = PP2}) ->
+%% validate(
+%% fun() -> chk_opt_StreamMode(SM1, SM2) end,
+%% 'LocalControlDescriptor'),
+%% validate(
+%% fun() -> chk_opt_BOOLEAN(RV1, RV2) end,
+%% 'LocalControlDescriptor_reserveValue'),
+%% validate(
+%% fun() -> chk_opt_BOOLEAN(RG1, RG2) end,
+%% 'LocalControlDescriptor_reserveGroup'),
+%% chk_LocalControlDescriptor_propertyParms(PP1, PP2),
+%% ok;
+%% chk_LocalControlDescriptor(LCD1, LCD2) ->
+%% wrong_type('LocalControlDescriptor', LCD1, LCD2).
+
+
+%% chk_LocalControlDescriptor_propertyParms([], []) ->
+%% ok;
+%% chk_LocalControlDescriptor_propertyParms([] = PP1, PP2) ->
+%% not_equal('LocalControlDescriptor_propertyParms', PP1, PP2);
+%% chk_LocalControlDescriptor_propertyParms(PP1, [] = PP2) ->
+%% not_equal('LocalControlDescriptor_propertyParms', PP1, PP2);
+%% chk_LocalControlDescriptor_propertyParms([H|T1], [H|T2]) ->
+%% case is_PropertyParm(H) of
+%% true ->
+%% chk_LocalControlDescriptor_propertyParms(T1, T2);
+%% false ->
+%% wrong_type('LocalControlDescriptor_propertyParms_val', H)
+%% end;
+%% chk_LocalControlDescriptor_propertyParms([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_PropertyParm(H1, H2) end,
+%% 'LocalControlDescriptor_propertyParms_val'),
+%% chk_LocalControlDescriptor_propertyParms(T1, T2);
+%% chk_LocalControlDescriptor_propertyParms(PP1, PP2) ->
+%% wrong_type('LocalControlDescriptor_propertyParms', PP1, PP2).
+
+
+%% %% -- StreamMode --
+
+%% is_opt_StreamMode(asn1_NOVALUE) ->
+%% true;
+%% is_opt_StreamMode(SM) ->
+%% is_StreamMode(SM).
+
+%% is_StreamMode(SM) ->
+%% lists:member(SM, [sendOnly, recvOnly, sendRecv, inactive, loopBack]).
+
+%% chk_opt_StreamMode(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_StreamMode(SM1, SM2) ->
+%% chk_StreamMode(SM1, SM2).
+
+%% chk_StreamMode(SM, SM) ->
+%% chk_type(fun is_StreamMode/1, 'StreamMode', SM);
+%% chk_StreamMode(SM1, SM2) ->
+%% case (is_StreamMode(SM1) andalso is_StreamMode(SM2)) of
+%% true ->
+%% not_equal('StreamMode', SM1, SM2);
+%% false ->
+%% wrong_type('StreamMode', SM1, SM2)
+%% end.
+
+
+%% %% -- PropertyParm --
+
+%% is_PropertyParm(#'PropertyParm'{name = N,
+%% value = V,
+%% extraInfo = I}) ->
+%% is_PkgdName(N) andalso
+%% is_PropertyParm_value(V) andalso
+%% is_PropertyParm_extraInfo(I);
+%% is_PropertyParm(_) ->
+%% false.
+
+%% is_PropertyParm_value([]) ->
+%% true;
+%% is_PropertyParm_value([H|T]) ->
+%% is_OCTET_STRING(H) andalso is_PropertyParm_value(T);
+%% is_PropertyParm_value(_) ->
+%% false.
+
+%% is_PropertyParm_extraInfo(asn1_NOVALUE) ->
+%% true;
+%% is_PropertyParm_extraInfo({Tag, Val}) ->
+%% is_PropertyParm_extraInfo_tag(Tag) andalso
+%% is_PropertyParm_extraInfo_val(Tag, Val);
+%% is_PropertyParm_extraInfo(_) ->
+%% false.
+
+%% is_PropertyParm_extraInfo_tag(Tag) ->
+%% Tags = [relation, range, sublist],
+%% lists:member(Tag, Tags).
+
+%% is_PropertyParm_extraInfo_val(relation, Val) ->
+%% is_Relation(Val);
+%% is_PropertyParm_extraInfo_val(range, Val) ->
+%% is_BOOLEAN(Val);
+%% is_PropertyParm_extraInfo_val(sublist, Val) ->
+%% is_BOOLEAN(Val).
+
+%% chk_PropertyParm(P, P) ->
+%% chk_type(fun is_PropertyParm/1, 'PropertyParm', P);
+%% chk_PropertyParm(#'PropertyParm'{name = N1,
+%% value = V1,
+%% extraInfo = I1},
+%% #'PropertyParm'{name = N2,
+%% value = V2,
+%% extraInfo = I2}) ->
+%% validate(fun() -> chk_PkgdName(N1, N2) end, 'PropertyParm'),
+%% chk_PropertyParm_value(V1, V2),
+%% chk_PropertyParm_extraInfo(I1, I2),
+%% ok;
+%% chk_PropertyParm(P1, P2) ->
+%% wrong_type('PropertyParm', P1, P2).
+
+%% chk_PropertyParm_value([], []) ->
+%% ok;
+%% chk_PropertyParm_value([] = V1, V2) ->
+%% not_equal('PropertyParm_value', V1, V2);
+%% chk_PropertyParm_value(V1, [] = V2) ->
+%% not_equal('PropertyParm_value', V1, V2);
+%% chk_PropertyParm_value([H|T1], [H|T2]) ->
+%% case is_OCTET_STRING(H) of
+%% true ->
+%% chk_PropertyParm_value(T1, T2);
+%% false ->
+%% wrong_type('PropertyParm_value_val', H)
+%% end;
+%% chk_PropertyParm_value([H1|_], [H2|_]) ->
+%% case (is_OCTET_STRING(H1) andalso is_OCTET_STRING(H2)) of
+%% true ->
+%% not_equal('PropertyParm_value_val', H1, H2);
+%% false ->
+%% wrong_type('PropertyParm_value_val', H1, H2)
+%% end;
+%% chk_PropertyParm_value(V1, V2) ->
+%% wrong_type('PropertyParm_value', V1, V2).
+
+%% chk_PropertyParm_extraInfo(EI, EI) ->
+%% chk_type(fun is_PropertyParm_extraInfo/1, 'PropertyParm_extraInfo', EI);
+%% chk_PropertyParm_extraInfo({Tag, Val1} = EI1, {Tag, Val2} = EI2) ->
+%% case (is_PropertyParm_extraInfo_tag(Tag) and
+%% is_PropertyParm_extraInfo_val(Tag, Val1) and
+%% is_PropertyParm_extraInfo_val(Tag, Val2)) of
+%% true ->
+%% chk_PropertyParm_extraInfo_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('PropertyParm_extraInfo', EI1, EI2)
+%% end;
+%% chk_PropertyParm_extraInfo({Tag1, Val1} = EI1, {Tag2, Val2} = EI2) ->
+%% case ((is_PropertyParm_extraInfo_tag(Tag1) and
+%% is_PropertyParm_extraInfo_val(Tag1, Val1)) and
+%% (is_PropertyParm_extraInfo_tag(Tag2) and
+%% is_PropertyParm_extraInfo_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('PropertyParm_extraInfo', EI1, EI2);
+%% false ->
+%% wrong_type('PropertyParm_extraInfo', EI1, EI2)
+%% end;
+%% chk_PropertyParm_extraInfo(EI1, EI2) ->
+%% wrong_type('PropertyParm_extraInfo', EI1, EI2).
+
+%% chk_PropertyParm_extraInfo_val(relation, Val1, Val2) ->
+%% validate(fun() -> chk_Relation(Val1, Val2) end, 'PropertyParm_extraInfo');
+%% chk_PropertyParm_extraInfo_val(range, Val1, Val2) ->
+%% validate(fun() -> chk_BOOLEAN(Val1, Val2) end, 'PropertyParm_extraInfo');
+%% chk_PropertyParm_extraInfo_val(sublist, Val1, Val2) ->
+%% validate(fun() -> chk_BOOLEAN(Val1, Val2) end, 'PropertyParm_extraInfo').
+
+
+%% %% -- Name --
+
+is_Name(N) ->
+ %% Binary: is_OCTET_STRING(N, {exact, 2}).
+ case is_OCTET_STRING(N, {range, 1, 64}) of
+ true ->
+ is_NAME(N);
+ false ->
+ false
+ end.
+
+is_NAME([H|T]) when H =< $z, $a =< H ->
+ is_NAME2(T);
+is_NAME([H|T]) when H =< $Z, $A =< H ->
+ is_NAME2(T);
+is_NAME(_) ->
+ false.
+
+is_NAME2([]) ->
+ true;
+is_NAME2([$_|T]) ->
+ is_NAME2(T);
+is_NAME2([H|T]) when H =< $z, $a =< H ->
+ is_NAME2(T);
+is_NAME2([H|T]) when H =< $Z, $A =< H ->
+ is_NAME2(T);
+is_NAME2([H|T]) when H =< $9, $0 =< H ->
+ is_NAME2(T);
+is_NAME2(_) ->
+ false.
+
+
+
+%% chk_Name(N, N) ->
+%% chk_type(fun is_Name/1, 'Name', N);
+%% chk_Name(N1, N2) ->
+%% case (is_Name(N1) andalso is_Name(N2)) of
+%% true ->
+%% not_equal('Name', N1, N2);
+%% false ->
+%% wrong_type('Name', N1, N2)
+%% end.
+
+
+%% %% -- PkgdName --
+
+%% PkgdName is either "AB/CD" or just plain "ABCD"
+%% Note that in ASN.1 the parts is exactly 2 char
+%% each, unless you don't use the native config
+%% option. In text and in binary without the native
+%% option, it is 63 + 1 chars for each.
+is_PkgdName(N) ->
+ d("is_PkgdName -> entry with"
+ "~n N: ~p", [N]),
+ case string:tokens(N, "/") of
+ ["*" = PackageName, "*" = ItemID] ->
+ d("is_PkgdName -> tokenized (0): "
+ "~n PackageName: ~p"
+ "~n ItemID: ~p", [PackageName, ItemID]),
+ true;
+ [PackageName, "*" = ItemID] ->
+ d("is_PkgdName -> tokenized (1): "
+ "~n PackageName: ~p"
+ "~n ItemID: ~p", [PackageName, ItemID]),
+ is_Name(PackageName);
+ [PackageName, ItemID] ->
+ d("is_PkgdName -> tokenized (2): "
+ "~n PackageName: ~p"
+ "~n ItemID: ~p", [PackageName, ItemID]),
+ is_Name(PackageName) andalso is_Name(ItemID);
+ _ ->
+ is_Name(N)
+ end.
+
+%% chk_PkgdName(N, N) ->
+%% case is_PkgdName(N) of
+%% true ->
+%% ok;
+%% false ->
+%% wrong_type('PkgdName', N, N)
+%% end;
+%% chk_PkgdName(N1, N2) ->
+%% case (is_PkgdName(N1) andalso is_PkgdName(N2)) of
+%% true ->
+%% not_equal('PkgdName', N1, N2);
+%% false ->
+%% wrong_type('PkgdName', N1, N2)
+%% end.
+
+
+%% %% -- Relation --
+
+is_Relation(R) ->
+ lists:member(R, [greaterThan, smallerThan, unequalTo]).
+
+%% chk_Relation(R, R) ->
+%% chk_type(fun is_Relation/1, 'Relation', R);
+%% chk_Relation(R1, R2) ->
+%% case (is_Relation(R1) andalso is_Relation(R2)) of
+%% true ->
+%% not_equal('Relation', R1, R2);
+%% false ->
+%% wrong_type('Relation', R1, R2)
+%% end.
+
+
+%% %% -- LocalRemoteDescriptor --
+
+%% is_opt_LocalRemoteDescriptor(D) ->
+%% is_OPTIONAL(fun is_LocalRemoteDescriptor/1, D).
+
+%% is_LocalRemoteDescriptor(#'LocalRemoteDescriptor'{propGrps = PGs}) ->
+%% is_LocalRemoteDescriptor_propGrps(PGs);
+%% is_LocalRemoteDescriptor(_) ->
+%% false.
+
+%% is_LocalRemoteDescriptor_propGrps([]) ->
+%% true;
+%% is_LocalRemoteDescriptor_propGrps([H|T]) ->
+%% is_PropertyGroup(H) andalso is_LocalRemoteDescriptor_propGrps(T);
+%% is_LocalRemoteDescriptor_propGrps(_) ->
+%% false.
+
+%% chk_opt_LocalRemoteDescriptor(D1, D2) ->
+%% chk_OPTIONAL('LocalRemoteDescriptor', D1, D2,
+%% fun is_LocalRemoteDescriptor/1,
+%% fun chk_LocalRemoteDescriptor/2).
+
+%% chk_LocalRemoteDescriptor(LRD, LRD) ->
+%% chk_type(fun is_LocalRemoteDescriptor/1, 'LocalRemoteDescriptor', LRD);
+%% chk_LocalRemoteDescriptor(#'LocalRemoteDescriptor'{propGrps = PG1},
+%% #'LocalRemoteDescriptor'{propGrps = PG2}) ->
+%% chk_LocalRemoteDescriptor_propGrps(PG1, PG2),
+%% ok;
+%% chk_LocalRemoteDescriptor(LRD1, LRD2) ->
+%% wrong_type('LocalRemoteDescriptor', LRD1, LRD2).
+
+%% chk_LocalRemoteDescriptor_propGrps([], []) ->
+%% ok;
+%% chk_LocalRemoteDescriptor_propGrps([] = PG1, PG2) ->
+%% not_equal('LocalRemoteDescriptor_propGrps', PG1, PG2);
+%% chk_LocalRemoteDescriptor_propGrps(PG1, [] = PG2) ->
+%% not_equal('LocalRemoteDescriptor_propGrps', PG1, PG2);
+%% chk_LocalRemoteDescriptor_propGrps([H|T1], [H|T2]) ->
+%% case is_PropertyGroup(H) of
+%% true ->
+%% chk_LocalRemoteDescriptor_propGrps(T1, T2);
+%% false ->
+%% wrong_type('LocalRemoteDescriptor_propGrps_val', H)
+%% end;
+%% chk_LocalRemoteDescriptor_propGrps([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_PropertyGroup(H1, H2) end,
+%% 'LocalRemoteDescriptor_propGrps_val'),
+%% chk_LocalRemoteDescriptor_propGrps(T1, T2);
+%% chk_LocalRemoteDescriptor_propGrps(PG1, PG2) ->
+%% wrong_type('LocalRemoteDescriptor_propGrps', PG1, PG2).
+
+
+%% %% -- PropertyGroup --
+
+%% is_PropertyGroup([]) ->
+%% true;
+%% is_PropertyGroup([H|T]) ->
+%% is_PropertyParm(H) andalso is_PropertyGroup(T);
+%% is_PropertyGroup(_) ->
+%% false.
+
+%% chk_PropertyGroup([], []) ->
+%% ok;
+%% chk_PropertyGroup([] = PG1, PG2) ->
+%% not_equal('PropertyGroup', PG1, PG2);
+%% chk_PropertyGroup(PG1, [] = PG2) ->
+%% not_equal('PropertyGroup', PG1, PG2);
+%% chk_PropertyGroup([H|T1], [H|T2]) ->
+%% case is_PropertyParm(H) of
+%% true ->
+%% chk_PropertyGroup(T1, T2);
+%% false ->
+%% wrong_type('PropertyGroup_val', H)
+%% end;
+%% chk_PropertyGroup([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_PropertyParm(H1, H2) end, 'PropertyGroup_val'),
+%% chk_PropertyGroup(T1, T2);
+%% chk_PropertyGroup(PG1, PG2) ->
+%% wrong_type('PropertyGroup', PG1, PG2).
+
+
+%% %% -- TerminationStateDescriptor --
+
+%% is_opt_TerminationStateDescriptor(D) ->
+%% is_OPTIONAL(fun is_TerminationStateDescriptor/1, D).
+
+%% is_TerminationStateDescriptor(
+%% #'TerminationStateDescriptor'{propertyParms = PP,
+%% eventBufferControl = EBC,
+%% serviceState = SS}) ->
+%% is_TerminationStateDescriptor_propertyParms(PP) andalso
+%% is_opt_EventBufferControl(EBC) andalso
+%% is_opt_ServiceState(SS);
+%% is_TerminationStateDescriptor(_) ->
+%% false.
+
+%% is_TerminationStateDescriptor_propertyParms([]) ->
+%% true;
+%% is_TerminationStateDescriptor_propertyParms([H|T]) ->
+%% is_PropertyParm(H) andalso is_TerminationStateDescriptor_propertyParms(T);
+%% is_TerminationStateDescriptor_propertyParms(_) ->
+%% false.
+
+%% chk_opt_TerminationStateDescriptor(D1, D2) ->
+%% chk_OPTIONAL('TerminationStateDescriptor', D1, D2,
+%% fun is_TerminationStateDescriptor/1,
+%% fun chk_TerminationStateDescriptor/2).
+
+%% chk_TerminationStateDescriptor(D, D) ->
+%% chk_type(fun is_TerminationStateDescriptor/1,
+%% 'TerminationStateDescriptor', D);
+%% chk_TerminationStateDescriptor(
+%% #'TerminationStateDescriptor'{propertyParms = PP1,
+%% eventBufferControl = EBC1,
+%% serviceState = SS1},
+%% #'TerminationStateDescriptor'{propertyParms = PP2,
+%% eventBufferControl = EBC2,
+%% serviceState = SS2}) ->
+%% chk_TerminationStateDescriptor_propertyParms(PP1, PP2),
+%% validate(
+%% fun() ->
+%% chk_opt_EventBufferControl(EBC1, EBC2)
+%% end,
+%% 'TerminationStateDescriptor'),
+%% validate(
+%% fun() ->
+%% chk_opt_ServiceState(SS1, SS2)
+%% end,
+%% 'TerminationStateDescriptor'),
+%% ok;
+%% chk_TerminationStateDescriptor(D1, D2) ->
+%% wrong_type('TerminationStateDescriptor', D1, D2).
+
+
+%% chk_TerminationStateDescriptor_propertyParms([], []) ->
+%% ok;
+%% chk_TerminationStateDescriptor_propertyParms([] = P1, P2) ->
+%% not_equal('TerminationStateDescriptor_propertyParms', P1, P2);
+%% chk_TerminationStateDescriptor_propertyParms(P1, [] = P2) ->
+%% not_equal('TerminationStateDescriptor_propertyParms', P1, P2);
+%% chk_TerminationStateDescriptor_propertyParms([H|T1], [H|T2]) ->
+%% case is_PropertyParm(H) of
+%% true ->
+%% chk_TerminationStateDescriptor_propertyParms(T1, T2);
+%% false ->
+%% wrong_type('TerminationStateDescriptor_propertyParms_val', H)
+%% end;
+%% chk_TerminationStateDescriptor_propertyParms([H1|_], [H2|_]) ->
+%% case (is_PropertyParm(H1) andalso is_PropertyParm(H2)) of
+%% true ->
+%% not_equal('TerminationStateDescriptor_propertyParms_val', H1, H2);
+%% false ->
+%% wrong_type('TerminationStateDescriptor_propertyParms_val', H1, H2)
+%% end;
+%% chk_TerminationStateDescriptor_propertyParms(P1, P2) ->
+%% wrong_type('TerminationStateDescriptor_propertyParms', P1, P2).
+
+
+%% %% -- EventBufferControl --
+
+%% is_opt_EventBufferControl(asn1_NOVALUE) ->
+%% true;
+%% is_opt_EventBufferControl(EBC) ->
+%% is_EventBufferControl(EBC).
+
+%% is_EventBufferControl(EBC) ->
+%% lists:member(EBC, [off, lockStep]).
+
+%% chk_opt_EventBufferControl(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_EventBufferControl(EBC1, EBC2) ->
+%% chk_EventBufferControl(EBC1, EBC2).
+
+%% chk_EventBufferControl(EBC, EBC) ->
+%% chk_type(fun is_EventBufferControl/1, 'EventBufferControl', EBC);
+%% chk_EventBufferControl(EBC1, EBC2) ->
+%% case (is_EventBufferControl(EBC1) andalso is_EventBufferControl(EBC2)) of
+%% true ->
+%% not_equal('EventBufferControl', EBC1, EBC2);
+%% false ->
+%% wrong_type('EventBufferControl', EBC1, EBC2)
+%% end.
+
+
+%% %% -- ServiceState --
+
+%% is_opt_ServiceState(asn1_NOVALUE) ->
+%% true;
+%% is_opt_ServiceState(SS) ->
+%% is_ServiceState(SS).
+
+%% is_ServiceState(SS) ->
+%% lists:member(SS, [test, outOfSvc, inSvc]).
+
+%% chk_opt_ServiceState(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_ServiceState(SS1, SS2) ->
+%% chk_ServiceState(SS1, SS2).
+
+%% chk_ServiceState(SS, SS) ->
+%% chk_type(fun is_ServiceState/1, 'ServiceState', SS);
+%% chk_ServiceState(SS1, SS2) ->
+%% case (is_ServiceState(SS1) andalso is_ServiceState(SS2)) of
+%% true ->
+%% not_equal('ServiceState', SS1, SS2);
+%% false ->
+%% wrong_type('ServiceState', SS1, SS2)
+%% end.
+
+
+%% %% -- MuxDescriptor --
+
+%% is_MuxDescriptor(#'MuxDescriptor'{muxType = MT,
+%% termList = TL,
+%% nonStandardData = NSD}) ->
+%% is_MuxType(MT) andalso
+%% is_MuxDescriptor_termList(TL) andalso
+%% is_NonStandardData(NSD);
+%% is_MuxDescriptor(_) ->
+%% false.
+
+%% is_MuxDescriptor_termList([]) ->
+%% true;
+%% is_MuxDescriptor_termList([H|T]) ->
+%% is_TerminationID(H) andalso is_MuxDescriptor_termList(T);
+%% is_MuxDescriptor_termList(_) ->
+%% false.
+
+%% chk_MuxDescriptor(D, D) ->
+%% chk_type(fun is_MuxDescriptor/1, 'MuxDescriptor', D);
+%% chk_MuxDescriptor(#'MuxDescriptor'{muxType = MT1,
+%% termList = TL1,
+%% nonStandardData = NSD1},
+%% #'MuxDescriptor'{muxType = MT2,
+%% termList = TL2,
+%% nonStandardData = NSD2}) ->
+%% validate(fun() -> chk_MuxType(MT1, MT2) end, 'MuxDescriptor'),
+%% chk_MuxDescriptor_termList(TL1, TL2),
+%% validate(fun() -> chk_NonStandardData(NSD1, NSD2) end, 'MuxDescriptor'),
+%% ok;
+%% chk_MuxDescriptor(D1, D2) ->
+%% wrong_type('MuxDescriptor', D1, D2).
+
+%% chk_MuxDescriptor_termList([], []) ->
+%% ok;
+%% chk_MuxDescriptor_termList([] = TL1, TL2) ->
+%% not_equal('MuxDescriptor_termList', TL1, TL2);
+%% chk_MuxDescriptor_termList(TL1, [] = TL2) ->
+%% not_equal('MuxDescriptor_termList', TL1, TL2);
+%% chk_MuxDescriptor_termList([H|T1], [H|T2]) ->
+%% case is_TerminationID(H) of
+%% true ->
+%% chk_MuxDescriptor_termList(T1, T2);
+%% false ->
+%% wrong_type('MuxDescriptor_termList_val', H)
+%% end;
+%% chk_MuxDescriptor_termList([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_TerminationID(H1, H2) end,
+%% 'MuxDescriptor_termList_val'),
+%% chk_MuxDescriptor_termList(T1, T2);
+%% chk_MuxDescriptor_termList(TL1, TL2) ->
+%% wrong_type('MuxDescriptor_termList', TL1, TL2).
+
+
+%% %% -- MuxType --
+
+%% is_MuxType(MT) ->
+%% lists:member(MT, [h221, h223, h226, v76, nx64k]).
+
+%% chk_MuxType(MT, MT) ->
+%% chk_type(fun is_MuxType/1, 'MuxType', MT);
+%% chk_MuxType(MT1, MT2) ->
+%% case (is_MuxType(MT1) andalso is_MuxType(MT2)) of
+%% true ->
+%% not_equal('MuxType', MT1, MT2);
+%% false ->
+%% wrong_type('MuxType', MT1, MT2)
+%% end.
+
+
+%% %% -- StreamID --
+
+is_opt_StreamID(asn1_NOVALUE) ->
+ true;
+is_opt_StreamID(V) ->
+ is_StreamID(V).
+
+is_StreamID(V) -> is_INTEGER(V, {range, 0, 65535}).
+
+%% chk_opt_StreamID(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_StreamID(V1, V2) ->
+%% chk_StreamID(V1, V2).
+
+%% chk_StreamID(ID, ID) ->
+%% chk_type(fun is_StreamID/1, 'StreamID', ID);
+%% chk_StreamID(ID1, ID2) ->
+%% case (is_StreamID(ID1) andalso is_StreamID(ID2)) of
+%% true ->
+%% not_equal('StreamID', ID1, ID2);
+%% false ->
+%% wrong_type('StreamID', ID1, ID2)
+%% end.
+
+
+%% %% -- EventsDescriptor --
+
+%% is_EventsDescriptor(#'EventsDescriptor'{requestID = RID,
+%% eventList = EVL}) ->
+%% d("is_EventsDescriptor -> entry with"
+%% "~n RID: ~p"
+%% "~n EVL: ~p", [RID, EVL]),
+%% is_opt_RequestID(RID) andalso is_EventsDescriptor_eventList(EVL);
+%% is_EventsDescriptor(_) ->
+%% false.
+
+%% is_EventsDescriptor_eventList([]) ->
+%% true;
+%% is_EventsDescriptor_eventList([H|T]) ->
+%% is_RequestedEvent(H) andalso is_EventsDescriptor_eventList(T);
+%% is_EventsDescriptor_eventList(_) ->
+%% false.
+
+%% chk_EventsDescriptor(D, D) ->
+%% chk_type(fun is_EventsDescriptor/1, 'EventsDescriptor', D);
+%% chk_EventsDescriptor(#'EventsDescriptor'{requestID = RID1,
+%% eventList = EVL1},
+%% #'EventsDescriptor'{requestID = RID2,
+%% eventList = EVL2}) ->
+%% validate(fun() -> chk_opt_RequestID(RID1, RID2) end, 'EventsDescriptor'),
+%% chk_EventsDescriptor_eventList(EVL1, EVL2),
+%% ok;
+%% chk_EventsDescriptor(D1, D2) ->
+%% wrong_type('EventsDescriptor', D1, D2).
+
+%% chk_EventsDescriptor_eventList([], []) ->
+%% ok;
+%% chk_EventsDescriptor_eventList([] = EVL1, EVL2) ->
+%% not_equal('EventsDescriptor_eventList', EVL1, EVL2);
+%% chk_EventsDescriptor_eventList(EVL1, [] = EVL2) ->
+%% not_equal('EventsDescriptor_eventList', EVL1, EVL2);
+%% chk_EventsDescriptor_eventList([H|T1], [H|T2]) ->
+%% case is_RequestedEvent(H) of
+%% true ->
+%% chk_EventsDescriptor_eventList(T1, T2);
+%% false ->
+%% wrong_type('EventsDescriptor_eventList_val', H)
+%% end;
+%% chk_EventsDescriptor_eventList([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_RequestedEvent(H1, H2) end,
+%% 'EventsDescriptor_eventList_val'),
+%% chk_EventsDescriptor_eventList(T1, T2);
+%% chk_EventsDescriptor_eventList(EVL1, EVL2) ->
+%% wrong_type('EventsDescriptor_eventList', EVL1, EVL2).
+
+
+%% %% -- RequestedEvent --
+
+%% is_RequestedEvent(#'RequestedEvent'{pkgdName = N,
+%% streamID = SID,
+%% eventAction = EA,
+%% evParList = EPL}) ->
+%% d("is_RequestedEvent -> entry with"
+%% "~n N: ~p"
+%% "~n SID: ~p"
+%% "~n EA: ~p"
+%% "~n EPL: ~p", [N, SID, EA, EPL]),
+%% is_PkgdName(N) andalso
+%% is_opt_StreamID(SID) andalso
+%% is_opt_RequestedActions(EA) andalso
+%% is_RequestedEvent_evParList(EPL);
+%% is_RequestedEvent(_) ->
+%% false.
+
+%% is_RequestedEvent_evParList([]) ->
+%% true;
+%% is_RequestedEvent_evParList([H|T]) ->
+%% is_EventParameter(H) andalso is_RequestedEvent_evParList(T);
+%% is_RequestedEvent_evParList(_) ->
+%% false.
+
+%% chk_RequestedEvent(RE, RE) ->
+%% chk_type(fun is_RequestedEvent/1, 'RequestedEvent', RE);
+%% chk_RequestedEvent(#'RequestedEvent'{pkgdName = N1,
+%% streamID = SID1,
+%% eventAction = EA1,
+%% evParList = EPL1},
+%% #'RequestedEvent'{pkgdName = N2,
+%% streamID = SID2,
+%% eventAction = EA2,
+%% evParList = EPL2}) ->
+%% validate(fun() -> chk_PkgdName(N1, N2) end, 'RequestedEvent'),
+%% validate(fun() -> chk_opt_StreamID(SID1, SID2) end, 'RequestedEvent'),
+%% validate(fun() -> chk_opt_RequestedActions(EA1, EA2) end,
+%% 'RequestedEvent'),
+%% chk_RequestedEvent_evParList(EPL1, EPL2),
+%% ok;
+%% chk_RequestedEvent(RE1, RE2) ->
+%% wrong_type('RequestedEvent', RE1, RE2).
+
+%% chk_RequestedEvent_evParList([], []) ->
+%% ok;
+%% chk_RequestedEvent_evParList([] = EPL1, EPL2) ->
+%% not_equal('RequestedEvent_evParList', EPL1, EPL2);
+%% chk_RequestedEvent_evParList(EPL1, [] = EPL2) ->
+%% not_equal('RequestedEvent_evParList', EPL1, EPL2);
+%% chk_RequestedEvent_evParList([H|T1], [H|T2]) ->
+%% case is_EventParameter(H) of
+%% true ->
+%% chk_RequestedEvent_evParList(T1, T2);
+%% false ->
+%% wrong_type('RequestedEvent_evParList_val', H)
+%% end;
+%% chk_RequestedEvent_evParList([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_EventParameter(H1, H2) end,
+%% 'RequestedEvent_evParList_val'),
+%% chk_RequestedEvent_evParList(T1, T2);
+%% chk_RequestedEvent_evParList(EPL1, EPL2) ->
+%% wrong_type('RequestedEvent_evParList', EPL1, EPL2).
+
+
+%% %% -- RequestedActions --
+
+%% is_opt_RequestedActions(asn1_NOVALUE) ->
+%% true;
+%% is_opt_RequestedActions(RA) ->
+%% is_RequestedActions(RA).
+
+%% is_RequestedActions(#'RequestedActions'{keepActive = KA,
+%% eventDM = EDM,
+%% secondEvent = SE,
+%% signalsDescriptor = SD}) ->
+%% d("is_RequestedActions -> entry with"
+%% "~n KA: ~p"
+%% "~n EDM: ~p"
+%% "~n SE: ~p"
+%% "~n SD: ~p", [KA, EDM, SE, SD]),
+%% is_opt_BOOLEAN(KA) andalso
+%% is_opt_EventDM(EDM) andalso
+%% is_opt_SecondEventsDescriptor(SE) andalso
+%% is_opt_SignalsDescriptor(SD);
+%% is_RequestedActions(_) ->
+%% false.
+
+%% chk_opt_RequestedActions(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_RequestedActions(RA1, RA2) ->
+%% chk_RequestedActions(RA1, RA2).
+
+%% chk_RequestedActions(RA, RA) ->
+%% chk_type(fun is_RequestedActions/1, 'RequestedActions', RA);
+%% chk_RequestedActions(#'RequestedActions'{keepActive = KA1,
+%% eventDM = EDM1,
+%% secondEvent = SA1,
+%% signalsDescriptor = SD1},
+%% #'RequestedActions'{keepActive = KA2,
+%% eventDM = EDM2,
+%% secondEvent = SA2,
+%% signalsDescriptor = SD2}) ->
+%% validate(fun() -> chk_opt_BOOLEAN(KA1, KA2) end, 'RequestedActions'),
+%% validate(fun() -> chk_opt_EventDM(EDM1, EDM2) end, 'RequestedActions'),
+%% validate(fun() -> chk_opt_SecondEventsDescriptor(SA1, SA2) end,
+%% 'RequestedActions'),
+%% validate(fun() -> chk_opt_SignalsDescriptor(SD1, SD2) end,
+%% 'RequestedActions'),
+%% ok;
+%% chk_RequestedActions(RA1, RA2) ->
+%% wrong_type('RequestedActions', RA1, RA2).
+
+
+%% %% -- EventDM --
+
+%% is_opt_EventDM(EDM) ->
+%% is_OPTIONAL(fun is_EventDM/1, EDM).
+
+%% is_EventDM({Tag, Val}) ->
+%% is_EventDM_tag(Tag) andalso is_EventDM_val(Tag, Val);
+%% is_EventDM(_) ->
+%% false.
+
+%% is_EventDM_tag(Tag) ->
+%% Tags = [digitMapName, digitMapValue],
+%% lists:member(Tag, Tags).
+
+%% is_EventDM_val(digitMapName, Val) ->
+%% is_DigitMapName(Val);
+%% is_EventDM_val(digitMapValue, Val) ->
+%% is_DigitMapValue(Val).
+
+%% chk_opt_EventDM(EDM1, EDM2) ->
+%% chk_OPTIONAL('EventDM', EDM1, EDM2, fun is_EventDM/1, fun chk_EventDM/2).
+
+%% chk_EventDM(EDM, EDM) ->
+%% chk_type(fun is_EventDM/1, 'EventDM', EDM);
+%% chk_EventDM({Tag, Val1} = EDM1, {Tag, Val2} = EDM2) ->
+%% case (is_EventDM_tag(Tag) andalso
+%% is_EventDM_val(Tag, Val1) andalso
+%% is_EventDM_val(Tag, Val2)) of
+%% true ->
+%% chk_EventDM_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('EventDM', EDM1, EDM2)
+%% end;
+%% chk_EventDM({Tag1, Val1} = EDM1, {Tag2, Val2} = EDM2) ->
+%% case ((is_EventDM_tag(Tag1) andalso
+%% is_EventDM_val(Tag1, Val1)) andalso
+%% (is_EventDM_tag(Tag2) andalso
+%% is_EventDM_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('EventDM', EDM1, EDM2);
+%% false ->
+%% wrong_type('EventDM', EDM1, EDM2)
+%% end;
+%% chk_EventDM(EDM1, EDM2) ->
+%% wrong_type('EventDM', EDM1, EDM2).
+
+%% chk_EventDM_val(digitMapName, Val1, Val2) ->
+%% validate(fun() -> chk_DigitMapName(Val1, Val2) end, 'EventDM');
+%% chk_EventDM_val(digitMapValue, Val1, Val2) ->
+%% validate(fun() -> chk_DigitMapValue(Val1, Val2) end, 'EventDM').
+
+
+%% %% -- SecondEventsDescriptor --
+
+%% is_opt_SecondEventsDescriptor(asn1_NOVALUE) ->
+%% true;
+%% is_opt_SecondEventsDescriptor(D) ->
+%% is_SecondEventsDescriptor(D).
+
+%% is_SecondEventsDescriptor(#'SecondEventsDescriptor'{requestID = RID,
+%% eventList = EL}) ->
+%% is_opt_RequestID(RID) andalso is_SecondEventsDescriptor_eventList(EL);
+%% is_SecondEventsDescriptor(_) ->
+%% false.
+
+%% is_SecondEventsDescriptor_eventList([]) ->
+%% true;
+%% is_SecondEventsDescriptor_eventList([H|T]) ->
+%% is_SecondRequestedEvent(H) andalso is_SecondEventsDescriptor_eventList(T);
+%% is_SecondEventsDescriptor_eventList(_) ->
+%% false.
+
+%% chk_opt_SecondEventsDescriptor(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_SecondEventsDescriptor(D1, D2) ->
+%% chk_SecondEventsDescriptor(D1, D2).
+
+%% chk_SecondEventsDescriptor(D, D) ->
+%% chk_type(fun is_SecondEventsDescriptor/1, 'SecondEventsDescriptor', D);
+%% chk_SecondEventsDescriptor(#'SecondEventsDescriptor'{requestID = RID1,
+%% eventList = EL1},
+%% #'SecondEventsDescriptor'{requestID = RID2,
+%% eventList = EL2}) ->
+%% validate(fun() -> chk_opt_RequestID(RID1, RID2) end,
+%% 'SecondEventsDescriptor'),
+%% chk_SecondEventsDescriptor_eventList(EL1, EL2),
+%% ok;
+%% chk_SecondEventsDescriptor(D1, D2) ->
+%% wrong_type('SecondEventsDescriptor', D1, D2).
+
+%% chk_SecondEventsDescriptor_eventList([], []) ->
+%% ok;
+%% chk_SecondEventsDescriptor_eventList([] = EL1, EL2) ->
+%% not_equal('SecondEventsDescriptor_eventList', EL1, EL2);
+%% chk_SecondEventsDescriptor_eventList(EL1, [] = EL2) ->
+%% not_equal('SecondEventsDescriptor_eventList', EL1, EL2);
+%% chk_SecondEventsDescriptor_eventList([H|T1], [H|T2]) ->
+%% case is_SecondRequestedEvent(H) of
+%% true ->
+%% chk_SecondEventsDescriptor_eventList(T1, T2);
+%% false ->
+%% wrong_type('SecondEventsDescriptor_eventList_val', H)
+%% end;
+%% chk_SecondEventsDescriptor_eventList([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_SecondRequestedEvent(H1, H2) end,
+%% 'SecondEventsDescriptor_eventList_val'),
+%% chk_SecondEventsDescriptor_eventList(T1, T2);
+%% chk_SecondEventsDescriptor_eventList(L1, L2) ->
+%% wrong_type('SecondEventsDescriptor_eventList_val', L1, L2).
+
+
+%% %% -- SecondRequestedEvent --
+
+%% is_SecondRequestedEvent(#'SecondRequestedEvent'{pkgdName = N,
+%% streamID = SID,
+%% eventAction = EA,
+%% evParList = EPL}) ->
+%% is_PkgdName(N) andalso
+%% is_opt_StreamID(SID) andalso
+%% is_opt_SecondRequestedActions(EA) andalso
+%% is_SecondRequestedEvent_evParList(EPL);
+%% is_SecondRequestedEvent(_) ->
+%% false.
+
+%% is_SecondRequestedEvent_evParList([]) ->
+%% true;
+%% is_SecondRequestedEvent_evParList([H|T]) ->
+%% is_EventParameter(H) andalso is_SecondRequestedEvent_evParList(T);
+%% is_SecondRequestedEvent_evParList(_) ->
+%% false.
+
+%% chk_SecondRequestedEvent(RE, RE) ->
+%% chk_type(fun is_SecondRequestedEvent/1, 'SecondRequestedEvent', RE);
+%% chk_SecondRequestedEvent(#'SecondRequestedEvent'{pkgdName = N1,
+%% streamID = SID1,
+%% eventAction = EA1,
+%% evParList = EPL1},
+%% #'SecondRequestedEvent'{pkgdName = N2,
+%% streamID = SID2,
+%% eventAction = EA2,
+%% evParList = EPL2}) ->
+%% validate(fun() -> chk_PkgdName(N1, N2) end, 'SecondRequestedEvent'),
+%% validate(fun() -> chk_opt_StreamID(SID1, SID2) end,
+%% 'SecondRequestedEvent'),
+%% validate(fun() -> chk_opt_SecondRequestedActions(EA1, EA2) end,
+%% 'SecondRequestedEvent'),
+%% chk_SecondRequestedEvent_evParList(EPL1, EPL2),
+%% ok;
+%% chk_SecondRequestedEvent(RE1, RE2) ->
+%% wrong_type('SecondRequestedEvent', RE1, RE2).
+
+%% chk_SecondRequestedEvent_evParList([], []) ->
+%% ok;
+%% chk_SecondRequestedEvent_evParList([] = EPL1, EPL2) ->
+%% not_equal('SecondRequestedEvent_evParList', EPL1, EPL2);
+%% chk_SecondRequestedEvent_evParList(EPL1, [] = EPL2) ->
+%% not_equal('SecondRequestedEvent_evParList', EPL1, EPL2);
+%% chk_SecondRequestedEvent_evParList([H|T1], [H|T2]) ->
+%% case is_EventParameter(H) of
+%% true ->
+%% chk_SecondRequestedEvent_evParList(T1, T2);
+%% false ->
+%% wrong_type('SecondRequestedEvent_evParList_val', H)
+%% end;
+%% chk_SecondRequestedEvent_evParList([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_EventParameter(H1, H2) end,
+%% 'SecondRequestedEvent_evParList_val'),
+%% chk_SecondRequestedEvent_evParList(T1, T2);
+%% chk_SecondRequestedEvent_evParList(EPL1, EPL2) ->
+%% wrong_type('SecondRequestedEvent_evParList', EPL1, EPL2).
+
+
+%% %% -- SecondRequestedActions --
+
+%% is_opt_SecondRequestedActions(asn1_NOVALUE) ->
+%% true;
+%% is_opt_SecondRequestedActions(SRA) ->
+%% is_SecondRequestedActions(SRA).
+
+%% is_SecondRequestedActions(#'SecondRequestedActions'{keepActive = KA,
+%% eventDM = EDM,
+%% signalsDescriptor = SD}) ->
+%% is_opt_BOOLEAN(KA) andalso
+%% is_opt_EventDM(EDM) andalso
+%% is_opt_SignalsDescriptor(SD);
+%% is_SecondRequestedActions(_) ->
+%% false.
+
+%% chk_opt_SecondRequestedActions(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_SecondRequestedActions(SRA1, SRA2) ->
+%% chk_SecondRequestedActions(SRA1, SRA2).
+
+%% chk_SecondRequestedActions(SRA, SRA) ->
+%% chk_type(fun is_SecondRequestedActions/1, 'SecondRequestedActions', SRA);
+%% chk_SecondRequestedActions(
+%% #'SecondRequestedActions'{keepActive = KA1,
+%% eventDM = EDM1,
+%% signalsDescriptor = SD1},
+%% #'SecondRequestedActions'{keepActive = KA2,
+%% eventDM = EDM2,
+%% signalsDescriptor = SD2}) ->
+%% validate(fun() -> chk_opt_BOOLEAN(KA1, KA2) end,
+%% 'SecondRequestedActions'),
+%% validate(fun() -> chk_opt_EventDM(EDM1, EDM2) end,
+%% 'SecondRequestedActions'),
+%% validate(fun() -> chk_opt_SignalsDescriptor(SD1, SD2) end,
+%% 'SecondRequestedActions'),
+%% ok;
+%% chk_SecondRequestedActions(SRA1, SRA2) ->
+%% wrong_type('SecondRequestedActions', SRA1, SRA2).
+
+
+%% %% -- EventBufferDescriptor --
+
+is_EventBufferDescriptor([]) ->
+ true;
+is_EventBufferDescriptor([H|T]) ->
+ is_EventSpec(H) andalso is_EventBufferDescriptor(T);
+is_EventBufferDescriptor(_) ->
+ false.
+
+%% chk_EventBufferDescriptor([], []) ->
+%% ok;
+%% chk_EventBufferDescriptor([] = D1, D2) ->
+%% not_equal('EventBufferDescriptor', D1, D2);
+%% chk_EventBufferDescriptor(D1, [] = D2) ->
+%% not_equal('EventBufferDescriptor', D1, D2);
+%% chk_EventBufferDescriptor([H|T1], [H|T2]) ->
+%% case is_EventSpec(H) of
+%% true ->
+%% chk_EventBufferDescriptor(T1, T2);
+%% false ->
+%% wrong_type('EventBufferDescriptor_val', H)
+%% end;
+%% chk_EventBufferDescriptor([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_EventSpec(H1, H2) end,
+%% 'EventBufferDescriptor_val'),
+%% chk_EventBufferDescriptor(T1, T2);
+%% chk_EventBufferDescriptor(D1, D2) ->
+%% wrong_type('EventBufferDescriptor_val', D1, D2).
+
+
+%% %% -- EventSpec --
+
+is_EventSpec(#'EventSpec'{eventName = N,
+ streamID = SID,
+ eventParList = EPL}) ->
+ is_EventName(N) andalso
+ is_opt_StreamID(SID) andalso
+ is_EventSpec_eventParList(EPL);
+is_EventSpec(_) ->
+ false.
+
+is_EventSpec_eventParList([]) ->
+ true;
+is_EventSpec_eventParList([H|T]) ->
+ is_EventParameter(H) andalso is_EventSpec_eventParList(T);
+is_EventSpec_eventParList(_) ->
+ false.
+
+%% chk_EventSpec(ES, ES) ->
+%% chk_type(fun is_EventSpec/1, 'EventSpec', ES);
+%% chk_EventSpec(#'EventSpec'{eventName = N1,
+%% streamID = SID1,
+%% eventParList = EPL1},
+%% #'EventSpec'{eventName = N2,
+%% streamID = SID2,
+%% eventParList = EPL2}) ->
+%% validate(fun() -> chk_EventName(N1, N2) end, 'EventSpec'),
+%% validate(fun() -> chk_opt_StreamID(SID1, SID2) end, 'EventSpec'),
+%% chk_EventSpec_eventParList(EPL1, EPL2),
+%% ok;
+%% chk_EventSpec(ES1, ES2) ->
+%% wrong_type('EventSpec', ES1, ES2).
+
+%% chk_EventSpec_eventParList([], []) ->
+%% ok;
+%% chk_EventSpec_eventParList([] = EPL1, EPL2) ->
+%% not_equal('EventSpec_eventParList', EPL1, EPL2);
+%% chk_EventSpec_eventParList(EPL1, [] = EPL2) ->
+%% not_equal('EventSpec_eventParList', EPL1, EPL2);
+%% chk_EventSpec_eventParList([H|T1], [H|T2]) ->
+%% case is_EventParameter(H) of
+%% true ->
+%% chk_EventSpec_eventParList(T1, T2);
+%% false ->
+%% wrong_type('EventSpec_eventParList_val', H)
+%% end;
+%% chk_EventSpec_eventParList([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_EventParameter(H1, H2) end,
+%% 'EventSpec_eventParList_val'),
+%% chk_EventSpec_eventParList(T1, T2);
+%% chk_EventSpec_eventParList(EPL1, EPL2) ->
+%% wrong_type('EventSpec_eventParList', EPL1, EPL2).
+
+
+%% %% -- SignalsDescriptor --
+
+%% is_opt_SignalsDescriptor(asn1_NOVALUE) ->
+%% true;
+%% is_opt_SignalsDescriptor(D) ->
+%% is_SignalsDescriptor(D).
+
+is_SignalsDescriptor([]) ->
+ true;
+is_SignalsDescriptor([H|T]) ->
+ is_SignalRequest(H) andalso is_SignalsDescriptor(T);
+is_SignalsDescriptor(_) ->
+ false.
+
+%% chk_opt_SignalsDescriptor(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_SignalsDescriptor(D1, D2) ->
+%% chk_SignalsDescriptor(D1, D2).
+
+%% chk_SignalsDescriptor([], []) ->
+%% ok;
+%% chk_SignalsDescriptor([] = D1, D2) ->
+%% not_equal('SignalsDescriptor', D1, D2);
+%% chk_SignalsDescriptor(D1, [] = D2) ->
+%% not_equal('SignalsDescriptor', D1, D2);
+%% chk_SignalsDescriptor([H|T1], [H|T2]) ->
+%% case is_SignalRequest(H) of
+%% true ->
+%% chk_SignalsDescriptor(T1, T2);
+%% false ->
+%% wrong_type('SignalsDescriptor_val', H)
+%% end;
+%% chk_SignalsDescriptor([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_SignalRequest(H1, H2) end, 'SignalsDescriptor_val'),
+%% chk_SignalsDescriptor(T1, T2);
+%% chk_SignalsDescriptor(D1, D2) ->
+%% wrong_type('SignalsDescriptor', D1, D2).
+
+
+%% %% -- SignalRequest --
+
+is_SignalRequest({Tag, Val}) ->
+ is_SignalRequest_tag(Tag) andalso is_SignalRequest_val(Tag, Val);
+is_SignalRequest(_) ->
+ false.
+
+is_SignalRequest_tag(Tag) ->
+ Tags = [signal, seqSigList],
+ lists:member(Tag, Tags).
+
+is_SignalRequest_val(signal, Val) ->
+ is_Signal(Val);
+is_SignalRequest_val(seqSigList, Val) ->
+ is_SeqSigList(Val).
+
+%% chk_SignalRequest(R, R) ->
+%% chk_type(fun is_SignalRequest/1, 'SignalRequest', R);
+%% chk_SignalRequest({Tag, Val1} = R1, {Tag, Val2} = R2) ->
+%% case (is_SignalRequest_tag(Tag) andalso
+%% is_SignalRequest_val(Tag, Val1) andalso
+%% is_SignalRequest_val(Tag, Val2)) of
+%% true ->
+%% chk_SignalRequest_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('SignalRequest', R1, R2)
+%% end;
+%% chk_SignalRequest({Tag1, Val1} = R1, {Tag2, Val2} = R2) ->
+%% case ((is_SignalRequest_tag(Tag1) andalso
+%% is_SignalRequest_val(Tag1, Val1)) andalso
+%% (is_SignalRequest_tag(Tag2) andalso
+%% is_SignalRequest_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('SignalRequest', R1, R2);
+%% false ->
+%% wrong_type('SignalRequest', R1, R2)
+%% end;
+%% chk_SignalRequest(R1, R2) ->
+%% wrong_type('SignalRequest', R1, R2).
+
+%% chk_SignalRequest_val(signal, Val1, Val2) ->
+%% validate(fun() -> chk_Signal(Val1, Val2) end, 'SignalRequest');
+%% chk_SignalRequest_val(seqSigList, Val1, Val2) ->
+%% validate(fun() -> chk_SeqSigList(Val1, Val2) end, 'SignalRequest').
+
+
+%% %% -- SeqSigList --
+
+is_SeqSigList(#'SeqSigList'{id = ID,
+ signalList = SL}) ->
+ is_INTEGER(ID, {range, 0, 65535}) andalso
+ is_SeqSigList_signalList(SL);
+is_SeqSigList(_) ->
+ false.
+
+is_SeqSigList_signalList([]) ->
+ true;
+is_SeqSigList_signalList([H|T]) ->
+ is_Signal(H) andalso is_SeqSigList_signalList(T);
+is_SeqSigList_signalList(_) ->
+ false.
+
+%% chk_SeqSigList(L, L) ->
+%% chk_type(fun is_SeqSigList/1, 'SeqSigList', L);
+%% chk_SeqSigList(#'SeqSigList'{id = ID1,
+%% signalList = SL1},
+%% #'SeqSigList'{id = ID2,
+%% signalList = SL2}) ->
+%% validate(fun() -> chk_INTEGER(ID1, ID2, {range, 0, 65535}) end,
+%% 'SeqSigList'),
+%% chk_SeqSigList_signalList(SL1, SL2),
+%% ok;
+%% chk_SeqSigList(L1, L2) ->
+%% wrong_type('SeqSigList', L1, L2).
+
+%% chk_SeqSigList_signalList([], []) ->
+%% ok;
+%% chk_SeqSigList_signalList([] = L1, L2) ->
+%% not_equal('SeqSigList_signalList', L1, L2);
+%% chk_SeqSigList_signalList(L1, [] = L2) ->
+%% not_equal('SeqSigList_signalList', L1, L2);
+%% chk_SeqSigList_signalList([H|T1], [H|T2]) ->
+%% case is_Signal(H) of
+%% true ->
+%% chk_SeqSigList_signalList(T1, T2);
+%% false ->
+%% wrong_type('SeqSigList_signalList_val', H)
+%% end;
+%% chk_SeqSigList_signalList([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_Signal(H1, H2) end,
+%% 'SeqSigList_signalList_val'),
+%% chk_SeqSigList_signalList(T1, T2);
+%% chk_SeqSigList_signalList(L1, L2) ->
+%% wrong_type('SeqSigList_signalList', L1, L2).
+
+
+%% %% -- Signal --
+
+is_Signal(#'Signal'{signalName = N,
+ streamID = SID,
+ sigType = ST,
+ duration = Dur,
+ notifyCompletion = NC,
+ keepActive = KA,
+ sigParList = SPL}) ->
+ is_SignalName(N) andalso
+ is_opt_StreamID(SID) andalso
+ is_opt_SignalType(ST) andalso
+ is_opt_INTEGER(Dur, {range, 0, 65535}) andalso
+ is_opt_NotifyCompletion(NC) andalso
+ is_opt_BOOLEAN(KA) andalso
+ is_Signal_sigParList(SPL).
+
+is_Signal_sigParList([]) ->
+ true;
+is_Signal_sigParList([H|T]) ->
+ is_SigParameter(H) andalso is_Signal_sigParList(T);
+is_Signal_sigParList(_) ->
+ false.
+
+%% chk_Signal(S, S) ->
+%% chk_type(fun is_Signal/1, 'Signal', S);
+%% chk_Signal(#'Signal'{signalName = N1,
+%% streamID = SID1,
+%% sigType = ST1,
+%% duration = Dur1,
+%% notifyCompletion = NC1,
+%% keepActive = KA1,
+%% sigParList = SPL1},
+%% #'Signal'{signalName = N2,
+%% streamID = SID2,
+%% sigType = ST2,
+%% duration = Dur2,
+%% notifyCompletion = NC2,
+%% keepActive = KA2,
+%% sigParList = SPL2}) ->
+%% validate(fun() -> chk_SignalName(N1, N2) end, 'Signal'),
+%% validate(fun() -> chk_opt_StreamID(SID1, SID2) end, 'Signal'),
+%% validate(fun() -> chk_opt_SignalType(ST1, ST2) end, 'Signal'),
+%% validate(fun() -> chk_opt_INTEGER(Dur1, Dur2, {range, 0, 65535}) end,
+%% 'Signal'),
+%% validate(fun() -> chk_opt_NotifyCompletion(NC1, NC2) end, 'Signal'),
+%% validate(fun() -> chk_opt_BOOLEAN(KA1, KA2) end, 'Signal'),
+%% chk_Signal_sigParList(SPL1, SPL2),
+%% ok;
+%% chk_Signal(S1, S2) ->
+%% wrong_type('Signal', S1, S2).
+
+%% chk_Signal_sigParList([], []) ->
+%% ok;
+%% chk_Signal_sigParList([] = L1, L2) ->
+%% not_equal('Signal_sigParList', L1, L2);
+%% chk_Signal_sigParList(L1, [] = L2) ->
+%% not_equal('Signal_sigParList', L1, L2);
+%% chk_Signal_sigParList([H|T1], [H|T2]) ->
+%% case is_SigParameter(H) of
+%% true ->
+%% chk_Signal_sigParList(T1, T2);
+%% false ->
+%% wrong_type('Signal_sigParList_val', H)
+%% end;
+%% chk_Signal_sigParList([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_SigParameter(H1, H2) end,
+%% 'Signal_sigParList_val'),
+%% chk_Signal_sigParList(T1, T2);
+%% chk_Signal_sigParList(L1, L2) ->
+%% wrong_type('Signal_sigParList', L1, L2).
+
+
+%% %% -- SignalType --
+
+is_opt_SignalType(asn1_NOVALUE) ->
+ true;
+is_opt_SignalType(T) ->
+ is_SignalType(T).
+
+is_SignalType(T) ->
+ Types = [brief, onOff, timeOut],
+ lists:member(T, Types).
+
+%% chk_opt_SignalType(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_SignalType(T1, T2) ->
+%% chk_SignalType(T1, T2).
+
+%% chk_SignalType(T, T) ->
+%% chk_type(fun is_SignalType/1, 'SignalType', T);
+%% chk_SignalType(T1, T2) ->
+%% case (is_SignalType(T1) andalso is_SignalType(T2)) of
+%% true ->
+%% not_equal('SignalType', T1, T2);
+%% false ->
+%% wrong_type('SignalType', T1, T2)
+%% end.
+
+
+%% %% -- SignalName --
+
+is_SignalName(N) -> is_PkgdName(N).
+
+%% chk_SignalName(N1, N2) ->
+%% validate(fun() -> chk_PkgdName(N1, N2) end, 'SignalName').
+
+
+%% %% -- NotifyCompletion --
+
+is_opt_NotifyCompletion(NC) ->
+ is_OPTIONAL(fun is_NotifyCompletion/1, NC).
+
+is_NotifyCompletion(NC) ->
+ Valids = [onTimeOut,
+ onInterruptByEvent,
+ onInterruptByNewSignalDescr,
+ otherReason],
+ lists:member(NC, Valids).
+
+%% chk_opt_NotifyCompletion(NC1, NC2) ->
+%% chk_OPTIONAL('NotifyCompletion', NC1, NC2,
+%% fun is_NotifyCompletion/1,
+%% fun chk_NotifyCompletion/2).
+
+%% chk_NotifyCompletion(NC, NC) ->
+%% chk_type(fun is_NotifyCompletion/1, 'NotifyCompletion', NC);
+%% chk_NotifyCompletion(NC1, NC2) ->
+%% case (is_NotifyCompletion(NC1) andalso is_NotifyCompletion(NC2)) of
+%% true ->
+%% not_equal('NotifyCompletion', NC1, NC2);
+%% false ->
+%% wrong_type('NotifyCompletion', NC1, NC2)
+%% end.
+
+
+%% %% -- SigParameter --
+
+is_SigParameter(#'SigParameter'{sigParameterName = N,
+ value = V,
+ extraInfo = I}) ->
+ is_Name(N) andalso
+ is_Value(V) andalso
+ is_SigParameter_extraInfo(I);
+is_SigParameter(_) ->
+ false.
+
+is_SigParameter_extraInfo({Tag, Val}) ->
+ is_SigParameter_extraInfo_tag(Tag) andalso
+ is_SigParameter_extraInfo_val(Tag, Val);
+is_SigParameter_extraInfo(_) ->
+ false.
+
+is_SigParameter_extraInfo_tag(Tag) ->
+ Tags = [relation, range, sublist],
+ lists:member(Tag, Tags).
+
+is_SigParameter_extraInfo_val(relation, Val) ->
+ is_Relation(Val);
+is_SigParameter_extraInfo_val(range, Val) ->
+ is_BOOLEAN(Val);
+is_SigParameter_extraInfo_val(sublist, Val) ->
+ is_BOOLEAN(Val).
+
+%% chk_SigParameter(P, P) ->
+%% chk_type(fun is_SigParameter/1, 'SigParameter', P);
+%% chk_SigParameter(#'SigParameter'{sigParameterName = N1,
+%% value = V1,
+%% extraInfo = I1},
+%% #'SigParameter'{sigParameterName = N2,
+%% value = V2,
+%% extraInfo = I2}) ->
+%% validate(fun() -> chk_Name(N1, N2) end, 'SigParameter'),
+%% validate(fun() -> chk_Value(V1, V2) end, 'SigParameter'),
+%% chk_SigParameter_extraInfo(I1, I2),
+%% ok;
+%% chk_SigParameter(P1, P2) ->
+%% wrong_type('SigParameter', P1, P2).
+
+%% chk_SigParameter_extraInfo(EI, EI) ->
+%% chk_type(fun is_SigParameter_extraInfo/1, 'SigParameter_extraInfo', EI);
+%% chk_SigParameter_extraInfo({Tag, Val1} = EI1, {Tag, Val2} = EI2) ->
+%% case (is_SigParameter_extraInfo_tag(Tag) and
+%% is_SigParameter_extraInfo_val(Tag, Val1) and
+%% is_SigParameter_extraInfo_val(Tag, Val2)) of
+%% true ->
+%% chk_SigParameter_extraInfo_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('SigParameter_extraInfo', EI1, EI2)
+%% end;
+%% chk_SigParameter_extraInfo({Tag1, Val1} = EI1, {Tag2, Val2} = EI2) ->
+%% case ((is_SigParameter_extraInfo_tag(Tag1) and
+%% is_SigParameter_extraInfo_val(Tag1, Val1)) and
+%% (is_SigParameter_extraInfo_tag(Tag2) and
+%% is_SigParameter_extraInfo_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('SigParameter_extraInfo', EI1, EI2);
+%% false ->
+%% wrong_type('SigParameter_extraInfo', EI1, EI2)
+%% end;
+%% chk_SigParameter_extraInfo(EI1, EI2) ->
+%% wrong_type('SigParameter_extraInfo', EI1, EI2).
+
+%% chk_SigParameter_extraInfo_val(relation, Val1, Val2) ->
+%% validate(fun() -> chk_Relation(Val1, Val2) end, 'SigParameter_extraInfo');
+%% chk_SigParameter_extraInfo_val(range, Val1, Val2) ->
+%% validate(fun() -> chk_BOOLEAN(Val1, Val2) end, 'SigParameter_extraInfo');
+%% chk_SigParameter_extraInfo_val(sublist, Val1, Val2) ->
+%% validate(fun() -> chk_BOOLEAN(Val1, Val2) end, 'SigParameter_extraInfo').
+
+
+%% %% -- RequestID --
+
+%% is_opt_RequestID(asn1_NOVALUE) ->
+%% true;
+%% is_opt_RequestID(V) ->
+%% is_RequestID(V).
+
+%% is_RequestID(V) -> is_INTEGER(V, {range, 0, 4294967295}).
+
+%% chk_opt_RequestID(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_RequestID(V1, V2) ->
+%% chk_RequestID(V1, V2).
+
+%% chk_RequestID(ID, ID) ->
+%% chk_type(fun is_RequestID/1, 'RequestID', ID);
+%% chk_RequestID(ID1, ID2) ->
+%% case (is_RequestID(ID1) andalso is_RequestID(ID2)) of
+%% true ->
+%% not_equal('RequestID', ID1, ID2);
+%% false ->
+%% wrong_type('RequestID', ID1, ID2)
+%% end.
+
+
+%% %% -- ModemDescriptor --
+
+%% is_ModemDescriptor(D) when record(D, 'ModemDescriptor') ->
+%% true;
+%% is_ModemDescriptor(_) ->
+%% false.
+
+%% chk_ModemDescriptor(D, D) when record(D, 'ModemDescriptor') ->
+%% ok;
+%% chk_ModemDescriptor(#'ModemDescriptor'{mtl = MTL1,
+%% mpl = MPL1,
+%% nonStandardData = NSD1},
+%% #'ModemDescriptor'{mtl = MTL2,
+%% mpl = MPL2,
+%% nonStandardData = NSD2}) ->
+%% chk_ModemDescriptor_mtl(MTL1, MTL2),
+%% chk_ModemDescriptor_mpl(MPL1, MPL2),
+%% chk_opt_NonStandardData(NSD1, NSD2),
+%% ok;
+%% chk_ModemDescriptor(D1, D2) ->
+%% wrong_type('ModemDescriptor', D1, D2).
+
+%% chk_ModemDescriptor_mtl([], []) ->
+%% ok;
+%% chk_ModemDescriptor_mtl([] = MTL1, MTL2) ->
+%% not_equal('ModemDescriptor_mtl', MTL1, MTL2);
+%% chk_ModemDescriptor_mtl(MTL1, [] = MTL2) ->
+%% not_equal('ModemDescriptor_mtl', MTL1, MTL2);
+%% chk_ModemDescriptor_mtl([H|T1], [H|T2]) ->
+%% case is_ModemType(H) of
+%% true ->
+%% chk_ModemDescriptor_mtl(T1, T2);
+%% false ->
+%% wrong_type('ModemDescriptor_mtl_val', H)
+%% end;
+%% chk_ModemDescriptor_mtl([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_ModemType(H1, H2) end, 'ModemDescriptor_mtl_val'),
+%% chk_ModemDescriptor_mtl(T1, T2);
+%% chk_ModemDescriptor_mtl(MTL1, MTL2) ->
+%% wrong_type('ModemDescriptor_mtl', MTL1, MTL2).
+
+
+%% chk_ModemDescriptor_mpl([], []) ->
+%% ok;
+%% chk_ModemDescriptor_mpl([] = MPL1, MPL2) ->
+%% not_equal('ModemDescriptor_mpl', MPL1, MPL2);
+%% chk_ModemDescriptor_mpl(MPL1, [] = MPL2) ->
+%% not_equal('ModemDescriptor_mpl', MPL1, MPL2);
+%% chk_ModemDescriptor_mpl([H|T1], [H|T2]) ->
+%% case is_PropertyParm(H) of
+%% true ->
+%% chk_ModemDescriptor_mpl(T1, T2);
+%% false ->
+%% wrong_type('ModemDescriptor_mpl_val', H)
+%% end;
+%% chk_ModemDescriptor_mpl([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_PropertyParm(H1, H2) end, 'ModemDescriptor_mpl_val'),
+%% chk_ModemDescriptor_mpl(T1, T2);
+%% chk_ModemDescriptor_mpl(MPL1, MPL2) ->
+%% wrong_type('ModemDescriptor_mpl', MPL1, MPL2).
+
+
+%% %% -- ModemType --
+
+%% chk_ModemType(MT, MT) ->
+%% case is_ModemType(MT) of
+%% true ->
+%% ok;
+%% false ->
+%% wrong_type('ModemType', MT, MT)
+%% end;
+%% chk_ModemType(MT1, MT2) ->
+%% case (is_ModemType(MT1) andalso is_ModemType(MT2)) of
+%% true ->
+%% not_equal('ModemType', MT1, MT2);
+%% false ->
+%% wrong_type('ModemType', MT1, MT2)
+%% end.
+
+%% is_ModemType(MT) ->
+%% lists:member(MT,
+%% [v18, v22, v22bis, v32, v32bis, v34, v90, v91, synchISDN]).
+
+
+%% %% -- DigitMapDescriptor --
+
+%% is_DigitMapDescriptor(#'DigitMapDescriptor'{digitMapName = Name,
+%% digitMapValue = Val}) ->
+%% is_opt_DigitMapName(Name) andalso is_opt_DigitMapValue(Val);
+%% is_DigitMapDescriptor(_) ->
+%% false.
+
+%% chk_DigitMapDescriptor(D, D) ->
+%% chk_type(fun is_DigitMapDescriptor/1, 'DigitMapDescriptor', D);
+%% chk_DigitMapDescriptor(#'DigitMapDescriptor'{digitMapName = Name1,
+%% digitMapValue = Val1},
+%% #'DigitMapDescriptor'{digitMapName = Name2,
+%% digitMapValue = Val2}) ->
+%% d("chk_DigitMapDescriptor -> entry with"
+%% "~n Name1: ~p"
+%% "~n Name2: ~p"
+%% "~n Val1: ~p"
+%% "~n Val2: ~p", [Name1, Name2, Val1, Val2]),
+%% validate(fun() -> chk_opt_DigitMapName(Name1, Name2) end,
+%% 'DigitMapDescriptor'),
+%% validate(fun() -> chk_opt_DigitMapValue(Val1, Val2) end,
+%% 'DigitMapDescriptor'),
+%% ok;
+%% chk_DigitMapDescriptor(D1, D2) ->
+%% wrong_type('DigitMapDescriptor', D1, D2).
+
+
+%% %% -- DigitMapName --
+
+%% is_opt_DigitMapName(asn1_NOVALUE) ->
+%% true;
+%% is_opt_DigitMapName(N) ->
+%% is_DigitMapName(N).
+
+%% is_DigitMapName(N) -> is_Name(N).
+
+%% chk_opt_DigitMapName(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_DigitMapName(N1, N2) ->
+%% chk_DigitMapName(N1, N2).
+
+%% chk_DigitMapName(N, N) ->
+%% chk_type(fun is_DigitMapName/1, 'DigitMapName', N);
+%% chk_DigitMapName(N1, N2) ->
+%% case (is_DigitMapName(N1) andalso is_DigitMapName(N2)) of
+%% true ->
+%% not_equal('DigitMapName', N1, N2);
+%% false ->
+%% wrong_type('DigitMapName', N1, N2)
+%% end.
+
+
+%% %% -- DigitMapValue --
+
+%% is_opt_DigitMapValue(V) ->
+%% is_OPTIONAL(fun is_DigitMapValue/1, V).
+
+%% is_DigitMapValue(#'DigitMapValue'{startTimer = Start,
+%% shortTimer = Short,
+%% longTimer = Long,
+%% digitMapBody = Body,
+%% durationTimer = Dur}) ->
+%% is_DigitMapValue_startTimer(Start) andalso
+%% is_DigitMapValue_shortTimer(Short) andalso
+%% is_DigitMapValue_longTimer(Long) andalso
+%% is_IA5String(Body) andalso
+%% is_DigitMapValue_durationTimer(Dur);
+%% is_DigitMapValue(_) ->
+%% false.
+
+%% is_DigitMapValue_startTimer(asn1_NOVALUE) -> true;
+%% is_DigitMapValue_startTimer(T) -> is_INTEGER(T, {range, 0, 99}).
+
+%% is_DigitMapValue_shortTimer(asn1_NOVALUE) -> true;
+%% is_DigitMapValue_shortTimer(T) -> is_INTEGER(T, {range, 0, 99}).
+
+%% is_DigitMapValue_longTimer(asn1_NOVALUE) -> true;
+%% is_DigitMapValue_longTimer(T) -> is_INTEGER(T, {range, 0, 99}).
+
+%% is_DigitMapValue_durationTimer(asn1_NOVALUE) -> true;
+%% is_DigitMapValue_durationTimer(T) -> is_INTEGER(T, {range, 0, 99}).
+
+%% chk_opt_DigitMapValue(V1, V2) ->
+%% chk_OPTIONAL('DigitMapValue', V1, V2,
+%% fun is_DigitMapValue/1, fun chk_DigitMapValue/2).
+
+%% chk_DigitMapValue(#'DigitMapValue'{startTimer = Start1,
+%% shortTimer = Short1,
+%% longTimer = Long1,
+%% digitMapBody = Body1,
+%% durationTimer = Dur1},
+%% #'DigitMapValue'{startTimer = Start2,
+%% shortTimer = Short2,
+%% longTimer = Long2,
+%% digitMapBody = Body2,
+%% durationTimer = Dur2}) ->
+%% d("chk_DigitMapValue -> entry with"
+%% "~n Start1: ~p"
+%% "~n Start2: ~p"
+%% "~n Short1: ~p"
+%% "~n Short2: ~p"
+%% "~n Long1: ~p"
+%% "~n Long2: ~p"
+%% "~n Body1: ~p"
+%% "~n Body2: ~p"
+%% "~n Dur1: ~p"
+%% "~n Dur2: ~p", [Start1, Start2,
+%% Short1, Short2,
+%% Long1, Long2,
+%% Body1, Body2,
+%% Dur1, Dur2]),
+%% chk_DigitMapValue_startTimer(Start1, Start2),
+%% chk_DigitMapValue_shortTimer(Short1, Short2),
+%% chk_DigitMapValue_longTimer(Long1, Long2),
+%% chk_DigitMapValue_digitMapBody(Body1, Body2),
+%% chk_DigitMapValue_durationTimer(Dur1, Dur2),
+%% ok;
+%% chk_DigitMapValue(V1, V2) ->
+%% wrong_type('DigitMapValue', V1, V2).
+
+%% chk_DigitMapValue_startTimer(T, T) ->
+%% chk_type(fun is_DigitMapValue_startTimer/1, 'DigitMapValue_startTimer', T);
+%% chk_DigitMapValue_startTimer(T1, T2) ->
+%% case (is_DigitMapValue_startTimer(T1) andalso
+%% is_DigitMapValue_startTimer(T2)) of
+%% true ->
+%% not_equal('DigitMapValue_startTimer', T1, T2);
+%% false ->
+%% wrong_type('DigitMapValue_startTimer', T1, T2)
+%% end.
+
+%% chk_DigitMapValue_shortTimer(T, T) ->
+%% chk_type(fun is_DigitMapValue_shortTimer/1, 'DigitMapValue_shortTimer', T);
+%% chk_DigitMapValue_shortTimer(T1, T2) ->
+%% case (is_DigitMapValue_shortTimer(T1) andalso
+%% is_DigitMapValue_shortTimer(T2)) of
+%% true ->
+%% not_equal('DigitMapValue_shortTimer', T1, T2);
+%% false ->
+%% wrong_type('DigitMapValue_shortTimer', T1, T2)
+%% end.
+
+%% chk_DigitMapValue_longTimer(T, T) ->
+%% chk_type(fun is_DigitMapValue_longTimer/1, 'DigitMapValue_longTimer', T);
+%% chk_DigitMapValue_longTimer(T1, T2) ->
+%% case (is_DigitMapValue_longTimer(T1) andalso
+%% is_DigitMapValue_longTimer(T2)) of
+%% true ->
+%% not_equal('DigitMapValue_longTimer', T1, T2);
+%% false ->
+%% wrong_type('DigitMapValue_longTimer', T1, T2)
+%% end.
+
+%% chk_DigitMapValue_durationTimer(T, T) ->
+%% chk_type(fun is_DigitMapValue_durationTimer/1,
+%% 'DigitMapValue_durationTimer', T);
+%% chk_DigitMapValue_durationTimer(T1, T2) ->
+%% case (is_DigitMapValue_durationTimer(T1) andalso
+%% is_DigitMapValue_durationTimer(T2)) of
+%% true ->
+%% not_equal('DigitMapValue_durationTimer', T1, T2);
+%% false ->
+%% wrong_type('DigitMapValue_durationTimer', T1, T2)
+%% end.
+
+%% chk_DigitMapValue_digitMapBody(B, B) ->
+%% d("chk_DigitMapValue_digitMapBody -> entry with"
+%% "~n B: ~p", [B]),
+%% chk_type(fun is_IA5String/1, 'DigitMapValue_digitMapBody', B);
+%% chk_DigitMapValue_digitMapBody(B1, B2) ->
+%% d("chk_DigitMapValue_digitMapBody -> entry with"
+%% "~n B1: ~p"
+%% "~n B2: ~p", [B1, B2]),
+%% case (is_IA5String(B1) andalso is_IA5String(B2)) of
+%% true ->
+%% %% If they are different it could be because
+%% %% of trailing tab's and newline's.
+%% case compare_strings(B1, B2) of
+%% {[], []} ->
+%% ok;
+%% {Str1, []} ->
+%% case strip_tab_and_newline(Str1) of
+%% [] ->
+%% ok;
+%% _ ->
+%% not_equal('DigitMapValue_digitMapBody', B1, B2)
+%% end;
+%% {[], Str2} ->
+%% case strip_tab_and_newline(Str2) of
+%% [] ->
+%% ok;
+%% _ ->
+%% not_equal('DigitMapValue_digitMapBody', B1, B2)
+%% end;
+%% _ ->
+%% not_equal('DigitMapValue_digitMapBody', B1, B2)
+%% end;
+%% false ->
+%% wrong_type('DigitMapValue_digitMapBody', B1, B2)
+%% end.
+
+%% %% -- ServiceChangeParm --
+
+%% is_ServiceChangeParm(#'ServiceChangeParm'{serviceChangeMethod = M,
+%% serviceChangeAddress = A,
+%% serviceChangeVersion = V,
+%% serviceChangeProfile = P,
+%% serviceChangeReason = R,
+%% serviceChangeDelay = D,
+%% serviceChangeMgcId = Id,
+%% timeStamp = TS,
+%% nonStandardData = NSD,
+%% serviceChangeInfo = I}) ->
+%% is_ServiceChangeMethod(M) andalso
+%% is_opt_ServiceChangeAddress(A) andalso
+%% is_opt_INTEGER(V, {range, 0, 99}) andalso
+%% is_opt_ServiceChangeProfile(P) andalso
+%% is_Value(R) andalso
+%% is_opt_INTEGER(D, {range, 0, 4294967295}) andalso
+%% is_opt_MId(Id) andalso
+%% is_opt_TimeNotation(TS) andalso
+%% is_opt_NonStandardData(NSD) andalso
+%% is_opt_AuditDescriptor(I);
+%% is_ServiceChangeParm(_) ->
+%% false.
+
+%% chk_ServiceChangeParm(P, P) ->
+%% chk_type(fun is_ServiceChangeParm/1, 'ServiceChangeParm', P);
+%% chk_ServiceChangeParm(#'ServiceChangeParm'{serviceChangeMethod = M1,
+%% serviceChangeAddress = A1,
+%% serviceChangeVersion = V1,
+%% serviceChangeProfile = P1,
+%% serviceChangeReason = R1,
+%% serviceChangeDelay = D1,
+%% serviceChangeMgcId = Id1,
+%% timeStamp = TS1,
+%% nonStandardData = NSD1,
+%% serviceChangeInfo = I1},
+%% #'ServiceChangeParm'{serviceChangeMethod = M2,
+%% serviceChangeAddress = A2,
+%% serviceChangeVersion = V2,
+%% serviceChangeProfile = P2,
+%% serviceChangeReason = R2,
+%% serviceChangeDelay = D2,
+%% serviceChangeMgcId = Id2,
+%% timeStamp = TS2,
+%% nonStandardData = NSD2,
+%% serviceChangeInfo = I2}) ->
+%% validate(fun() -> chk_ServiceChangeMethod(M1, M2) end,
+%% 'ServiceChangeParm'),
+%% validate(fun() -> chk_opt_ServiceChangeAddress(A1, A2) end,
+%% 'ServiceChangeParm'),
+%% validate(fun() -> chk_opt_INTEGER(V1, V2, {range, 0, 99}) end,
+%% 'ServiceChangeParm'),
+%% validate(fun() -> chk_opt_ServiceChangeProfile(P1, P2) end,
+%% 'ServiceChangeParm'),
+%% validate(fun() -> chk_Value(R1, R2) end,
+%% 'ServiceChangeParm'),
+%% validate(fun() -> chk_opt_INTEGER(D1, D2, {range, 0, 4294967295}) end,
+%% 'ServiceChangeParm'),
+%% validate(fun() -> chk_opt_MId(Id1, Id2) end,
+%% 'ServiceChangeParm'),
+%% validate(fun() -> chk_opt_TimeNotation(TS1, TS2) end,
+%% 'ServiceChangeParm'),
+%% validate(fun() -> chk_opt_NonStandardData(NSD1, NSD2) end,
+%% 'ServiceChangeParm'),
+%% validate(fun() -> chk_opt_AuditDescriptor(I1, I2) end,
+%% 'ServiceChangeParm'),
+%% ok;
+%% chk_ServiceChangeParm(P1, P2) ->
+%% wrong_type('ServiceChangeParm', P1, P2).
+
+
+%% %% -- ServiceChangeAddress --
+
+%% is_opt_ServiceChangeAddress(A) ->
+%% is_OPTIONAL(fun is_ServiceChangeAddress/1, A).
+
+%% is_ServiceChangeAddress({Tag, Val}) ->
+%% is_ServiceChangeAddress_tag(Tag) andalso
+%% is_ServiceChangeAddress_val(Tag, Val);
+%% is_ServiceChangeAddress(_) ->
+%% false.
+
+%% is_ServiceChangeAddress_tag(Tag) ->
+%% Tags = [portNumber, ip4Address, ip6Address, domainName, deviceName,
+%% mtpAddress],
+%% lists:member(Tag, Tags).
+
+%% is_ServiceChangeAddress_val(portNumber, Val) ->
+%% is_INTEGER(Val, {range, 0, 65535});
+%% is_ServiceChangeAddress_val(ip4Address, Val) ->
+%% is_IP4Address(Val);
+%% is_ServiceChangeAddress_val(ip6Address, Val) ->
+%% is_IP6Address(Val);
+%% is_ServiceChangeAddress_val(domainName, Val) ->
+%% is_DomainName(Val);
+%% is_ServiceChangeAddress_val(deviceName, Val) ->
+%% is_PathName(Val);
+%% is_ServiceChangeAddress_val(mtpAddress, Val) ->
+%% is_OCTET_STRING(Val, {range, 2, 4}).
+
+
+%% chk_opt_ServiceChangeAddress(A1, A2) ->
+%% chk_OPTIONAL('ServiceChangeAddress', A1, A2,
+%% fun is_ServiceChangeAddress/1,
+%% fun chk_ServiceChangeAddress/2).
+
+%% chk_ServiceChangeAddress(A, A) ->
+%% chk_type(fun is_ServiceChangeAddress/1, 'ServiceChangeAddress', A);
+%% chk_ServiceChangeAddress({Tag, Val1} = A1, {Tag, Val2} = A2) ->
+%% case (is_ServiceChangeAddress_tag(Tag) andalso
+%% is_ServiceChangeAddress_val(Tag, Val1) andalso
+%% is_ServiceChangeAddress_val(Tag, Val2)) of
+%% true ->
+%% chk_ServiceChangeAddress_val(Tag, Val1, Val2);
+%% false ->
+%% wrong_type('ServiceChangeAddress', A1, A2)
+%% end;
+%% chk_ServiceChangeAddress({Tag1, Val1} = A1, {Tag2, Val2} = A2) ->
+%% case ((is_ServiceChangeAddress_tag(Tag1) andalso
+%% is_ServiceChangeAddress_val(Tag1, Val1)) andalso
+%% (is_ServiceChangeAddress_tag(Tag2) andalso
+%% is_ServiceChangeAddress_val(Tag2, Val2))) of
+%% true ->
+%% not_equal('ServiceChangeAddress', A1, A2);
+%% false ->
+%% wrong_type('ServiceChangeAddress', A1, A2)
+%% end;
+%% chk_ServiceChangeAddress(A1, A2) ->
+%% wrong_type('ServiceChangeAddress', A1, A2).
+
+%% chk_ServiceChangeAddress_val(portNumber, Val1, Val2) ->
+%% validate(fun() -> chk_INTEGER(Val1, Val2, {range, 0, 99}) end,
+%% 'ServiceChangeAddress');
+%% chk_ServiceChangeAddress_val(ip4Address, Val1, Val2) ->
+%% validate(fun() -> chk_IP4Address(Val1, Val2) end,
+%% 'ServiceChangeAddress');
+%% chk_ServiceChangeAddress_val(ip6Address, Val1, Val2) ->
+%% validate(fun() -> chk_IP6Address(Val1, Val2) end,
+%% 'ServiceChangeAddress');
+%% chk_ServiceChangeAddress_val(domainName, Val1, Val2) ->
+%% validate(fun() -> chk_DomainName(Val1, Val2) end,
+%% 'ServiceChangeAddress');
+%% chk_ServiceChangeAddress_val(deviceName, Val1, Val2) ->
+%% validate(fun() -> chk_PathName(Val1, Val2) end,
+%% 'ServiceChangeAddress');
+%% chk_ServiceChangeAddress_val(mtpAddress, Val1, Val2) ->
+%% validate(fun() -> chk_OCTET_STRING(Val1, Val2, {range, 2, 4}) end,
+%% 'ServiceChangeAddress').
+
+
+%% %% -- ServiceChangeResParm --
+
+%% is_ServiceChangeResParm(#'ServiceChangeResParm'{serviceChangeMgcId = Id,
+%% serviceChangeAddress = A,
+%% serviceChangeVersion = V,
+%% serviceChangeProfile = P,
+%% timeStamp = TS}) ->
+%% is_opt_MId(Id) andalso
+%% is_opt_ServiceChangeAddress(A) andalso
+%% is_opt_INTEGER(V, {range, 0, 99}) andalso
+%% is_opt_ServiceChangeProfile(P) andalso
+%% is_opt_TimeNotation(TS);
+%% is_ServiceChangeResParm(_) ->
+%% false.
+
+%% chk_ServiceChangeResParm(P, P) ->
+%% chk_type(fun is_ServiceChangeResParm/1, 'ServiceChangeResParm', P);
+%% chk_ServiceChangeResParm(
+%% #'ServiceChangeResParm'{serviceChangeMgcId = Id1,
+%% serviceChangeAddress = A1,
+%% serviceChangeVersion = V1,
+%% serviceChangeProfile = P1,
+%% timeStamp = TS1},
+%% #'ServiceChangeResParm'{serviceChangeMgcId = Id2,
+%% serviceChangeAddress = A2,
+%% serviceChangeVersion = V2,
+%% serviceChangeProfile = P2,
+%% timeStamp = TS2}) ->
+%% validate(fun() -> chk_opt_MId(Id1, Id2) end, 'ServiceChangeResParm'),
+%% validate(fun() -> chk_opt_ServiceChangeAddress(A1, A2) end,
+%% 'ServiceChangeResParm'),
+%% validate(fun() -> chk_opt_INTEGER(V1, V2, {range, 0, 99}) end,
+%% 'ServiceChangeResParm'),
+%% validate(fun() -> chk_opt_ServiceChangeProfile(P1, P2) end,
+%% 'ServiceChangeResParm'),
+%% validate(fun() -> chk_opt_TimeNotation(TS1, TS2) end,
+%% 'ServiceChangeResParm'),
+%% ok;
+%% chk_ServiceChangeResParm(P1, P2) ->
+%% wrong_type('ServiceChangeResParm', P1, P2).
+
+
+%% %% -- ServiceChangeMethod --
+
+%% is_ServiceChangeMethod(M) ->
+%% Methods = [failover, forced, graceful, restart, disconnected, handOff],
+%% lists:member(M, Methods).
+
+%% chk_ServiceChangeMethod(M, M) ->
+%% chk_type(fun is_ServiceChangeMethod/1, 'ServiceChangeMethod', M);
+%% chk_ServiceChangeMethod(M1, M2) ->
+%% case (is_ServiceChangeMethod(M1) andalso is_ServiceChangeMethod(M2)) of
+%% true ->
+%% not_equal('ServiceChangeMethod', M1, M2);
+%% false ->
+%% wrong_type('ServiceChangeMethod', M1, M2)
+%% end.
+
+
+%% %% -- ServiceChangeProfile --
+
+%% is_opt_ServiceChangeProfile(P) ->
+%% is_OPTIONAL(fun is_ServiceChangeProfile/1, P).
+
+%% is_ServiceChangeProfile(#'ServiceChangeProfile'{profileName = N}) ->
+%% is_IA5String(N, {range, 1, 67});
+%% is_ServiceChangeProfile(_) ->
+%% false.
+
+%% chk_opt_ServiceChangeProfile(P1, P2) ->
+%% chk_OPTIONAL('ServiceChangeProfile', P1, P2,
+%% fun is_ServiceChangeProfile/1,
+%% fun chk_ServiceChangeProfile/2).
+
+%% chk_ServiceChangeProfile(P, P) ->
+%% chk_type(fun is_ServiceChangeProfile/1, 'ServiceChangeProfile', P);
+%% chk_ServiceChangeProfile(#'ServiceChangeProfile'{profileName = N1},
+%% #'ServiceChangeProfile'{profileName = N2}) ->
+%% validate(fun() -> chk_IA5String(N1, N2, {range, 1, 67}) end,
+%% 'ServiceChangeProfile'),
+%% ok;
+%% chk_ServiceChangeProfile(P1, P2) ->
+%% wrong_type('ServiceChangeProfile', P1, P2).
+
+
+%% %% -- PackagesDescriptor --
+
+%% is_PackagesDescriptor([]) ->
+%% true;
+%% is_PackagesDescriptor([H|T]) ->
+%% is_PackagesItem(H) andalso is_PackagesDescriptor(T);
+%% is_PackagesDescriptor(_) ->
+%% false.
+
+%% chk_PackagesDescriptor([], []) ->
+%% ok;
+%% chk_PackagesDescriptor([] = D1, D2) ->
+%% not_equal('PackagesDescriptor', D1, D2);
+%% chk_PackagesDescriptor(D1, [] = D2) ->
+%% not_equal('PackagesDescriptor', D1, D2);
+%% chk_PackagesDescriptor([H|T1], [H|T2]) ->
+%% case is_PackagesItem(H) of
+%% true ->
+%% chk_PackagesDescriptor(T1, T2);
+%% false ->
+%% wrong_type('PackagesDescriptor_val', H)
+%% end;
+%% chk_PackagesDescriptor([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_PackagesItem(H1, H2) end,
+%% 'PackagesDescriptor_val'),
+%% chk_PackagesDescriptor(T1, T2);
+%% chk_PackagesDescriptor(D1, D2) ->
+%% wrong_type('PackagesDescriptor_val', D1, D2).
+
+
+%% %% -- PackagesItem --
+
+%% is_PackagesItem(#'PackagesItem'{packageName = N,
+%% packageVersion = V}) ->
+%% is_Name(N) andalso is_INTEGER(V, {range, 0, 99});
+%% is_PackagesItem(_) ->
+%% false.
+
+%% chk_PackagesItem(I, I) ->
+%% chk_type(fun is_PackagesItem/1, 'PackagesItem', I);
+%% chk_PackagesItem(#'PackagesItem'{packageName = N1,
+%% packageVersion = V1},
+%% #'PackagesItem'{packageName = N2,
+%% packageVersion = V2}) ->
+%% validate(fun() -> chk_Name(N1, N2) end, 'PackagesItem'),
+%% validate(fun() -> chk_INTEGER(V1, V2, {range, 0, 99}) end, 'PackagesItem'),
+%% ok;
+%% chk_PackagesItem(I1, I2) ->
+%% wrong_type('PackagesItem', I1, I2).
+
+
+%% %% -- StatisticsDescriptor --
+
+%% is_StatisticsDescriptor([]) ->
+%% true;
+%% is_StatisticsDescriptor([H|T]) ->
+%% is_StatisticsParameter(H) andalso is_StatisticsDescriptor(T);
+%% is_StatisticsDescriptor(_) ->
+%% false.
+
+%% chk_StatisticsDescriptor([], []) ->
+%% ok;
+%% chk_StatisticsDescriptor([] = D1, D2) ->
+%% not_equal('StatisticsDescriptor', D1, D2);
+%% chk_StatisticsDescriptor(D1, [] = D2) ->
+%% not_equal('StatisticsDescriptor', D1, D2);
+%% chk_StatisticsDescriptor([H|T1], [H|T2]) ->
+%% case is_StatisticsParameter(H) of
+%% true ->
+%% chk_StatisticsDescriptor(T1, T2);
+%% false ->
+%% wrong_type('StatisticsDescriptor_val', H)
+%% end;
+%% chk_StatisticsDescriptor([H1|T1], [H2|T2]) ->
+%% validate(fun() -> chk_StatisticsParameter(H1, H2) end,
+%% 'StatisticsDescriptor_val'),
+%% chk_StatisticsDescriptor(T1, T2);
+%% chk_StatisticsDescriptor(D1, D2) ->
+%% wrong_type('StatisticsDescriptor_val', D1, D2).
+
+
+%% %% -- StatisticsParameter --
+
+%% is_StatisticsParameter(#'StatisticsParameter'{statName = N,
+%% statValue = V}) ->
+%% is_PkgdName(N) andalso is_opt_Value(V);
+%% is_StatisticsParameter(_) ->
+%% false.
+
+%% chk_StatisticsParameter(P, P) ->
+%% chk_type(fun is_StatisticsParameter/1, 'StatisticsParameter', P);
+%% chk_StatisticsParameter(#'StatisticsParameter'{statName = N1,
+%% statValue = V1},
+%% #'StatisticsParameter'{statName = N2,
+%% statValue = V2}) ->
+%% validate(fun() -> chk_PkgdName(N1, N2) end, 'StatisticsParameter'),
+%% validate(fun() -> chk_opt_Value(V1, V2) end, 'StatisticsParameter'),
+%% ok;
+%% chk_StatisticsParameter(P1, P2) ->
+%% wrong_type('StatisticsParameter', P1, P2).
+
+
+%% %% -- NonStandardData --
+
+%% is_opt_NonStandardData(asn1_NOVALUE) ->
+%% true;
+%% is_opt_NonStandardData(NSD) ->
+%% is_NonStandardData(NSD).
+
+%% %% is_NonStandardData(#'NonStandardData'{nonStandardIdentifier = Id,
+%% %% data = D}) ->
+%% %% is_NonStandardIdentifier(Id) andalso is_OCTET_STRING(D);
+%% %% is_NonStandardData(_) ->
+%% %% false.
+
+%% is_NonStandardData(_) ->
+%% true.
+
+%% chk_opt_NonStandardData(asn1_NOVALUE, asn1_NOVALUE) ->
+%% true;
+%% chk_opt_NonStandardData(NSD1, NSD2) ->
+%% chk_NonStandardData(NSD1, NSD2).
+
+%% chk_NonStandardData(NSD, NSD) ->
+%% chk_type(fun is_NonStandardData/1, 'NonStandardData', NSD);
+%% %% chk_NonStandardData(#'NonStandardData'{nonStandardIdentifier = Id1,
+%% %% data = D1},
+%% %% #'NonStandardData'{nonStandardIdentifier = Id2,
+%% %% data = D2}) ->
+%% %% validate(fun() -> chk_NonStandardIdentifier(Id1, Id2) end,
+%% %% 'NonStandardData'),
+%% %% validate(fun() -> chk_OCTET_STRING(D1, D2) end, 'NonStandardData'),
+%% %% ok;
+%% %% chk_NonStandardData(NSD1, NSD2) ->
+%% %% wrong_type('NonStandardData', NSD1, NSD2).
+%% chk_NonStandardData(NSD1, NSD2) ->
+%% not_equal('NonStandardData', NSD1, NSD2).
+
+
+%% %% -- NonStandardIdentifier --
+
+%% %% is_NonStandardIdentifier({Tag, Val}) ->
+%% %% is_NonStandardIdentifier_tag(Tag) andalso
+%% %% is_NonStandardIdentifier_val(Tag, Val);
+%% %% is_NonStandardIdentifier(_) ->
+%% %% false.
+
+%% %% is_NonStandardIdentifier_tag(Tag) ->
+%% %% Tags = [object, h221NonStandard, experimental],
+%% %% lists:member(Tag, Tags).
+
+%% %% is_NonStandardIdentifier_val(object, Val) ->
+%% %% is_OBJECT_IDENTIFIER(Val);
+%% %% is_NonStandardIdentifier_val(h221NonStandard, Val) ->
+%% %% is_H221NonStandard(Val);
+%% %% is_NonStandardIdentifier_val(experimental, Val) ->
+%% %% is_IA5String(Val, {exact, 8}).
+
+%% %% chk_NonStandardIdentifier(Id, Id) ->
+%% %% chk_type(fun is_NonStandardIdentifier/1, 'NonStandardIdentifier', Id);
+%% %% chk_NonStandardIdentifier({Tag, Val1} = Id1, {Tag, Val2} = Id2) ->
+%% %% case (is_NonStandardIdentifier_tag(Tag) andalso
+%% %% is_NonStandardIdentifier_val(Tag, Val1) andalso
+%% %% is_NonStandardIdentifier_val(Tag, Val1)) of
+%% %% true ->
+%% %% chk_NonStandardIdentifier_val(Tag, Val1, Val2);
+%% %% false ->
+%% %% wrong_type('NonStandardIdentifier', Id1, Id2)
+%% %% end;
+%% %% chk_NonStandardIdentifier({Tag1, Val1} = Id1, {Tag2, Val2} = Id2) ->
+%% %% case ((is_NonStandardIdentifier_tag(Tag1) andalso
+%% %% is_NonStandardIdentifier_val(Tag1, Val1)) andalso
+%% %% (is_NonStandardIdentifier_tag(Tag2) andalso
+%% %% is_NonStandardIdentifier_val(Tag2, Val1))) of
+%% %% true ->
+%% %% not_equal('NonStandardIdentifier', Id1, Id2);
+%% %% false ->
+%% %% wrong_type('NonStandardIdentifier', Id1, Id2)
+%% %% end;
+%% %% chk_NonStandardIdentifier(Id1, Id2) ->
+%% %% wrong_type('NonStandardIdentifier', Id1, Id2).
+
+%% %% chk_NonStandardIdentifier_val(object, Val1, Val2) ->
+%% %% chk_OBJECT_IDENTIFIER(Val1, Val2);
+%% %% chk_NonStandardIdentifier_val(h221NonStandard, Val1, Val2) ->
+%% %% chk_H221NonStandard(Val1, Val2);
+%% %% chk_NonStandardIdentifier_val(experimental, Val1, Val2) ->
+%% %% chk_IA5String(Val1, Val2, {exact, 8}).
+
+
+%% %% -- H221NonStandard --
+
+%% %% is_H221NonStandard(#'H221NonStandard'{t35CountryCode1 = CC1,
+%% %% t35CountryCode2 = CC2,
+%% %% t35Extension = Ext,
+%% %% manufacturerCode = MC}) ->
+%% %% is_INTEGER(CC1, {range, 0, 255}) andalso
+%% %% is_INTEGER(CC2, {range, 0, 255}) andalso
+%% %% is_INTEGER(Ext, {range, 0, 255}) andalso
+%% %% is_INTEGER(Ext, {range, 0, 65535});
+%% %% is_H221NonStandard(_) ->
+%% %% false.
+
+%% %% chk_H221NonStandard(NS, NS) ->
+%% %% chk_type(fun is_H221NonStandard/1, 'H221NonStandard', NS);
+%% %% chk_H221NonStandard(#'H221NonStandard'{t35CountryCode1 = CC11,
+%% %% t35CountryCode2 = CC21,
+%% %% t35Extension = Ext1,
+%% %% manufacturerCode = MC1},
+%% %% #'H221NonStandard'{t35CountryCode1 = CC12,
+%% %% t35CountryCode2 = CC22,
+%% %% t35Extension = Ext2,
+%% %% manufacturerCode = MC2}) ->
+%% %% validate(fun() -> chk_INTEGER(CC11, CC12, {range, 0, 255}) end,
+%% %% 'H221NonStandard'),
+%% %% validate(fun() -> chk_INTEGER(CC21, CC22, {range, 0, 255}) end,
+%% %% 'H221NonStandard'),
+%% %% validate(fun() -> chk_INTEGER(Ext1, Ext2, {range, 0, 255}) end,
+%% %% 'H221NonStandard'),
+%% %% validate(fun() -> chk_INTEGER(MC1, MC2, {range, 0, 65535}) end,
+%% %% 'H221NonStandard'),
+%% %% ok;
+%% %% chk_H221NonStandard(NS1, NS2) ->
+%% %% wrong_type('H221NonStandard', NS1, NS2).
+
+
+%% %% -- TimeNotation --
+
+%% is_opt_TimeNotation(asn1_NOVALUE) ->
+%% true;
+%% is_opt_TimeNotation(TN) ->
+%% is_TimeNotation(TN).
+
+%% is_TimeNotation(#'TimeNotation'{date = D, time = T}) ->
+%% is_IA5String(D, {exact, 8}) andalso is_IA5String(T, {exact, 8});
+%% is_TimeNotation(_) ->
+%% false.
+
+%% chk_opt_TimeNotation(asn1_NOVALUE, asn1_NOVALUE) ->
+%% ok;
+%% chk_opt_TimeNotation(TN1, TN2) ->
+%% chk_TimeNotation(TN1, TN2).
+
+%% chk_TimeNotation(TN, TN) ->
+%% chk_type(fun is_TimeNotation/1, 'TimeNotation', TN);
+%% chk_TimeNotation(#'TimeNotation'{date = D1, time = T1},
+%% #'TimeNotation'{date = D2, time = T2}) ->
+%% validate(fun() -> chk_IA5String(D1, D2, {exact, 8}) end, 'TimeNotation'),
+%% validate(fun() -> chk_IA5String(T1, T2, {exact, 8}) end, 'TimeNotation'),
+%% ok;
+%% chk_TimeNotation(TN1, TN2) ->
+%% wrong_type('TimeNotation', TN1, TN2).
+
+
+%% %% -- Value --
+
+%% is_opt_Value(V) ->
+%% is_OPTIONAL(fun is_Value/1, V).
+
+is_Value([]) ->
+ true;
+is_Value([H|T]) ->
+ is_OCTET_STRING(H) andalso is_Value(T);
+is_Value(_) ->
+ false.
+
+%% chk_opt_Value(V1, V2) ->
+%% chk_OPTIONAL('Value', V1, V2, fun is_Value/1, fun chk_Value/2).
+
+%% chk_Value(V, V) ->
+%% case is_Value(V) of
+%% true ->
+%% ok;
+%% false ->
+%% wrong_type('Value', V, V)
+%% end;
+%% chk_Value(V1, V2) ->
+%% case (is_Value(V1) andalso is_Value(V2)) of
+%% true ->
+%% not_equal('Value', V1, V2);
+%% false ->
+%% wrong_type('Value', V1, V2)
+%% end.
+
+
+%% %% ----------------------------------------------------------------------
+%% %% Basic type check functions
+%% %% ----------------------------------------------------------------------
+
+
+is_opt_BOOLEAN(B) ->
+ is_OPTIONAL(fun is_BOOLEAN/1, B).
+
+is_BOOLEAN(B) ->
+ lists:member(B, [true, false]).
+
+%% chk_opt_BOOLEAN(B1, B2) ->
+%% chk_OPTIONAL('BOOLEAN', B1, B2, fun is_BOOLEAN/1, fun chk_BOOLEAN/2).
+
+%% chk_BOOLEAN(B, B) ->
+%% chk_type(fun is_BOOLEAN/1, 'BOOLEAN', B);
+%% chk_BOOLEAN(B1, B2) ->
+%% case (is_BOOLEAN(B1) andalso is_BOOLEAN(B2)) of
+%% true ->
+%% not_equal('BOOLEAN', B1, B2);
+%% false ->
+%% wrong_type('BOOLEAN', B1, B2)
+%% end.
+
+
+%% is_IA5String(S) when list(S) ->
+%% true;
+%% is_IA5String(_) ->
+%% false.
+
+%% is_IA5String(S, _) when list(S) ->
+%% true;
+%% is_IA5String(_, _) ->
+%% false.
+
+%% %% chk_IA5String(S, S) ->
+%% %% chk_type(fun is_IA5String/1, 'IA5String', S);
+%% %% chk_IA5String(S1, S2) ->
+%% %% case (is_IA5String(S1) andalso is_IA5String(S2)) of
+%% %% true ->
+%% %% not_equal('IA5String', S1, S2);
+%% %% false ->
+%% %% wrong_type('IA5String', S1, S2)
+%% %% end.
+
+%% chk_IA5String(S, S, R) ->
+%% chk_type(fun is_IA5String/2, 'IA5String', S, R);
+%% chk_IA5String(S1, S2, R) ->
+%% case (is_IA5String(S1, R) andalso is_IA5String(S2, R)) of
+%% true ->
+%% not_equal('IA5String', S1, S2);
+%% false ->
+%% wrong_type('IA5String', S1, S2)
+%% end.
+
+
+is_OCTET_STRING(L) -> is_OCTET_STRING(L, any).
+
+is_OCTET_STRING(L, any) when is_list(L) ->
+ true;
+is_OCTET_STRING(L, {exact, Len}) when is_list(L) andalso (length(L) =:= Len) ->
+ true;
+is_OCTET_STRING(L, {atleast, Len}) when is_list(L) andalso (Len =< length(L)) ->
+ true;
+is_OCTET_STRING(L, {atmost, Len}) when is_list(L) andalso (length(L) =< Len) ->
+ true;
+is_OCTET_STRING(L, {range, Min, Max})
+ when is_list(L) andalso (Min =< length(L)) andalso (length(L) =< Max) ->
+ true;
+is_OCTET_STRING(_, _) ->
+ false.
+
+%% %% chk_OCTET_STRING(L1, L2) ->
+%% %% chk_OCTET_STRING(L1, L2, any).
+
+%% chk_OCTET_STRING(L, L, R) ->
+%% chk_type(fun is_OCTET_STRING/2, 'OCTET STRING', L, R);
+%% chk_OCTET_STRING(L1, L2, R) ->
+%% case (is_OCTET_STRING(L1, R) andalso is_OCTET_STRING(L2, R)) of
+%% true ->
+%% not_equal('OCTET STRING', L1, L2);
+%% false ->
+%% wrong_type('OCTET STRING', L1, L2)
+%% end.
+
+
+%% %% is_OBJECT_IDENTIFIER(_) ->
+%% %% true.
+
+%% %% chk_OBJECT_IDENTIFIER(X, X) ->
+%% %% ok;
+%% %% chk_OBJECT_IDENTIFIER(X1, X2) ->
+%% %% not_equal('OBJECT IDENTIFIER', X1, X2).
+
+
+%% is_opt_NULL(N) ->
+%% is_OPTIONAL(fun is_NULL/1, N).
+
+%% is_NULL('NULL') ->
+%% true;
+%% is_NULL(_) ->
+%% false.
+
+%% chk_opt_NULL(N1, N2) ->
+%% chk_OPTIONAL('NULL', N1, N2, fun is_NULL/1, fun chk_NULL/2).
+
+%% chk_NULL(N, N) ->
+%% chk_type(fun is_NULL/1, 'NULL', N);
+%% chk_NULL(N1, N2) ->
+%% case (is_NULL(N1) andalso is_NULL(N2)) of
+%% true ->
+%% not_equal('NULL', N1, N2);
+%% false ->
+%% wrong_type('NULL', N1, N2)
+%% end.
+
+
+is_opt_INTEGER(I, R) ->
+ is_OPTIONAL(fun(X) -> is_INTEGER(X, R) end, I).
+
+is_INTEGER(I, any) when is_integer(I) ->
+ true;
+is_INTEGER(I, {exact, I}) when is_integer(I) ->
+ true;
+is_INTEGER(I, {atleast, Min}) when is_integer(I) andalso is_integer(Min) andalso (Min =< I) ->
+ true;
+is_INTEGER(I, {atmost, Max}) when is_integer(I) andalso is_integer(Max) andalso (I =< Max) ->
+ true;
+is_INTEGER(I, {range, Min, Max})
+ when is_integer(I) andalso
+ is_integer(Min) andalso
+ is_integer(Max) andalso
+ (Min =< I) andalso
+ (I =< Max) ->
+ true;
+is_INTEGER(_, _) ->
+ false.
+
+%% chk_opt_INTEGER(I1, I2, R) ->
+%% chk_OPTIONAL('INTEGER', I1, I2,
+%% fun(X) -> is_INTEGER(X, R) end,
+%% fun(Y1, Y2) -> chk_INTEGER(Y1, Y2, R) end).
+
+%% chk_INTEGER(I, I, R) ->
+%% chk_type(fun is_INTEGER/2, 'INTEGER', I, R);
+%% chk_INTEGER(I1, I2, R) ->
+%% case (is_INTEGER(I1, R) andalso is_INTEGER(I2, R)) of
+%% true ->
+%% not_equal('INTEGER', I1, I2);
+%% false ->
+%% wrong_type('INTEGER', I1, I2)
+%% end.
+
+
+%% %% ----------------------------------------------------------------------
+%% %% Various utility functions
+%% %% ----------------------------------------------------------------------
+
+
+%% to_lower([C|Cs]) when C >= $A, C =< $Z ->
+%% [C+($a-$A)|to_lower(Cs)];
+%% to_lower([C|Cs]) ->
+%% [C|to_lower(Cs)];
+%% to_lower([]) ->
+%% [].
+
+
+%% validate(F, Type) when function(F) ->
+%% case (catch F()) of
+%% {error, Reason} ->
+%% error({Type, Reason});
+%% ok ->
+%% ok
+%% end.
+
+
+%% chk_type(F, T, V) when function(F), atom(T) ->
+%% case F(V) of
+%% true ->
+%% ok;
+%% false ->
+%% wrong_type(T, V)
+%% end.
+
+%% chk_type(F, T, V1, V2) when function(F), atom(T) ->
+%% case F(V1, V2) of
+%% true ->
+%% ok;
+%% false ->
+%% wrong_type(T, V1)
+%% end.
+
+
+is_OPTIONAL(_, asn1_NOVALUE) ->
+ true;
+is_OPTIONAL(F, Val) when is_function(F) ->
+ F(Val).
+
+%% chk_OPTIONAL(_, asn1_NOVALUE, asn1_NOVALUE, _, _) ->
+%% ok;
+%% chk_OPTIONAL(Type, asn1_NOVALUE = V1, V2, IS, _CHK) when function(IS) ->
+%% case IS(V2) of
+%% true ->
+%% not_equal(Type, V1, V2);
+%% false ->
+%% wrong_type(Type, V1, V2)
+%% end;
+%% chk_OPTIONAL(Type, V1, asn1_NOVALUE = V2, IS, _CHK) when function(IS) ->
+%% case IS(V1) of
+%% true ->
+%% not_equal(Type, V1, V2);
+%% false ->
+%% wrong_type(Type, V1, V2)
+%% end;
+%% chk_OPTIONAL(_Type, V1, V2, _IS, CHK) when function(CHK) ->
+%% CHK(V1, V2).
+
+
+%% %% ----------------------------------------------------------------------
+
+%% compare_strings([] = L1, L2) ->
+%% {L1, L2};
+%% compare_strings(L1, [] = L2) ->
+%% {L1, L2};
+%% compare_strings([H|T1], [H|T2]) ->
+%% compare_strings(T1, T2);
+%% compare_strings(L1, L2) ->
+%% {L1, L2}.
+
+%% strip_tab_and_newline([]) ->
+%% [];
+%% strip_tab_and_newline([$\n|T]) ->
+%% strip_tab_and_newline(T);
+%% strip_tab_and_newline([$\t|T]) ->
+%% strip_tab_and_newline(T);
+%% strip_tab_and_newline([H|T]) ->
+%% [H|strip_tab_and_newline(T)].
+
+
+%% ----------------------------------------------------------------------
+
+%% atmost_once(Type, Val) ->
+%% error({atmost_once, {Type, Val}}).
+
+%% wrong_type(Type, Val) ->
+%% error({wrong_type, {Type, Val}}).
+
+%% wrong_type(Type, Val1, Val2) ->
+%% error({wrong_type, {Type, Val1, Val2}}).
+
+%% not_equal(What, Val1, Val2) ->
+%% error({not_equal, {What, Val1, Val2}}).
+
+error(Reason) ->
+ throw({error, Reason}).
+
+
+%% ----------------------------------------------------------------------
+
+%% d(F) ->
+%% d(F, []).
+
+d(F, A) ->
+ d(get(dbg), F, A).
+
+d(true, F, A) ->
+ io:format("DBG:" ++ F ++ "~n", A);
+d(_, _, _) ->
+ ok.
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-01 00:24:06 +0000