-- ECN module extracted from ITU-T X.1084 (05/2008)



TSM-ENCODING {itu-t(0) recommendation(0) x(24) tsm-1(1084) modules(0) tls-extended-protocol-encoding(3) version1(1)}
ENCODING-DEFINITIONS ::=
BEGIN

EXPORTS 
TSM-encodings,
Directory-encodings,
HelloRequest-encodings,ClientHello-encodings,ServerHello-encodings,
CertificateList-encodings,ServerKeyExchange-encodings,
CertificateRequest-encodings,
ServerHelloDone-encodings,CertificateVerify-encodings,
ClientKeyExchange-encodings,
Finished-encodings,CertificateURL-encodings,
CertificateStatus-encodings,
BiometricClientHello-encodings,
BiometricServerHello-encodings,
BiometricVerify-encodings,BiometricRetryRequest-encodings,
BiometricFinished-encodings,BiometricTTPRequest-encodings,
BiometricTTPResponse-encodings;

IMPORTS 
#Opaque,#Handshake,#HelloRequest,#ClientHello,
#ProtocolVersion,#ClientRandom,#CipherSuites,
#CompressionMethods,#TLSPlainText,
#TLSCompressed,#TLSCipherText,#TLSStreamCipherText,#TLSBlockCipherText,
#GenericStreamCipher,#GenericBlockCipher,#ChangeCipherSpec,
#ServerHello,#ServerRandom,
#CertificateList,#Certificates,#ServerKeyExchange,
#ServerDHParams,#ServerRSAParams,#Signature,
#CertificateRequest,#ClientCertificateTypes,
#DistinguishedNames,#ServerHelloDone,#ClientKeyExchange,
#PreMasterSecret,
#CertificateVerify,
#Finished,#CertificateURL,#URLAndOptionalHashList,
#URLAndOptionalHash,#SHA1Hash,#CertificateStatus,
#ServerNameList,#ListOfServerName,#ServerName,
#MaxFragmentLength,#ClientCertificateURL,#TrustedAuthorities,
#ListOfTrustedAuthority,#TrustedAuthority,#TruncatedHMAC,
#CertificateStatusRequest,#OCSPStatusRequest,
#ResponderIDList,#TLS-ExtensionValues,
#TLS-ExtensionValue,#BiometricClientHello,#BiometricMethod,
#BSP-BFP-Schema,#BSP-BFP-Schemas,
#BiometricServerHello,#Quality,
#BiometricAuthenticationRequest,#XtsmTemplate,#BiometricVerify,
#SignedDatabyClient,#BDforLocalModel,#BiometricClientProcess,
#TemplateID,#TemplateInfo,#CertificateIDInformation,
#BDforDownloadModel,#BDforAttachedModel,#BDforCenterModel,
#BDforRefOnTTPforLocalModel,#BDforRefOnTTPforCenterModel,
#BDforCObyClientModel,
#BDforCObyServerModel,#BDforSCObyClientModel,#BDforSCObyServerModel,
#BiometricRetryRequest,#Alert,
#BiometricFinished,#BiometricAuthenticationResult,
#BiometricTTPRequest,#BDforStorageOutsourcing,
#BDforComparisonOutsourcing,
#BiometricTTPResponse,#RBDforStorageOutsourcing,
#RBDforComparisonOutsourcing,#SignedDatabyTTP,
#ApplicationData,#SampleData
	FROM TSM{itu-t(0) recommendation(0) x(24) tsm-1(1084) modules(0) tls-extended-protocol(1) version1(1)}

#BiometricCertificate
	FROM TAI{itu-t(0) recommendation(0) x(24) tai(1089) modules(0) framework(0) version1(1)}

#BioAPI-BFP-SCHEMA,#BioAPI-BSP-SCHEMA,#BioAPI-FMR,#BioAPI-BIR
	FROM BIP{joint-iso-itu-t bip(41) modules(0) bip(0) version1(1)}

#DistinguishedName,#Name
	FROM InformationFramework{joint-iso-itu-t ds(5) module(1) informationFramework(1) 5}

#Certificate, #CertificateSerialNumber
	FROM AuthenticationFramework{joint-iso-itu-t ds(5) module(1) authenticationFramework(7) 5}

#ID
	FROM UsefulDefinitions{joint-iso-itu-t ds(5) module(1) usefulDefinitions(0) 5}

#SignedData
  	FROM CryptographicMessageSyntax2004{iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) smime(16) modules(0) cms-2004(24)} -- RFC 3852

#SignedDataACBio
	FROM AuthenticationContextForBiometrics{iso(1) standard(0) acbio(24761) module(1) acbio(2) version1(1)} -- iSO/IEC 24761:2009

#BiometricType
	FROM CBEFF-DATA-ELEMENTS{iso standard 19785 modules(0) types-for-cbeff-data-elements(1)};

TSM-encodings	#ENCODINGS ::= {
outer-encoding |
iD-encoding |
tLSPlainText-encoding |
tLSCompressed-encoding |
tLSCipherText-encoding |
tLSStreamCipherText-encoding |
tLSBlockCipherText-encoding |
changeCipherSpec-encoding |
sampleData-encoding |
alert-encoding |
handshake-encoding |
preMasterSecret-encoding |
applicationData-encoding
}
Directory-encodings     #ENCODINGS ::= {
BER }
outer-encoding #OUTER ::= {
ADDED BITS DECODING next-value
}
iD-encoding     #ID     ::= {
ENCODE WITH Directory-encodings
}

integer-1-encoding	#INT ::= {
ENCODING {
	ENCODING-SPACE
		SIZE 1
		MULTIPLE OF octet
	ENCODING positive-int
	}
}

integer-2-encoding	#INT ::= {
ENCODING {
	ENCODING-SPACE
		SIZE 2
		MULTIPLE OF octet
	ENCODING positive-int
	}
}
integer-3-encoding	#INT ::= {
ENCODING {
	ENCODING-SPACE
		SIZE 3
		MULTIPLE OF octet
	ENCODING positive-int
	}
}
integer-4-encoding	#INT ::= {
ENCODING {
	ENCODING-SPACE
		SIZE 4
		MULTIPLE OF octet
	ENCODING positive-int
	}
}
enumerated-1-encoding	#ENUMERATED ::= {
ENCODING {
	ENCODING-SPACE
		SIZE 1
		MULTIPLE OF octet
	ENCODING positive-int
	}
}
enumerated-2-encoding	#ENUMERATED ::= {
ENCODING {
	ENCODING-SPACE
		SIZE 2
		MULTIPLE OF octet
	ENCODING positive-int
	}
}
boolean-encoding	#BOOLEAN ::= {
ENCODING-SPACE
	SIZE 1
	MULTIPLE OF octet
TRUE-PATTERN octets:'01'H
FALSE-PATTERN octets:'00'H
}
opaque-1-encoding         #OCTETS ::=     {
REPETITION-ENCODING {
	REPLACE STRUCTURE
		WITH #OpaqueWithLength
		ENCODED BY opaque-1WithLength-encoding
	}
}
#OpaqueWithLength{<#Element>}	::=	#CONCATENATION {
length	#INT,
element	#Element
}
opaque-1WithLength-encoding{<#Element>}	
#OpaqueWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length	integer-1-encoding,
	element countedOctetString-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
countedOctetString-encoding{<REFERENCE:length>}	#OCTETS ::= {
REPETITION-ENCODING {
	REPETITION-SPACE
		SIZE variable-with-determinant
			MULTIPLE OF octet
		DETERMINED BY field-to-be-set
			USING length
	}
}
opaque-2-encoding         #OCTETS ::=     {
REPETITION-ENCODING {
	REPLACE STRUCTURE
		WITH #OpaqueWithLength
		ENCODED BY opaque-2WithLength-encoding
		}
	}
opaque-2WithLength-encoding{<#Element>}	
#OpaqueWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length	integer-2-encoding,
	element countedOctetString-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
opaque-3-encoding	#OCTETS ::=	{
REPETITION-ENCODING {
	REPLACE STRUCTURE
		WITH #OpaqueWithLength
		ENCODED BY opaque-3WithLength-encoding
	}
}
opaque-3WithLength-encoding{<#Element>}	
#OpaqueWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length	integer-3-encoding,
	element	countedOctetString-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
#SequenceOfWithLength{<#Element>}	::= #CONCATENATION {
length	#INT,
value	#Element
}
sequenceOfWithLength-encoding{<REFERENCE:length>} 	#REPETITION ::= {
REPETITION-ENCODING {
	REPETITION-SPACE
		SIZE variable-with-determinant
			MULTIPLE OF octet
		DETERMINED BY field-to-be-set
			USING length
	}
}
#StructureWithLength{<#Element>} ::= #CONCATENATION {
length	#INT,
value	#Element
}
structureWithLength-encoding{<REFERENCE:length>}	
#CONCATENATION ::= {
ENCODING-SPACE
	SIZE variable-with-determinant
		MULTIPLE OF octet
	DETERMINED BY field-to-be-set
		USING length
}
structure-encoding	#CONCATENATION ::= {
ENCODING-SPACE
	SIZE self-delimiting-values
}
#Presence ::= #OPTIONAL
presence-encoding{<REFERENCE:flag>}	#OPTIONAL ::= {
PRESENCE
	DETERMINED BY field-to-be-set
		USING flag	
}
tLSPlainText-encoding	#TLSPlainText		::= {
ENCODE STRUCTURE {
	type	enumerated-1-encoding,
	version	USE-SET,
	fragment opaque-2-encoding
	}
WITH PER-BASIC-UNALIGNED
}
tLSCompressed-encoding  #TLSCompressed           ::= {
ENCODE STRUCTURE {
	type	enumerated-1-encoding,
	version	USE-SET,
	fragment opaque-2-encoding
	}
WITH PER-BASIC-UNALIGNED
}
tLSCipherText-encoding  #TLSCipherText           ::= {
ENCODE STRUCTURE {
	type	enumerated-1-encoding,
	version	USE-SET,
     		fragment {
			ENCODE STRUCTURE {
				stream  genericStreamCipher-encoding,
				block   genericBlockCipher-encoding
				STRUCTURED WITH cipherType-encoding
				}
			}
		}
	WITH PER-BASIC-UNALIGNED
	}
tLSStreamCipherText-encoding	#TLSStreamCipherText ::= {
ENCODE STRUCTURE {
	type	enumerated-1-encoding,
	version	USE-SET,
	fragment	genericStreamCipher-encoding
	}
WITH PER-BASIC-UNALIGNED
}
tLSBlockCipherText-encoding	#TLSBlockCipherText ::= {
ENCODE STRUCTURE {
	type	enumerated-1-encoding,
	version	USE-SET,
	fragment	genericBlockCipher-encoding
	}
WITH PER-BASIC-UNALIGNED
}
genericStreamCipher-encoding    #GenericStreamCipher    ::=     {
	ENCODE STRUCTURE {
		content opaque-2-encoding,
		mAC     opaque-2-encoding
	}
WITH PER-BASIC-UNALIGNED
}
genericBlockCipher-encoding     #GenericBlockCipher     ::=     {
ENCODE STRUCTURE {
	content opaque-2-encoding,
	mAC     opaque-2-encoding,
  	padding opaque-2-encoding
 	}
WITH PER-BASIC-UNALIGNED
}
cipherType-encoding     #ALTERNATIVES ::=
NON-ECN-BEGIN
	extern cipherType;
	return(cipherType);
	NON-ECN-END
changeCipherSpec-encoding #ChangeCipherSpec ::= enumerated-1-encoding
sampleData-encoding	#SampleData ::= {
ENCODE STRUCTURE {
	patronFormatOwner	USE-SET,
	patronFormatType	USE-SET,
	formattedBIR		formattedBIR-encoding}
WITH PER-BASIC-UNALIGNED
}
formattedBIR-encoding	#OCTETS ::= opaque-2-encoding
alert-encoding	#Alert ::= {
ENCODE STRUCTURE {
	level		enumerated-1-encoding,
	description	enumerated-1-encoding
	}
WITH PER-BASIC-UNALIGNED
}
handshake-encoding	#OPEN-TYPE ::= {
REPLACE STRUCTURE
	WITH #OpaqueWithLength
	ENCODED BY handshakeWithLength-encoding
}
handshakeWithLength-encoding{<#Element>}
#OpaqueWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length	integer-3-encoding,
	element	handshakeValue-encoding{<length>}}
WITH PER-BASIC-UNALIGNED
}
handshakeValue-encoding{<REFERENCE:length>}	#OPEN-TYPE ::= {
ENCODING-SPACE
	SIZE variable-with-determinant
		MULTIPLE OF octet
	DETERMINED BY field-to-be-set
	USING length	
ENCODED WITH Handshake-encodings
}
preMasterSecret-encoding	#PreMasterSecret ::= {
ENCODE STRUCTURE {
	client-version	protocolVersion-encoding,
	random		USE-SET
	}
WITH PER-BASIC-UNALIGNED
}
protocolVersion-encoding	#ProtocolVersion ::= {
ENCODE STRUCTURE {
	major	USE-SET,
	minor	USE-SET
	}
WITH PER-BASIC-UNALIGNED
}
biometricCertificate	#BiometricCertificate ::= {
ENCODE WITH Directory-encodings
}
Handshake-encodings	#ENCODINGS ::= { 
helloRequest-encoding	|
clientHello-encoding	|
serverHello-encoding	|
certificateList-encoding |
serverKeyExchange-encoding |
certificateRequest-encoding |
serverHelloDone-encoding |
certificateVerify-encoding |
clientKeyExchange-encoding |
finished-encoding |
certificateURL-encoding |
certificateStatus-encoding |
biometricClientHello-encoding |
biometricServerHello-encoding |
biometricVerify-encoding |
biometricRetryRequest-encoding |
biometricFinished-encoding |
biometricTTPRequest-encoding |
biometricTTPResponse-encoding
}
HelloRequest-encodings	#ENCODINGS ::= {
	helloRequest-encoding
	}
helloRequest-encoding #HelloRequest ::=
{ENCODE WITH PER-BASIC-UNALIGNED}
ClientHello-encodings	#ENCODINGS ::= {
clientHello-encoding
}
clientHello-encoding	#ClientHello ::= {
ENCODE STRUCTURE {
	client-version			protocolVersion-encoding,
	random				clientRandom-encoding,
	session-id				USE-SET,
	cipher-suites			cipherSuites-encoding,
	compression-methods		compressionMethods-encoding,
	client-hello-extension-list	tLS-Extensions-encoding
	}
WITH PER-BASIC-UNALIGNED
}
compressionMethods-encoding		#SEQUENCE-OF ::= {
REPETITION-ENCODING {
	REPLACE STRUCTURE
		WITH #SequenceOfWithLength
		ENCODED BY compressionMethodsWithLength-encoding
	}
}
compressionMethodsWithLength-encoding{<#Element>}	
#SequenceOfWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length	integer-1-encoding,
	value	compressionMethodsValue-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
cipherSuites-encoding		#SEQUENCE-OF ::= {
REPETITION-ENCODING {
	REPLACE STRUCTURE
		WITH #SequenceOfWithLength
		ENCODED BY cipherSuitesWithLength-encoding
	}
}
cipherSuitesWithLength-encoding{<#Element>} 
#SequenceOfWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length	integer-2-encoding,
	value	cipherSuitesValue-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
cipherSuitesValue-encoding{<REFERENCE:length>}	#CipherSuites ::= {
ENCODE STRUCTURE {
	enumerated-2-encoding
	STRUCTURED WITH sequenceOfWithLength-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
ServerNameList-encodings #ENCODINGS ::= {
serverNameList-encoding
}
MaxFragmentLength-encodings	#ENCODINGS ::= {
maxFragmentLength-encoding
}
ClientCertificateURL-encodings	#ENCODINGS ::= {
clientCertificateURL-encoding
}
TrustedAuthorities-encodings	#ENCODINGS ::= {
trustedAuthorities-encoding
}
TruncatedHMAC-encodings	#ENCODINGS ::= {
truncatedHMAC-encoding
}
CertificateStatusRequest-encodings	#ENCODINGS ::= {
certificateStatusRequest-encoding
}
serverNameList-encoding #ServerNameList ::= {
ENCODE STRUCTURE {
	server-name-list	listOfServerName-encoding
	}
WITH PER-BASIC-UNALIGNED
}
listOfServerName-encoding	#SEQUENCE-OF ::= {
REPETITION-ENCODING {
	REPLACE STRUCTURE 
		WITH #SequenceOfWithLength
		ENCODED BY listOfServerNameWithLength-encoding
	}
}
listOfServerNameWithLength-encoding{<#Element>} 
#SequenceOfWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length	integer-2-encoding,
	value	listOfServerNameValue-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
listOfServerNameValue-encoding{<REFERENCE:length>} #ListOfServerName ::= {
ENCODE STRUCTURE {
	serverName-encoding
	STRUCTURED WITH sequenceOfWithLength-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
serverName-encoding	#ServerName ::= {
ENCODE STRUCTURE {
	host-name	[serverNameTag-encoding] opaque-2-encoding
	STRUCTURED WITH serverNameChoice-encoding
	}
}
serverNameTag-encoding	#TAG ::= {
ENCODING-SPACE
	SIZE 1
		MULTIPLE OF octet
	EXHIBITS HANDLE "ServerName" AT {0..7} AS tag:any
}
serverNameChoice-encoding	#ALTERNATIVES ::= {
ALTERNATIVE
	DETERMINED BY handle
		HANDLE "ServerName"
}
maxFragmentLength-encoding      #MaxFragmentLength ::= {
USE #INT-1
MAPPING VALUES {
	 512 TO 1,
	1024 TO 2,
	2048 TO 3,
	4096 TO 4
	}
WITH PER-BASIC-UNALIGNED
}
#INT-1 ::= #INT(0..255)
clientCertificateURL-encoding	#ClientCertificateURL ::=
certificateURL-encoding
trustedAuthorities-encoding     #TrustedAuthorities     ::= {
ENCODE STRUCTURE {
	trusted-authorities-list listOfTrustedAuthority-encoding
	}
WITH PER-BASIC-UNALIGNED
}
listOfTrustedAuthority-encoding 	#SEQUENCE-OF ::= {
REPETITION-ENCODING {
	REPLACE STRUCTURE
		WITH #SequenceOfWithLength
		ENCODED BY listOfTrustedAuthorityWithLength-encoding
	}
}
listOfTrustedAuthorityWithLength-encoding{<#Element>}	
#SequenceOfWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length	integer-2-encoding,
	value	listOfTrustedAuthorityValue-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
listOfTrustedAuthorityValue-encoding{<REFERENCE:length>}	
#ListOfTrustedAuthority ::= {
ENCODE STRUCTURE {
	trustedAuthority-encoding
	STRUCTURED WITH sequenceOfWithLength-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
trustedAuthority-encoding	#TrustedAuthority ::= {
ENCODE STRUCTURE {
	pre-agreed	[trustedAuthorityTag-encoding] USE-SET,
	key-sha1-hash	[trustedAuthorityTag-encoding] USE-SET,
	x509-name	[trustedAuthorityTag-encoding] 
			distinguishedName-encoding,
	cert-sha1-hash	[trustedAuthorityTag-encoding] USE-SET
	STRUCTURED WITH trustedAuthorityChoice-encoding
	}
WITH PER-BASIC-UNALIGNED
}
trustedAuthorityTag-encoding	#TAG ::= {
ENCODING-SPACE
	SIZE 1
		MULTIPLE OF octet
	EXHIBITS HANDLE "TrustedAuthority" AT {0..7} AS tag:any
}
trustedAuthorityChoice-encoding	#ALTERNATIVES ::= {
ALTERNATIVE
	DETERMINED BY handle
		HANDLE "TrustedAuthority"
}
truncatedHMAC-encoding	#TruncatedHMAC ::= {
ENCODE WITH PER-BASIC-UNALIGNED
}
certificateStatusRequest-encoding       #CertificateStatusRequest ::= {
ENCODE STRUCTURE {
	ocsp	[certificateStatusRequestTag-encoding] 
		oCSPStatusRequest-encoding
	STRUCTURED WITH certificateStatusRequestChoice-encoding
	}
WITH PER-BASIC-UNALIGNED
}
certificateStatusRequestTag-encoding	#TAG ::= {
ENCODING-SPACE
	SIZE 1
		MULTIPLE OF octet
EXHIBITS HANDLE "CertificateStatusRequest" AT {0..7} AS tag:any
}
certificateStatusRequestChoice-encoding	#ALTERNATIVES ::= {
ALTERNATIVE
	DETERMINED BY handle
		HANDLE "CertificateStatusRequest"
}
oCSPStatusRequest-encoding	#OCSPStatusRequest ::= {
ENCODE STRUCTURE {
	responder-id-list	responderIDList-encoding,
	request-extensions	opaque-2-encoding
	}
WITH PER-BASIC-UNALIGNED
}
responderIDList-encoding	#SEQUENCE-OF ::= {
REPETITION-ENCODING {
	REPLACE STRUCTURE 
		WITH #SequenceOfWithLength
		ENCODED BY responderIDListWithLength-encoding
	}
}
responderIDListWithLength-encoding{<#Element>}	
#SequenceOfWithLength{<#Element>} ::= {
ENCODE STRUCTURE{
	length	integer-2-encoding,
	value	responderIDListValue-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
responderIDListValue-encoding{<REFERENCE:length>}	#ResponderIDList ::= {
ENCODE STRUCTURE {
	opaque-2-encoding
	STRUCTURED WITH sequenceOfWithLength-encoding{<length>}
	}
}
TLS-Extensions-encodings #ENCODINGS ::= {
ServerNameList-encodings |
MaxFragmentLength-encodings |
ClientCertificateURL-encodings |
TrustedAuthorities-encodings |
TruncatedHMAC-encodings |
CertificateStatusRequest-encodings
}
tLS-Extensions-encoding	#TLS-ExtensionValues ::= {
ENCODE STRUCTURE {
	tLS-ExtensionValue-encoding
	STRUCTURED WITH sequenceOfTLS-Extension-encoding
	}
}
tLS-ExtensionValue-encoding	#TLS-ExtensionValue ::= {	
ENCODE STRUCTURE {
	extension-type	integer-1-encoding,
	extension-data	extension-data-encoding
	STRUCTURED WITH structure-encoding
	}
}
extension-data-encoding	#OPEN-TYPE ::= {
ENCODE WITH TLS-Extensions-encodings
	COMPLETED BY PER-BASIC-UNALIGNED
}
sequenceOfTLS-Extension-encoding	#SEQUENCE-OF ::= {
REPETITION-ENCODING {
	REPETITION-SPACE 
		SIZE variable-with-determinant
			MULTIPLE OF octet
		DETERMINED BY container
			USING OUTER 
	}
}
compressionMethodsValue-encoding{<REFERENCE:length>} #CompressionMethods ::= {
ENCODE STRUCTURE {
	enumerated-1-encoding
	STRUCTURED WITH sequenceOfWithLength-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
clientRandom-encoding		#ClientRandom ::= {
ENCODE STRUCTURE {
	gmt-unix-time	USE-SET,
	random-bytes	USE-SET
	}
WITH PER-BASIC-UNALIGNED
}
ServerHello-encodings	#ENCODINGS ::= {
serverHello-encoding
}
serverHello-encoding	#ServerHello	::= {
ENCODE STRUCTURE {
	server-version			protocolVersion-encoding,
	random				serverRandom-encoding,
	session-id			USE-SET,
	cipher-suite			enumerated-2-encoding,
	compression-method		enumerated-1-encoding,
	server-hello-extension-list	tLS-Extensions-encoding
	}
WITH PER-BASIC-UNALIGNED
}
serverRandom-encoding		#ServerRandom ::= {
ENCODE STRUCTURE {
	gmt-unix-time	USE-SET,
	random-bytes	USE-SET
	}
WITH PER-BASIC-UNALIGNED
}
CertificateList-encodings	#ENCODINGS ::= {
certificateList-encoding
}
certificateList-encoding	#CertificateList	::= {
ENCODE STRUCTURE {
	certificates	certificates-encoding}
WITH PER-BASIC-UNALIGNED
}
certificates-encoding	#SEQUENCE-OF ::= {
REPETITION-ENCODING {
	REPLACE STRUCTURE
		WITH #SequenceOfWithLength
		ENCODED BY certificateListWithLength-encoding
	}
}
certificateListWithLength-encoding{<#Element>} 
#SequenceOfWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length	integer-3-encoding,
	value	certificateListValue-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
certificateListValue-encoding{<REFERENCE:length>}	#Certificates ::= {
ENCODE STRUCTURE {
	x509Certificate-encoding
	STRUCTURED WITH sequenceOfWithLength-encoding{<length>}
	}
}
x509Certificate-encoding	#OCTETS ::= {
REPETITION-ENCODING {
	REPLACE STRUCTURE 
		WITH #OpaqueWithLength
		ENCODED BY x509CertificateWithLength
	}
}
x509CertificateWithLength{<#Element>}	#OpaqueWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length	integer-3-encoding,
	element countedX509Certificate-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
countedX509Certificate-encoding{<REFERENCE:length>}	#OCTETS ::= {
REPETITION-ENCODING {
	REPETITION-SPACE
		SIZE variable-with-determinant
			MULTIPLE OF octet
		DETERMINED BY field-to-be-set
			USING length
		}
	CONTENTS-ENCODING {Directory-encodings}
	}
certificate-encoding #Certificate ::= {ENCODE WITH Directory-encodings}
ServerKeyExchange-encodings	#ENCODINGS ::= {
serverKeyExchange-encoding
}
serverKeyExchange-encoding	#ServerKeyExchange ::= {
ENCODE STRUCTURE {
	rsa [serverKeyExchangeTag-encoding] {
		ENCODE STRUCTURE {
			params		serverRSAParams-encoding,
			signed-params	signature-encoding
			}
		WITH PER-BASIC-UNALIGNED
		},
	diffie-hellman [serverKeyExchangeTag-encoding] {
		ENCODE STRUCTURE {
			params		serverDHParams-encoding,
			signed-params	signature-encoding
			}
		WITH PER-BASIC-UNALIGNED
		}
	STRUCTURED WITH serverKeyExchangeChoice-encoding
	}
}
serverKeyExchangeTag-encoding #TAG ::= {
ENCODING-SPACE
	SIZE 1
		MULTIPLE OF octet
EXHIBITS HANDLE "ServerKeyExchange" AT {0..7} AS tag:any
}
serverKeyExchangeChoice-encoding	#ALTERNATIVES ::= {
ALTERNATIVE
	DETERMINED BY handle
		HANDLE "ServerKeyExchange"
}
serverDHParams-encoding		#ServerDHParams	::= {
ENCODE STRUCTURE {
	dh-p	integer-2-encoding,
	dh-g	integer-2-encoding,
	dh-Ys	integer-2-encoding
	}
WITH PER-BASIC-UNALIGNED
}
signature-encoding #Signature ::= {
ENCODE STRUCTURE {
	anonymous	[signatureTag-encoding] USE-SET,
	rsa		[signatureTag-encoding] USE-SET,
	dsa		[signatureTag-encoding] USE-SET
	STRUCTURED WITH signatureChoice-encoding
	}
WITH PER-BASIC-UNALIGNED
}
signatureTag-encoding	#TAG ::= {
ENCODING-SPACE
	SIZE 1
		MULTIPLE OF octet
EXHIBITS HANDLE "Signature" AT {0..7} AS tag:any
}
signatureChoice-encoding	#ALTERNATIVES ::= {
ALTERNATIVE
	DETERMINED BY handle
		HANDLE "Signature"
}
serverRSAParams-encoding	#ServerRSAParams ::= {
ENCODE STRUCTURE {
	rsa-modulus	integer-2-encoding,
	rsa-exponent	integer-2-encoding
	}
WITH PER-BASIC-UNALIGNED
}
CertificateRequest-encodings	#ENCODINGS ::= {
certificateRequest-encoding
}
certificateRequest-encoding	#CertificateRequest ::= {
ENCODE STRUCTURE {
	certificate-types	clientCertificateTypes-encoding,
	certificate-authorities distinguishedNames-encoding
	}
WITH PER-BASIC-UNALIGNED
}
clientCertificateTypes-encoding	#SEQUENCE-OF ::= {
REPETITION-ENCODING {
	REPLACE STRUCTURE WITH #SequenceOfWithLength
	ENCODED BY clientCertificateTypesWithLength-encoding
	}
}
clientCertificateTypesWithLength-encoding{<#Element>} 
#SequenceOfWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length	integer-1-encoding,
	value	clientCertificateTypesValue-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}	
clientCertificateTypesValue-encoding{<REFERENCE:length>} 
#ClientCertificateTypes ::= {
ENCODE STRUCTURE {
	enumerated-1-encoding
	STRUCTURED WITH sequenceOfWithLength-encoding{<length>}
	}
	WITH PER-BASIC-UNALIGNED
}
distinguishedNames-encoding	#SEQUENCE-OF	::= {
REPETITION-ENCODING {
	REPLACE STRUCTURE WITH #SequenceOfWithLength
	ENCODED BY distinguishedNamesWithLength-encoding
	}
}
distinguishedNamesWithLength-encoding{<#Element>}
#SequenceOfWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length 	integer-2-encoding,
	value	distinguishedNamesValue-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
distinguishedNamesValue-encoding{<REFERENCE:length>} #DistinguishedNames ::= {
ENCODE STRUCTURE {
	distinguishedName-encoding
	STRUCTURED WITH sequenceOfWithLength-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
distinguishedName-encoding	#DistinguishedName ::= {
ENCODE WITH Directory-encodings
}	
ServerHelloDone-encodings	#ENCODINGS ::= {
serverHelloDone-encoding
}
serverHelloDone-encoding #ServerHelloDone ::= 
{ENCODE WITH PER-BASIC-UNALIGNED}
CertificateVerify-encodings	#ENCODINGS ::= {
certificateVerify-encoding
}
certificateVerify-encoding	#CertificateVerify ::= {
ENCODE STRUCTURE {
	signature	signature-encoding
	}
WITH PER-BASIC-UNALIGNED
}
ClientKeyExchange-encodings	#ENCODINGS ::= {
clientKeyExchange-encoding
}
clientKeyExchange-encoding	#ClientKeyExchange ::= opaque-2-encoding
Finished-encodings	#ENCODINGS ::= {
finished-encoding
}
finished-encoding #Finished ::= {ENCODE WITH PER-BASIC-UNALIGNED}
CertificateURL-encodings	#ENCODINGS ::= {
certificateURL-encoding
}
certificateURL-encoding         #CertificateURL ::= {
ENCODE STRUCTURE {
	type			enumerated-1-encoding,
	url-and-hash-list	uRLAndOptionalHashList-encoding
	}
WITH PER-BASIC-UNALIGNED
}
uRLAndOptionalHashList-encoding	#SEQUENCE-OF	::= {
REPETITION-ENCODING {
	REPLACE STRUCTURE
		WITH #SequenceOfWithLength
		ENCODED BY uRLAndOptionalHashListWithLength-encoding
	}
}
uRLAndOptionalHashListWithLength-encoding{<#Element>}
#SequenceOfWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length	integer-2-encoding,
	value	uRLAndOptionalHashListValue-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
uRLAndOptionalHashListValue-encoding{<REFERENCE:length>} 
#URLAndOptionalHashList ::= {
ENCODE STRUCTURE {
	uRLAndOptionalHash-encoding
	STRUCTURED WITH sequenceOfWithLength-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
uRLAndOptionalHash-encoding	#URLAndOptionalHash ::= {
USE	#URLAndOptionalHashWithFlag
	MAPPING FIELDS WITH {
	ENCODE STRUCTURE {
		flag	boolean-encoding,
		url	opaque-2-encoding,
		hash	USE-SET	
			OPTIONAL-ENCODING presence-encoding{<flag>}
		STRUCTURED WITH structure-encoding
		}
	WITH PER-BASIC-UNALIGNED
	}
}
#URLAndOptionalHashWithFlag	::=	#CONCATENATION {
flag	#BOOLEAN,
url	#Opaque,
hash	#SHA1Hash	OPTIONAL-ENCODING #Presence
}
CertificateStatus-encodings	#ENCODINGS ::= {
certificateStatus-encoding
}
certificateStatus-encoding #CertificateStatus ::= 
{ENCODE WITH PER-BASIC-UNALIGNED}
BiometricClientHello-encodings	#ENCODINGS ::= {
biometricClientHello-encoding
}
biometricClientHello-encoding	#SEQUENCE-OF ::= {
REPETITION-ENCODING {
	REPLACE STRUCTURE
		WITH #SequenceOfWithLength
		ENCODED BY biometricClientHelloWithLength-encoding
	}
}
biometricClientHelloWithLength-encoding{<#Element>}
#SequenceOfWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length	integer-2-encoding,
	value	biometricClientHelloValue-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
biometricClientHelloValue-encoding{<REFERENCE:length>} 
#BiometricClientHello ::= {
ENCODE STRUCTURE {
	biometricMethod-encoding
	STRUCTURED WITH sequenceOfWithLength-encoding{<length>}
	}
}
biometricMethod-encoding	#BiometricMethod ::= {
ENCODE STRUCTURE {
	biometricType			USE-SET,
	biometricFunctionProvider	bSP-BFP-Schema-encoding,
	networkAuthenticationModel	USE-SET,
	thirdPartyInfo			uTF8String-encoding
	}
WITH PER-BASIC-UNALIGNED
}			
uTF8String-encoding	#UTF8String ::= {
REPETITION-ENCODING {
	REPLACE STRUCTURE 
		WITH #UTF8StringWithLength
		ENCODED BY uTF8StringWithLength-encoding
	}
}
#UTF8StringWithLength{<#Element>} ::= #CONCATENATION {
	length	#INT(0..65535),
	element	#Element
	}
uTF8StringWithLength-encoding{<#Element>}
#UTF8StringWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length USE-SET,
	element countedString-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
countedString-encoding{<REFERENCE:length>} #UTF8String ::= {
TRANSFORMS {{CHAR-TO-BITS AS iso10646  SIZE 2 MULTIPLE OF octet}}
REPETITION-ENCODING {
	REPETITION-SPACE
		SIZE variable-with-determinant
			MULTIPLE OF octet
		DETERMINED BY field-to-be-set
			USING length
	}
}
bSP-BFP-Schema-encoding		#BSP-BFP-Schema ::= {
ENCODE STRUCTURE {
	bSPSchema	[bSP-BFP-SchemaTag-encoding] 
			bioAPI-BSP-SCHEMA-encoding,
	bFPSchema	[bSP-BFP-SchemaTag-encoding] 
			bioAPI-BFP-SCHEMA-encoding
	STRUCTURED WITH bSP-BFP-SchemaChoice-encoding
	}
}
bSP-BFP-SchemaTag-encoding	#TAG ::= {
ENCODING-SPACE
	SIZE 1
		MULTIPLE OF octet
	EXHIBITS HANDLE "BSP-BFP-Schema" AT {0..7} AS tag:any
}
bSP-BFP-SchemaChoice-encoding	#ALTERNATIVES ::= {
ALTERNATIVE
	DETERMINED BY handle
		HANDLE "BSP-BFP-Schema"
}
bioAPI-BSP-SCHEMA-encoding #BioAPI-BSP-SCHEMA ::= {
ENCODE WITH Directory-encodings
}
bioAPI-BFP-SCHEMA-encoding #BioAPI-BFP-SCHEMA ::= {
ENCODE WITH Directory-encodings
}
BiometricServerHello-encodings	#ENCODINGS ::= {
biometricServerHello-encoding
}
biometricServerHello-encoding #BiometricServerHello ::= 
biometricAuthenticationRequest-encoding
biometricAuthenticationRequest-encoding #BiometricAuthenticationRequest ::= {
USE	#BiometricAuthenticationRequestWithFlag
	MAPPING FIELDS WITH {
	ENCODE STRUCTURE {
		biometricMethod		biometricMethod-encoding,
		requestFMR		USE-SET,
		requestTrialNumber	integer-1-encoding,
		requestQuality		quality-encoding,
		flag			boolean-encoding,
		requestTemplateData	xtsmTemplate-encoding 
			OPTIONAL-ENCODING  presence-encoding{<flag>}
		STRUCTURED WITH structure-encoding
		}
	WITH PER-BASIC-UNALIGNED
	}
}
quality-encoding #Quality ::= integer-1-encoding
#BiometricAuthenticationRequestWithFlag ::= #CONCATENATION {
biometricMethod		#BiometricMethod,
requestFMR			#BioAPI-FMR,
requestTrialNumber     #INT(1..15),
requestQuality		#Quality,
flag				#BOOLEAN,
requestTemplateData	#XtsmTemplate OPTIONAL-ENCODING #Presence
}
xtsmTemplate-encoding	#XtsmTemplate ::= {
ENCODE WITH Directory-encodings
}
BiometricVerify-encodings	#ENCODINGS	::= {
biometricVerify-encoding
}
biometricVerify-encoding	#BiometricVerify ::= {
ENCODE STRUCTURE {
	biometricData {
		ENCODE STRUCTURE {
			no-value
			[networkAuthenticationModelTag-encoding]
				null-value-encoding,
			local-model 	
			[networkAuthenticationModelTag-encoding]	
				bDforLocalModel-encoding,
			download-model  
			[networkAuthenticationModelTag-encoding]
				bDforDownloadModel-encoding,
			attached-model
			[networkAuthenticationModelTag-encoding]
				bDforAttachedModel-encoding,
			center-model
			[networkAuthenticationModelTag-encoding]
				bDforCenterModel-encoding,
			ref-onttp-for-local-model
			[networkAuthenticationModelTag-encoding]
				bDforRefOnTTPforLocalModel-encoding,
			ref-onttp-for-center-model
			[networkAuthenticationModelTag-encoding]
				bDforRefOnTTPforCenterModel-encoding,
			comparison-outsourcing-by-client-model
			[networkAuthenticationModelTag-encoding]
				bDforCObyClientModel-encoding,
			comparison-outsourcing-by-server-model
			[networkAuthenticationModelTag-encoding]
				bDforCObyServerModel-encoding,
			storage-comparison-outsourcing-by-client-model
			[networkAuthenticationModelTag-encoding]
				bDforSCObyClientModel-encoding,
			storage-comparison-outsourcing-by-server-model
			[networkAuthenticationModelTag-encoding]
				bDforSCObyServerModel-encoding
			STRUCTURED WITH 
			networkAuthenticationModelChoice-encoding
			}
		WITH PER-BASIC-UNALIGNED
		},
	digitalSignature	signedDatabyClient-encoding
	}
WITH PER-BASIC-UNALIGNED
}
networkAuthenticationModelTag-encoding #TAG ::= {
ENCODING-SPACE
	SIZE 1
		MULTIPLE OF octet
EXHIBITS HANDLE "NetworkAuthenticationModel" AT {0..7} AS tag:any
}
networkAuthenticationModelChoice-encoding #ALTERNATIVES ::= {
ALTERNATIVE
	DETERMINED BY handle
	HANDLE "NetworkAuthenticationModel"
}
null-value-encoding	#NULL ::= {ENCODE WITH PER-BASIC-UNALIGNED}
signedDatabyClient-encoding     #SignedDatabyClient ::= {
ENCODE STRUCTURE {
 	digital-signature       [signedDatabyClientTag-encoding]
                                signedData-encoding,
	aCBioOnClient           [signedDatabyClientTag-encoding]
                                signedDataACBio-encoding
  	STRUCTURED WITH signedDatabyClientChoice-encoding
                }
WITH PER-BASIC-UNALIGNED
}
signedDatabyClientTag-encoding  #TAG ::= {
ENCODING-SPACE
 	SIZE 1
		MULTIPLE OF octet
EXHIBITS HANDLE "SignedDatabyClient" AT {0..7} AS tag:any
}
signedDatabyClientChoice-encoding #ALTERNATIVES ::= {
ALTERNATIVE
	DETERMINED BY handle
	HANDLE "SignedDatabyClient"
	}
signedData-encoding #SignedData ::= {
ENCODE WITH Directory-encodings
}
signedDataACBio-encoding #SignedDataACBio ::= {
ENCODE WITH Directory-encodings
}
bDforLocalModel-encoding 	#BDforLocalModel ::= {
ENCODE STRUCTURE { 
	biometricClientProcess	biometricClientProcess-encoding
	}
WITH PER-BASIC-UNALIGNED
}
biometricClientProcess-encoding	#BiometricClientProcess ::= {
ENCODE STRUCTURE {
	bFPSchema	bSP-BFP-Schemas-encoding,
	templateID	templateID-encoding,
	sampleQuality	quality-encoding,
	score		USE-SET
	}
WITH PER-BASIC-UNALIGNED
}
bSP-BFP-Schemas-encoding	#SEQUENCE-OF ::= {
REPETITION-ENCODING {
	REPLACE STRUCTURE
		WITH #SequenceOfWithLength
		ENCODED BY bSP-BFP-SchemasWithLength-encoding
	}
}
bSP-BFP-SchemasWithLength-encoding{<#Element>} 
#SequenceOfWithLength{<#Element>} ::= {
ENCODE STRUCTURE {
	length	integer-4-encoding,
	value	bSP-BFP-SchemasValue-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
bSP-BFP-SchemasValue-encoding{<REFERENCE:length>} #BSP-BFP-Schemas ::= {
ENCODE STRUCTURE {
	bSP-BFP-Schema-encoding
	STRUCTURED WITH sequenceOfWithLength-encoding{<length>}
	}
WITH PER-BASIC-UNALIGNED
}
templateID-encoding #TemplateID ::= {
ENCODE STRUCTURE {
	certificateIssuer	name-encoding,
	serialNumber		certificateSerialNumber-encoding,
	templateInfo		templateInfo-encoding
	}
WITH PER-BASIC-UNALIGNED
}

name-encoding	#Name ::= {
ENCODE WITH Directory-encodings
}
certificateSerialNumber-encoding	#CertificateSerialNumber ::= 
integer-4-encoding
templateInfo-encoding	#TemplateInfo ::= {
ENCODE STRUCTURE {
	biometricType		USE-SET,
	creator			uTF8String-encoding,
	createdBFPSchema	bSP-BFP-Schema-encoding,
	templateID		certificateIDInformation-encoding
	}
WITH PER-BASIC-UNALIGNED
}
certificateIDInformation-encoding	#CertificateIDInformation ::=
certificateSerialNumber-encoding
bDforDownloadModel-encoding	#BDforDownloadModel ::= {
ENCODE STRUCTURE { 
	biometricClientProcess	biometricClientProcess-encoding
	}
WITH PER-BASIC-UNALIGNED
}
bDforAttachedModel-encoding            #BDforAttachedModel ::= {
ENCODE STRUCTURE {
	templateData		xtsmTemplate-encoding,
	sampleData		sampleData-encoding
	}
WITH PER-BASIC-UNALIGNED
}
sampleData	#SampleData	::= opaque-2-encoding
bDforCenterModel-encoding	#BDforCenterModel ::= {
ENCODE STRUCTURE {
	sampleData	sampleData-encoding
	}
WITH PER-BASIC-UNALIGNED
}
bDforRefOnTTPforLocalModel-encoding #BDforRefOnTTPforLocalModel ::= {
USE #BDforRefOnTTPforLocalModelWithFlag
	MAPPING FIELDS WITH {
	ENCODE STRUCTURE {
		thirdPartyInfo 		uTF8String-encoding,
		flag			boolean-encoding,
		biometric-ttp-process 	biometricTTPResponse-encoding
			OPTIONAL-ENCODING presence-encoding{<flag>},
		biometricClientProcess	biometricClientProcess-encoding
			STRUCTURED WITH structure-encoding
		}
	}
}	
#BDforRefOnTTPforLocalModelWithFlag	::= #CONCATENATION {
thirdPartyInfo		#UTF8String,
flag			#BOOLEAN,
biometric-ttp-process	#BiometricTTPResponse 
	OPTIONAL-ENCODING #Presence,
biometricClientProcess	#BiometricClientProcess
}
bDforRefOnTTPforCenterModel-encoding #BDforRefOnTTPforCenterModel ::= {
ENCODE STRUCTURE {
	thirdPartyInfo	uTF8String-encoding,
	sampleData	sampleData-encoding
	}
WITH PER-BASIC-UNALIGNED
}
bDforCObyClientModel-encoding	#BDforCObyClientModel ::= {
ENCODE STRUCTURE {
	bFPSchemaForClientProcess	bSP-BFP-Schemas-encoding,
	thirdPartyInfo			uTF8String-encoding,
	biometric-ttp-Process		biometricTTPResponse-encoding
	}
WITH PER-BASIC-UNALIGNED
}
bDforCObyServerModel-encoding	#BDforCObyServerModel ::= {
ENCODE STRUCTURE {
	sampleData	sampleData-encoding
	}
WITH PER-BASIC-UNALIGNED
}
bDforSCObyClientModel-encoding	#BDforSCObyClientModel ::= {
ENCODE STRUCTURE {
	bFPSchemaForClientProcess	bSP-BFP-Schemas-encoding,
	thirdPartyInfo			uTF8String-encoding,
	biometric-ttp-Process		biometricTTPResponse-encoding
	}
WITH PER-BASIC-UNALIGNED
}
bDforSCObyServerModel-encoding	#BDforSCObyServerModel ::= {
ENCODE STRUCTURE {
	sampleData	sampleData-encoding
	}
WITH PER-BASIC-UNALIGNED
}
BiometricRetryRequest-encodings	#ENCODINGS ::= {
biometricRetryRequest-encoding
}
biometricRetryRequest-encoding	#BiometricRetryRequest ::= {
ENCODE STRUCTURE {
	retryRequest	biometricAuthenticationRequest-encoding
	}
WITH PER-BASIC-UNALIGNED
}
BiometricFinished-encodings	#ENCODINGS ::= {
biometricFinished-encoding
}
biometricFinished-encoding	#BiometricFinished ::= {
ENCODE STRUCTURE {
	result	biometricAuthenticationResult-encoding
	}
WITH PER-BASIC-UNALIGNED
}
biometricAuthenticationResult-encoding	#BiometricAuthenticationResult ::=
boolean-encoding
BiometricTTPRequest-encodings	#ENCODINGS ::= {
biometricTTPRequest-encoding
}
biometricTTPRequest-encoding #BiometricTTPRequest ::= {
ENCODE STRUCTURE {
	storage-type
		[biometricTTPOutsourcingTypeTag-encoding]
			bDforStorageOutsourcing-encoding,
	comparison-type
		[biometricTTPOutsourcingTypeTag-encoding]
			bDforComparisonOutsourcing-encoding,
	storage-comparison-type
		[biometricTTPOutsourcingTypeTag-encoding]
			bDforComparisonOutsourcing-encoding
	STRUCTURED WITH
		biometricTTPOutsourcingTypeChoice-encoding
	}
WITH PER-BASIC-UNALIGNED
}	
biometricTTPOutsourcingTypeTag-encoding	#TAG ::= {
ENCODING-SPACE
	SIZE 1
		MULTIPLE OF octet
	EXHIBITS HANDLE "BiometricTTPOutsourcingType" AT {0..7}
		AS tag:any
}
biometricTTPOutsourcingTypeChoice-encoding	#ALTERNATIVES ::= {
ALTERNATIVE 
	DETERMINED BY handle
	HANDLE  "BiometricTTPOutsourcingType"
}
bDforStorageOutsourcing-encoding 	#BDforStorageOutsourcing ::= {
ENCODE STRUCTURE {
	templateID	templateID-encoding
	}
WITH PER-BASIC-UNALIGNED
}
bDforComparisonOutsourcing-encoding	#BDforComparisonOutsourcing ::= {
ENCODE STRUCTURE {
	templateData	xtsmTemplate-encoding,
	sampleData	sampleData-encoding
	}
WITH PER-BASIC-UNALIGNED
}
BiometricTTPResponse-encodings	#ENCODINGS ::= {
biometricTTPResponse-encoding
}
biometricTTPResponse-encoding		#BiometricTTPResponse ::= {
ENCODE STRUCTURE {
	request-body	{
		ENCODE STRUCTURE {
			storage-type
			[biometricTTPOutsourcingTypeTag-encoding]
				rBDforStorageOutsourcing-encoding,
			comparison-type
			[biometricTTPOutsourcingTypeTag-encoding]
				rBDforComparisonOutsourcing-encoding,
			storage-comparison-type
			[biometricTTPOutsourcingTypeTag-encoding]
				rBDforComparisonOutsourcing-encoding
			STRUCTURED WITH
			biometricTTPOutsourcingTypeChoice-encoding
			}
		WITH PER-BASIC-UNALIGNED
		},
	digital-signature	signedDatabyTTP-encoding
	}
WITH PER-BASIC-UNALIGNED
}
signedDatabyTTP-encoding     #SignedDatabyTTP ::= {
ENCODE STRUCTURE {
	digital-signature		[signedDatabyTTPTag-encoding]
			signedData-encoding,
	aCBioOnTTP          	[signedDatabyTTPTag-encoding]
    			signedDataACBio-encoding
     	STRUCTURED WITH signedDatabyTTPChoice-encoding
     	}
WITH PER-BASIC-UNALIGNED
}
signedDatabyTTPTag-encoding  #TAG ::= {
ENCODING-SPACE
	SIZE 1
      	MULTIPLE OF octet
	EXHIBITS HANDLE "SignedDatabyTTP" AT {0..7} AS tag:any
}
signedDatabyTTPChoice-encoding #ALTERNATIVES ::= {
ALTERNATIVE
	DETERMINED BY handle
	HANDLE "SignedDatabyTTP"
}
rBDforStorageOutsourcing-encoding	#RBDforStorageOutsourcing ::= {
ENCODE STRUCTURE {
	templateData	xtsmTemplate-encoding
	}
WITH PER-BASIC-UNALIGNED
}
rBDforComparisonOutsourcing-encoding	#RBDforComparisonOutsourcing ::= {
ENCODE STRUCTURE {
	bFPSchema	bSP-BFP-Schemas-encoding,
	templateID	templateID-encoding,
	sampleQuality	quality-encoding,
	score		USE-SET
	}
WITH PER-BASIC-UNALIGNED
}
applicationData-encoding	#ApplicationData ::= {
REPETITION-ENCODING {
	REPETITION-SPACE
		SIZE variable-with-determinant
		DETERMINED BY container
		USING OUTER
	}
}
END