Z39-50-APDU-1995
-- OID for this definition, assigned in OID.3.1, is {Z39-50 2 1}
DEFINITIONS ::=
BEGIN -- Z39.50-1995 Maintenance Agency Official Text for ANSI/NISO Z39.50-1995 - July 1995
--
EXPORTS OtherInformation, Term, AttributeSetId, AttributeList,
AttributeElement, ElementSetName, SortElement, DatabaseName, CompSpec,
Specification, Permissions, InternationalString, IntUnit, Unit,
StringOrNumeric, Query, Records, ResultSetId, DefaultDiagFormat, DiagRec;
--
PDU ::= CHOICE{
initRequest [20] IMPLICIT InitializeRequest,
initResponse [21] IMPLICIT InitializeResponse,
searchRequest [22] IMPLICIT SearchRequest,
searchResponse [23] IMPLICIT SearchResponse,
presentRequest [24] IMPLICIT PresentRequest,
presentResponse [25] IMPLICIT PresentResponse,
deleteResultSetRequest [26] IMPLICIT DeleteResultSetRequest,
deleteResultSetResponse [27] IMPLICIT DeleteResultSetResponse,
accessControlRequest [28] IMPLICIT AccessControlRequest,
accessControlResponse [29] IMPLICIT AccessControlResponse,
resourceControlRequest [30] IMPLICIT ResourceControlRequest,
resourceControlResponse [31] IMPLICIT ResourceControlResponse,
triggerResourceControlRequest [32] IMPLICIT TriggerResourceControlRequest,
resourceReportRequest [33] IMPLICIT ResourceReportRequest,
resourceReportResponse [34] IMPLICIT ResourceReportResponse,
scanRequest [35] IMPLICIT ScanRequest,
scanResponse [36] IMPLICIT ScanResponse,
-- [37] through [42] reserved
sortRequest [43] IMPLICIT SortRequest,
sortResponse [44] IMPLICIT SortResponse,
segmentRequest [45] IMPLICIT Segment,
extendedServicesRequest [46] IMPLICIT ExtendedServicesRequest,
extendedServicesResponse [47] IMPLICIT ExtendedServicesResponse,
close [48] IMPLICIT Close}
-- Initialize APDUs
--
InitializeRequest ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
protocolVersion ProtocolVersion,
options Options,
preferredMessageSize [5] IMPLICIT INTEGER,
exceptionalRecordSize [6] IMPLICIT INTEGER,
idAuthentication [7] ANY OPTIONAL, -- see note below
implementationId [110] IMPLICIT InternationalString OPTIONAL,
implementationName [111] IMPLICIT InternationalString OPTIONAL,
implementationVersion [112] IMPLICIT InternationalString OPTIONAL,
userInformationField [11] EXTERNAL OPTIONAL,
otherInfo OtherInformation OPTIONAL}
--Note:
-- For idAuthentication, the type ANY is retained
-- for compatibility with earlier versions.
-- For interoperability, the following is recommended:
-- IdAuthentication [7] CHOICE{
-- open VisibleString,
-- idPass SEQUENCE {
-- groupId [0] IMPLICIT InternationalString OPTIONAL,
-- userId [1] IMPLICIT InternationalString OPTIONAL,
-- password [2] IMPLICIT InternationalString OPTIONAL },
-- anonymous NULL,
-- other EXTERNAL
-- May use access control formats for 'other'. See Appendix 7 ACC.
--
InitializeResponse ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
protocolVersion ProtocolVersion,
options Options,
preferredMessageSize [5] IMPLICIT INTEGER,
exceptionalRecordSize [6] IMPLICIT INTEGER,
result [12] IMPLICIT BOOLEAN,
-- relect = FALSE; Accept = TRUE
implementationId [110] IMPLICIT InternationalString OPTIONAL,
implementationName [111] IMPLICIT InternationalString OPTIONAL,
implementationVersion [112] IMPLICIT InternationalString OPTIONAL,
userInformationField [11] EXTERNAL OPTIONAL,
otherInfo OtherInformation OPTIONAL}
-- Begin auxiliary definitions for Init PDUs
ProtocolVersion ::= [3] IMPLICIT BIT STRING{
version-1 (0),
-- This bit should always be set, but does not
-- correspond to any Z39.50 version.
version-2 (1),
-- "Version 2 supported."
-- This bit should always be set.
version-3 (2)
-- "Version 3 supported."
-- Values higher than 'version-3' should be ignored. Both the Initialize
-- request and Initialize Response APDUs include a value string corresponding
-- to the supported versions. The highest common version is selected
-- for use. If there are no versions in common, "Result" in the Init Response
-- should indicate "reject."
-- Note: Versions 1 and 2 are identical. Systems supporting version 2 should
-- indicate support for version 1 as well, for interoperability with systems
-- that indicate support for version 1 only (e.g. ISO 10163-1991
-- implementations).
}
Options ::= [4] IMPLICIT BIT STRING{
search (0),
present (1),
delSet (2),
resourceReport (3),
triggerResourceCtrl (4),
resourceCtrl (5),
accessCtrl (6),
scan (7),
sort (8),
-- (9) (reserved)
extendedServices (10),
level-1Segmentation (11),
level-2Segmentation (12),
concurrentOperations (13),
namedResultSets (14)}
-- end auxiliary definitions for Init PDUs
--Search APDUs
SearchRequest ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
smallSetUpperBound [13] IMPLICIT INTEGER,
largeSetLowerBound [14] IMPLICIT INTEGER,
mediumSetPresentNumber [15] IMPLICIT INTEGER,
replaceIndicator [16] IMPLICIT BOOLEAN,
resultSetName [17] IMPLICIT InternationalString,
databaseNames [18] IMPLICIT SEQUENCE OF DatabaseName,
smallSetElementSetNames [100] ElementSetNames OPTIONAL,
mediumSetElementSetNames [101] ElementSetNames OPTIONAL,
preferredRecordSyntax [104] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
query [21] Query,
-- Following two parameters may be used only if version 3 is in force.
additionalSearchInfo [203] IMPLICIT OtherInformation OPTIONAL,
otherInfo OtherInformation OPTIONAL}
-- Query Definitions
Query ::= CHOICE{
type-0 [0] ANY,
type-1 [1] IMPLICIT RPNQuery,
type-2 [2] OCTET STRING,
type-100 [100] OCTET STRING,
type-101 [101] IMPLICIT RPNQuery,
type-102 [102] OCTET STRING}
--
-- Definitions for RPN query
RPNQuery ::= SEQUENCE{
attributeSet AttributeSetId,
rpn RPNStructure}
--
RPNStructure ::= CHOICE{
op [0] Operand,
rpnRpnOp [1] IMPLICIT SEQUENCE{
rpn1 RPNStructure,
rpn2 RPNStructure,
op Operator }}
Operand ::= CHOICE{
attrTerm AttributesPlusTerm,
resultSet ResultSetId,
-- If version 2 is in force:
-- - If query type is 1, one of the above two must be chosen;
-- - resultAttr (below) may be used only if query type is 101.
resultAttr ResultSetPlusAttributes}
AttributesPlusTerm ::= [102] IMPLICIT SEQUENCE{
attributes AttributeList,
term Term}
ResultSetPlusAttributes ::= [214] IMPLICIT SEQUENCE{
resultSet ResultSetId,
attributes AttributeList}
AttributeList ::= [44] IMPLICIT SEQUENCE OF AttributeElement
--
Term ::= CHOICE{
general [45] IMPLICIT OCTET STRING,
-- values below may be used only if version 3 is in force
numeric [215] IMPLICIT INTEGER,
characterString [216] IMPLICIT InternationalString,
oid [217] IMPLICIT OBJECT IDENTIFIER,
dateTime [218] IMPLICIT GeneralizedTime,
external [219] IMPLICIT EXTERNAL,
integerAndUnit [220] IMPLICIT IntUnit,
null [221] IMPLICIT NULL}
Operator ::= [46] CHOICE{
and [0] IMPLICIT NULL,
or [1] IMPLICIT NULL,
and-not [2] IMPLICIT NULL,
-- If version 2 is in force:
-- - For query type 1, one of the above three
-- must be chosen;
-- - prox (below) may be used only if query type
-- is 101.
prox [3] IMPLICIT ProximityOperator}
AttributeElement ::= SEQUENCE{
attributeSet [1] IMPLICIT AttributeSetId OPTIONAL,
-- Must be omitted if version 2 is in force.
-- If included, overrides value of attributeSet
-- in RPNQuery above, but only for this attribute.
attributeType [120] IMPLICIT INTEGER,
attributeValue CHOICE{
numeric [121] IMPLICIT INTEGER,
-- If version 2 is in force,
-- Must select 'numeric' for attributeValue.
complex [224] IMPLICIT SEQUENCE{
list [1] IMPLICIT SEQUENCE OF StringOrNumeric,
semanticAction [2] IMPLICIT SEQUENCE OF INTEGER OPTIONAL}}}
ProximityOperator ::= SEQUENCE{
exclusion [1] IMPLICIT BOOLEAN OPTIONAL,
distance [2] IMPLICIT INTEGER,
ordered [3] IMPLICIT BOOLEAN,
relationType [4] IMPLICIT INTEGER{
lessThan (1),
lessThanOrEqual (2),
equal (3),
greaterThanOrEqual (4),
greaterThan (5),
notEqual (6)},
proximityUnitCode [5] CHOICE{
known [1] IMPLICIT KnownProximityUnit,
private [2] IMPLICIT INTEGER}}
--
KnownProximityUnit ::= INTEGER{
character (1),
word (2),
sentence (3),
paragraph (4),
section (5),
chapter (6),
document (7),
element (8),
subelement (9),
elementType (10),
byte (11) -- Version 3 only
}
-- End definitions for RPN Query
SearchResponse ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
resultCount [23] IMPLICIT INTEGER,
numberOfRecordsReturned [24] IMPLICIT INTEGER,
nextResultSetPosition [25] IMPLICIT INTEGER,
searchStatus [22] IMPLICIT BOOLEAN,
resultSetStatus [26] IMPLICIT INTEGER{
subset (1),
interim (2),
none (3)} OPTIONAL,
presentStatus PresentStatus OPTIONAL,
records Records OPTIONAL,
-- Following two parameters may be used only if version 3 is in force.
additionalSearchInfo [203] IMPLICIT OtherInformation OPTIONAL,
otherInfo OtherInformation OPTIONAL}
--Retrieval APDUs
PresentRequest ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
resultSetId ResultSetId,
resultSetStartPoint [30] IMPLICIT INTEGER,
numberOfRecordsRequested [29] IMPLICIT INTEGER,
additionalRanges [212] IMPLICIT SEQUENCE OF Range OPTIONAL,
-- additionalRanges may be included only if version 3 is in force.
recordComposition CHOICE{
simple [19] ElementSetNames,
-- must choose 'simple' if version 2
-- is in force
complex [209] IMPLICIT CompSpec} OPTIONAL,
preferredRecordSyntax [104] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
maxSegmentCount [204] IMPLICIT INTEGER OPTIONAL, -- level 1 or 2
maxRecordSize [206] IMPLICIT INTEGER OPTIONAL, -- level 2 only
maxSegmentSize [207] IMPLICIT INTEGER OPTIONAL, -- level 2 only
otherInfo OtherInformation OPTIONAL}
--
Segment ::= SEQUENCE{
-- Segment PDU may only be used when version 3 is in force,
-- and only when segmentation is in effect.
referenceId ReferenceId OPTIONAL,
numberOfRecordsReturned [24] IMPLICIT INTEGER,
segmentRecords [0] IMPLICIT SEQUENCE OF NamePlusRecord,
otherInfo OtherInformation OPTIONAL}
--
PresentResponse ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
numberOfRecordsReturned [24] IMPLICIT INTEGER,
nextResultSetPosition [25] IMPLICIT INTEGER,
presentStatus PresentStatus,
records Records OPTIONAL,
otherInfo OtherInformation OPTIONAL}
-- begin auxiliary definitions for Search and Present APDUs
-- begin definition of records
Records ::= CHOICE{
responseRecords [28] IMPLICIT SEQUENCE OF NamePlusRecord,
nonSurrogateDiagnostic [130] IMPLICIT DefaultDiagFormat,
multipleNonSurDiagnostics [205] IMPLICIT SEQUENCE OF DiagRec}
--
NamePlusRecord ::= SEQUENCE{
name [0] IMPLICIT DatabaseName OPTIONAL,
record [1] CHOICE{
retrievalRecord [1] EXTERNAL,
surrogateDiagnostic [2] DiagRec,
-- Must select one of the above two, retrievalRecord or
-- surrogateDiagnostic, unless 'level 2 segmentation'
-- is in effect.
startingFragment [3] FragmentSyntax,
intermediateFragment [4] FragmentSyntax,
finalFragment [5] FragmentSyntax}}
FragmentSyntax ::= CHOICE{
externallyTagged EXTERNAL,
notExternallyTagged OCTET STRING}
DiagRec ::= CHOICE{
defaultFormat DefaultDiagFormat,
-- Must choose defaultFormat if version 2 is in effect.
externallyDefined EXTERNAL}
DefaultDiagFormat::= SEQUENCE{
diagnosticSetId OBJECT IDENTIFIER,
condition INTEGER,
addinfo CHOICE{
v2Addinfo VisibleString, -- version 2
v3Addinfo InternationalString -- version 3
}}
-- end definition of records
Range ::= SEQUENCE{
startingPosition [1] IMPLICIT INTEGER,
numberOfRecords [2] IMPLICIT INTEGER}
--
ElementSetNames ::= CHOICE {
genericElementSetName [0] IMPLICIT InternationalString,
databaseSpecific [1] IMPLICIT SEQUENCE OF SEQUENCE{
dbName DatabaseName,
esn ElementSetName}}
PresentStatus ::= [27] IMPLICIT INTEGER{
success (0),
partial-1 (1),
partial-2 (2),
partial-3 (3),
partial-4 (4),
failure (5)}
-- begin definition of composition specification
CompSpec ::= SEQUENCE{
selectAlternativeSyntax [1] IMPLICIT BOOLEAN,
-- See comment for recordSyntax, below.
generic [2] IMPLICIT Specification OPTIONAL,
dbSpecific [3] IMPLICIT SEQUENCE OF SEQUENCE{
db [1] DatabaseName,
spec [2] IMPLICIT Specification} OPTIONAL,
-- At least one of generic and dbSpecific must
-- occur, and both may occur. If both, then for
-- any record not in the list of databases
-- within dbSpecific, generic applies.
recordSyntax [4] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER
OPTIONAL
-- For each record, the target selects the
-- first record syntax in this list that it can
-- support. If the list is exhausted, the
-- target may select an alternative syntax if
-- selectAlternativeSyntax is 'true'.
}
Specification ::= SEQUENCE{
schema [1] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
elementSpec [2] CHOICE{
elementSetName [1] IMPLICIT InternationalString,
externalEspec [2] IMPLICIT EXTERNAL} OPTIONAL}
-- end definition of composition specification
-- end auxiliary definitions for search and response APDUs
-- Delete APDUs
DeleteResultSetRequest ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
deleteFunction [32] IMPLICIT INTEGER{
list (0),
all (1)},
resultSetList SEQUENCE OF ResultSetId OPTIONAL,
otherInfo OtherInformation OPTIONAL}
--
DeleteResultSetResponse ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
deleteOperationStatus [0] IMPLICIT DeleteSetStatus,
deleteListStatuses [1] IMPLICIT ListStatuses OPTIONAL,
numberNotDeleted [34] IMPLICIT INTEGER OPTIONAL,
bulkStatuses [35] IMPLICIT ListStatuses OPTIONAL,
deleteMessage [36] IMPLICIT InternationalString OPTIONAL,
otherInfo OtherInformation OPTIONAL}
ListStatuses ::= SEQUENCE OF SEQUENCE{
id ResultSetId,
status DeleteSetStatus}
DeleteSetStatus ::= [33] IMPLICIT INTEGER{
success (0),
resultSetDidNotExist (1),
previouslyDeletedByTarget (2),
systemProblemAtTarget (3),
accessNotAllowed (4),
resourceControlAtOrigin (5),
resourceControlAtTarget (6),
bulkDeleteNotSupported (7),
notAllRsltSetsDeletedOnBulkDlte (8),
notAllRequestedResultSetsDeleted (9),
resultSetInUse (10)}
--
--Access- and Resource-control APDUs
--
AccessControlRequest ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
securityChallenge CHOICE{
simpleForm [37] IMPLICIT OCTET STRING,
externallyDefined [0] EXTERNAL},
otherInfo OtherInformation OPTIONAL}
AccessControlResponse ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
securityChallengeResponse CHOICE{
simpleForm [38] IMPLICIT
OCTET STRING,
externallyDefined [0] EXTERNAL}
OPTIONAL,
-- Optional only in version 3; mandatory in
-- version 2. If omitted (in version 3) then
-- diagnostic must occur.
diagnostic [223] DiagRec OPTIONAL, -- Version 3 only.
otherInfo OtherInformation OPTIONAL}
ResourceControlRequest ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
suspendedFlag [39] IMPLICIT BOOLEAN OPTIONAL,
resourceReport [40] ResourceReport OPTIONAL,
partialResultsAvailable [41] IMPLICIT INTEGER{
subset (1),
interim (2),
none (3)} OPTIONAL,
responseRequired [42] IMPLICIT BOOLEAN,
triggeredRequestFlag [43] IMPLICIT BOOLEAN OPTIONAL,
otherInfo OtherInformation OPTIONAL}
ResourceControlResponse ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
continueFlag [44] IMPLICIT BOOLEAN,
resultSetWanted [45] IMPLICIT BOOLEAN OPTIONAL,
otherInfo OtherInformation OPTIONAL}
TriggerResourceControlRequest ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
requestedAction [46] IMPLICIT INTEGER{
resourceReport (1),
resourceControl (2),
cancel (3)},
prefResourceReportFormat [47] IMPLICIT ResourceReportId OPTIONAL,
resultSetWanted [48] IMPLICIT BOOLEAN OPTIONAL,
otherInfo OtherInformation OPTIONAL}
ResourceReportRequest ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
opId [210] IMPLICIT ReferenceId OPTIONAL,
prefResourceReportFormat [49] IMPLICIT ResourceReportId OPTIONAL,
otherInfo OtherInformation OPTIONAL}
--
ResourceReportResponse ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
resourceReportStatus [50] IMPLICIT INTEGER{
success (0),
partial (1),
failure-1 (2),
failure-2 (3),
failure-3 (4),
failure-4 (5),
failure-5 (6),
failure-6 (7)},
resourceReport [51] ResourceReport OPTIONAL,
otherInfo OtherInformation OPTIONAL}
--
ResourceReport ::= EXTERNAL
ResourceReportId ::= OBJECT IDENTIFIER
--Scan APDUs
ScanRequest ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
databaseNames [3] IMPLICIT SEQUENCE OF DatabaseName,
attributeSet AttributeSetId OPTIONAL,
termListAndStartPoint AttributesPlusTerm,
stepSize [5] IMPLICIT INTEGER OPTIONAL,
numberOfTermsRequested [6] IMPLICIT INTEGER,
preferredPositionInResponse [7] IMPLICIT INTEGER OPTIONAL,
otherInfo OtherInformation OPTIONAL}
ScanResponse ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
stepSize [3] IMPLICIT INTEGER OPTIONAL,
scanStatus [4] IMPLICIT INTEGER {
success (0),
partial-1 (1),
partial-2 (2),
partial-3 (3),
partial-4 (4),
partial-5 (5),
failure (6) },
numberOfEntriesReturned [5] IMPLICIT INTEGER,
positionOfTerm [6] IMPLICIT INTEGER OPTIONAL,
entries [7] IMPLICIT ListEntries OPTIONAL,
attributeSet [8] IMPLICIT AttributeSetId OPTIONAL,
otherInfo OtherInformation OPTIONAL}
-- begin auxiliary definitions for Scan
ListEntries ::= SEQUENCE{
entries [1] IMPLICIT SEQUENCE OF Entry OPTIONAL,
nonsurrogateDiagnostics [2] IMPLICIT SEQUENCE OF DiagRec OPTIONAL
-- At least one of entries and nonsurrogateDiagnostic must occur
}
Entry ::= CHOICE {
termInfo [1] IMPLICIT TermInfo,
surrogateDiagnostic [2] DiagRec}
--
TermInfo ::= SEQUENCE {
term Term,
displayTerm [0] IMPLICIT InternationalString OPTIONAL,
-- Presence of displayTerm means that term is
-- not considered by the target to be suitable
-- for display, and displayTerm should instead
-- be displayed. 'term' is the actual term in
-- the term list; 'displayTerm' is for display
-- purposes only, and is not an actual term in
-- the term list.
suggestedAttributes AttributeList OPTIONAL,
alternativeTerm [4] IMPLICIT SEQUENCE OF AttributesPlusTerm
OPTIONAL,
globalOccurrences [2] IMPLICIT INTEGER OPTIONAL,
byAttributes [3] IMPLICIT OccurrenceByAttributes OPTIONAL,
otherTermInfo OtherInformation OPTIONAL}
OccurrenceByAttributes ::= SEQUENCE OF SEQUENCE{
attributes [1] AttributeList,
occurrences CHOICE{
global [2] INTEGER,
byDatabase [3] IMPLICIT SEQUENCE OF
SEQUENCE{
db DatabaseName,
num [1] IMPLICIT
INTEGER OPTIONAL,
otherDbInfo OtherInformation OPTIONAL}}
OPTIONAL,
otherOccurInfo OtherInformation OPTIONAL}
-- end auxiliary definitions for Scan
-- Sort APDUs
SortRequest ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
inputResultSetNames [3] IMPLICIT SEQUENCE OF InternationalString,
sortedResultSetName [4] IMPLICIT InternationalString,
sortSequence [5] IMPLICIT SEQUENCE OF SortKeySpec,
-- order of occurrence is
-- from major to minor
otherInfo OtherInformation OPTIONAL}
SortResponse ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
sortStatus [3] IMPLICIT INTEGER{
success (0),
partial-1 (1),
failure (2)},
resultSetStatus [4] IMPLICIT INTEGER{
empty (1),
interim (2),
unchanged (3),
none (4)} OPTIONAL,
diagnostics [5] IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
otherInfo OtherInformation OPTIONAL}
-- begin auxiliary definitions for Sort
SortKeySpec ::= SEQUENCE{
sortElement SortElement,
sortRelation [1] IMPLICIT INTEGER{
ascending (0),
descending (1),
ascendingByFrequency (3),
descendingByfrequency (4)},
caseSensitivity [2] IMPLICIT INTEGER{
caseSensitive (0),
caseInsensitive (1)},
missingValueAction [3] CHOICE{
abort [1] IMPLICIT NULL,
null [2] IMPLICIT NULL,
-- supply a null value
-- for missing value
missingValueData [3] IMPLICIT OCTET
STRING} OPTIONAL}
SortElement ::= CHOICE{
generic [1] SortKey,
datbaseSpecific [2] IMPLICIT SEQUENCE OF SEQUENCE{
databaseName DatabaseName,
dbSort SortKey}}
SortKey ::= CHOICE{
sortfield [0] IMPLICIT InternationalString,
-- An element, element-group-tag, or alias
-- supported by the target and denoting a set
-- of elements associated with each record.
elementSpec [1] IMPLICIT Specification,
sortAttributes [2] IMPLICIT SEQUENCE{
id AttributeSetId,
list AttributeList}}
-- end auxiliary definitions for sort
-- Extended Service APDUs
ExtendedServicesRequest ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
function [3] IMPLICIT INTEGER {
create (1),
delete (2),
modify (3)},
packageType [4] IMPLICIT OBJECT IDENTIFIER,
packageName [5] IMPLICIT InternationalString OPTIONAL,
-- PackageName mandatory for 'modify' or
-- 'delete'; optional for 'create'.
-- Following four parameters mandatory
-- for 'create'; should be included on
-- 'modify' if being modified; not needed
-- on 'delete'.
userId [6] IMPLICIT InternationalString OPTIONAL,
retentionTime [7] IMPLICIT IntUnit OPTIONAL,
permissions [8] IMPLICIT Permissions OPTIONAL,
description [9] IMPLICIT InternationalString OPTIONAL,
taskSpecificParameters [10] IMPLICIT EXTERNAL OPTIONAL,
-- Mandatory for 'create'; included on
-- 'modify' if specific parameters being
-- modified; not necessary on 'delete'.
-- For the 'EXTERNAL,' use OID of
-- specific ES definition and select
-- CHOICE [1]: 'esRequest'.
waitAction [11] IMPLICIT INTEGER{
wait (1),
waitIfPossible (2),
dontWait (3),
dontReturnPackage (4)},
elements ElementSetName OPTIONAL,
otherInfo OtherInformation OPTIONAL}
--
ExtendedServicesResponse ::= SEQUENCE{
referenceId ReferenceId OPTIONAL,
operationStatus [3] IMPLICIT INTEGER{
done (1),
accepted (2),
failure (3)},
diagnostics [4] IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
taskPackage [5] IMPLICIT EXTERNAL OPTIONAL,
-- Use OID: {Z39-50-recordSyntax (106)}
-- and corresponding syntax. For the
-- EXTERNAL, 'taskSpecific,' within that
-- definition, use OID of the specific
-- es, and choose [2], 'taskPackage'.
otherInfo OtherInformation OPTIONAL}
Permissions ::= SEQUENCE OF SEQUENCE{
userId [1] IMPLICIT InternationalString,
allowableFunctions [2] IMPLICIT SEQUENCE OF INTEGER{
delete (1),
modifyContents (2),
modifyPermissions (3),
present (4),
invoke (5)}}
Close ::= SEQUENCE{
referenceId ReferenceId OPTIONAL, -- See 3.2.11.1.5.
closeReason CloseReason,
diagnosticInformation [3] IMPLICIT InternationalString OPTIONAL,
resourceReportFormat [4] IMPLICIT ResourceReportId OPTIONAL,
-- For use by origin only, and only on
-- Close request; origin requests target
-- to include report in response.
resourceReport [5] ResourceReport OPTIONAL,
-- For use by target only, unilaterally
-- on Close request; on Close response
-- may be unilateral or in response to
-- origin request.
otherInfo OtherInformation OPTIONAL}
CloseReason ::= [211] IMPLICIT INTEGER{
finished (0),
shutdown (1),
systemProblem (2),
costLimit (3),
resources (4),
securityViolation (5),
protocolError (6),
lackOfActivity (7),
peerAbort (8),
unspecified (9)}
-- Global auxiliary definitions
ReferenceId ::= [2] IMPLICIT OCTET STRING
ResultSetId ::= [31] IMPLICIT InternationalString
ElementSetName ::= [103] IMPLICIT InternationalString
DatabaseName ::= [105] IMPLICIT InternationalString
AttributeSetId ::= OBJECT IDENTIFIER
-- OtherInformation
OtherInformation ::= [201] IMPLICIT SEQUENCE OF SEQUENCE{
category [1] IMPLICIT InfoCategory OPTIONAL,
information CHOICE{
characterInfo [2] IMPLICIT InternationalString,
binaryInfo [3] IMPLICIT OCTET STRING,
externallyDefinedInfo [4] IMPLICIT EXTERNAL,
oid [5] IMPLICIT OBJECT IDENTIFIER}}
--
InfoCategory ::= SEQUENCE{
categoryTypeId [1] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
categoryValue [2] IMPLICIT INTEGER}
-- Units
-- IntUnit is used when value and unit are supplied together. Unit, alone,
-- is used when just specifying a unit (without a value). For example,
-- IntUnit is used in Term, in an RPNQuery, or it can be the datatype of
-- an element within a retrieval record. Unit (alone) would be used in an
-- element request, when requesting data be returned according to a
-- particular unit.
IntUnit ::= SEQUENCE{
value [1] IMPLICIT INTEGER,
unitUsed [2] IMPLICIT Unit}
--
Unit ::= SEQUENCE{
unitSystem [1] InternationalString OPTIONAL, -- e.g. 'SI'
unitType [2] StringOrNumeric OPTIONAL, -- e.g. 'mass'
unit [3] StringOrNumeric OPTIONAL, -- e.g. 'kilograms'
scaleFactor [4] IMPLICIT INTEGER OPTIONAL -- e.g. 9 means 10**9
}
--CharacterString
InternationalString ::= GeneralString
-- When version 2 is in force, this collapses to VisibleString. That
-- is, only characters in the visibleString repertoire may be used.
-- (Datatype compatibility with version 2 is not affected, because
-- references are IMPLICIT.) When version 3 is in force, the semantics
-- of the GeneralString content may be altered by negotiation during
-- initialization. If no such negotiation is in effect, then
-- GeneralString semantics are in force.
StringOrNumeric ::= CHOICE{
string [1] IMPLICIT InternationalString,
numeric [2] IMPLICIT INTEGER}
END --IR DEFINITIONS
DiagnosticFormatDiag1
{Z39-50-diagnosticFormat diag-1 (2)} DEFINITIONS ::=
BEGIN
IMPORTS Term, Specification, AttributeList, SortElement,
DatabaseName,
DefaultDiagFormat, InternationalString FROM Z39-50-APDU-1995;
DiagnosticFormat ::= SEQUENCE OF SEQUENCE{
diagnostic [1] CHOICE{
defaultDiagRec [1] IMPLICIT DefaultDiagFormat,
explicitDiagnostic [2] DiagFormat} OPTIONAL,
message [2] IMPLICIT InternationalString OPTIONAL}
DiagFormat ::= CHOICE{
tooMany [1000] IMPLICIT SEQUENCE{
tooManyWhat [1] IMPLICIT INTEGER{
argumentWords (1),
truncatedWords (2),
booleanOperators (3),
incompleteSubfields (4),
characters (5),
recordsRetrieved (6),
dataBasesSpecified (7),
resultSetsCreated (8),
indexTermsProcessed (9)},
max [2] IMPLICIT INTEGER OPTIONAL},
badSpec [1001] IMPLICIT SEQUENCE{
-- element set name or specification
spec [1] IMPLICIT Specification,
-- esn or element spec not supported
db [2] IMPLICIT DatabaseName OPTIONAL,
-- if db specified, above spec not
-- supported for db; otherwise,
-- spec not supported period.
goodOnes [3] IMPLICIT SEQUENCE OF Specification
OPTIONAL
-- target supplies ones that are
-- supported
},
dbUnavail [1002] IMPLICIT SEQUENCE{ -- database unavailable
db [1] IMPLICIT DatabaseName,
why [2] IMPLICIT SEQUENCE{
reasonCode [1] IMPLICIT INTEGER{
doesNotExist (0),
existsButUnavail (1),
locked (2),
accessDenied (3)}
OPTIONAL,
message [2] IMPLICIT
InternationalString OPTIONAL}},
unSupOp [1003] IMPLICIT INTEGER{ -- unsupported operator
and (0),
or (1),
and-not (2),
prox (3)},
attribute [1004] IMPLICIT SEQUENCE{
-- Applies for unsupported attribute set,
-- attribute type, attribute value, or term (for
-- a given attribute type or value).
id [1] IMPLICIT OBJECT IDENTIFIER,
-- if only "id" occurs, then
-- attribute set is not supported
type [2] IMPLICIT INTEGER OPTIONAL,
-- must occur if value occurs.
value [3] IMPLICIT INTEGER OPTIONAL,
-- if omitted, and Type occurs,
-- then Type is what is unsupported
term [4] Term OPTIONAL
-- If occurs, term is illegal or
-- not supported, for attribute
-- value, if value occurs;
-- otherwise, for type.
},
attCombo [1005] IMPLICIT SEQUENCE{
-- attribute combination not supported
unsupportedCombination [1] IMPLICIT AttributeList,
recommendedAlternatives [2] IMPLICIT SEQUENCE OF
AttributeList OPTIONAL},
term [1006] IMPLICIT SEQUENCE{
problem [1] IMPLICIT INTEGER{
codedValue (1),
unparsable (2),
tooShort (3),
type (4)} OPTIONAL,
term [2] Term},
proximity [1007] CHOICE{ -- proximity diagnostics:
resultSets [1] IMPLICIT NULL,
-- proximity between sets not
-- supported
badSet [2] IMPLICIT InternationalString,
-- bad result set specified
relation [3] IMPLICIT INTEGER,
-- 1 to 6 ; relation not supported
unit [4] IMPLICIT INTEGER,
-- unsupported unit code
distance [5] IMPLICIT INTEGER,
-- unsupported distance
attributes [6] AttributeList,
-- proximity not supported with
-- specified attribute combination
ordered [7] IMPLICIT NULL,
-- ordered flag not supported
exclusion [8] IMPLICIT NULL
-- exclusion flag not supported
},
scan [1008] CHOICE{ -- scan diagnostics:
nonZeroStepSize [0] IMPLICIT NULL,
-- only zero step size
-- supported
specifiedStepSize [1] IMPLICIT NULL,
-- specified step size not
-- supported
termList1 [3] IMPLICIT NULL,
-- term list not supported
-- (no alternative supplied)
termList2 [4] IMPLICIT SEQUENCE OF
AttributeList,
-- term list not supported
-- (alternatives supplied)
posInResponse [5] IMPLICIT INTEGER{
-- value of positionIn-
-- Response not supported
mustBeOne (1),
mustBePositive (2),
mustBeNonNegative (3),
other (4)},
resources [6] IMPLICIT NULL,
-- resources exhausted
-- looking for satisfying
-- terms
endOfList [7] IMPLICIT NULL
-- beginning or end of term
-- list
},
sort [1009] CHOICE{
sequence [0] IMPLICIT NULL,
-- cannot sort according
-- to sequence
noRsName [1] IMPLICIT NULL,
-- no result set name
-- supplied
tooMany [2] IMPLICIT INTEGER,
-- Too many input result
-- sets, maximum supplied.
incompatible [3] IMPLICIT NULL,
-- records with different
-- formats not compatible for
-- sorting
generic [4] IMPLICIT NULL,
-- generic sort not supported
-- (db specific only)
dbSpecific [5] IMPLICIT NULL,
-- db specific sort not
-- supported
sortElement [6] SortElement,
key [7] IMPLICIT INTEGER{
tooMany (1),
-- too many sort keys
duplicate (2)},
-- duplicate sort keys
action [8] IMPLICIT NULL,
-- unuspported missing data
-- action
illegal [9] IMPLICIT INTEGER{
relation (1),
-- illegal sort relation
case (2),
-- illegal case value
action (3),
-- illegal missing data
-- action
sort (4)},
-- illegal sort
inputTooLarge [10] IMPLICIT SEQUENCE OF
InternationalString,
-- one or more of the
-- input result sets too
-- large to sort
aggregateTooLarge [11] IMPLICIT NULL
-- aggregate result set
-- too large
},
segmentation [1010] CHOICE{
segmentCount [0] IMPLICIT NULL,
-- Cannot guarantee record will fit
-- within max segments. Target
-- suggests that origin try again
-- to retrieve record, without
-- including max-segment-count.
segmentSize [1] IMPLICIT INTEGER
-- record cannot be segmented into
-- fragments such that the largest
-- will fit within max segment
-- size specified. Target supplies (in
-- bytes) the smallest acceptable value.
-- of Max-segment-size to retrieve
-- the record.
},
extServices [1011] CHOICE{
req [1] IMPLICIT INTEGER{ -- bad request
nameInUse (1),
-- package name already in use
noSuchName (2),
-- no such package, on
-- modify/delete
quota (3),
-- quota exceeded
type (4)},
-- extended service type not
-- supported
permission [2] IMPLICIT INTEGER{
-- permission denied on ES, because:
id (1),
-- id not authorized, or
modifyDelete (2)},
-- cannot modify or delete
immediate [3] IMPLICIT INTEGER{
-- immediate execution:
failed (1),
service (2),
-- not supported for this service,
parameters (3)
-- not supported for these
-- parameters.
}},
accessCtrl [1012] CHOICE{
noUser [1] IMPLICIT NULL,
-- no user to display challenge to
refused [2] IMPLICIT NULL,
-- access control information
-- refused by user
simple [3] IMPLICIT NULL,
-- only simple form supported
-- (target used externally defined)
oid [4] IMPLICIT SEQUENCE OF OBJECT
IDENTIFIER,
-- oid not supported (origin
-- supplies alternative suggested
-- oids)
alternative [5] IMPLICIT SEQUENCE OF OBJECT
IDENTIFIER,
-- origin insists that target use
-- an alternative challenge for
-- this data (e.g. stronger
-- authentication or stronger
-- Access control). The origin
-- supplies suggested alternative
-- oids.
pwdInv [6] IMPLICIT NULL,
-- password invalid
pwdExp [7] IMPLICIT NULL
-- password expired
},
recordSyntax [1013] IMPLICIT SEQUENCE{
-- record cannot be transferred in requested syntax
unsupportedSyntax [1] IMPLICIT OBJECT
IDENTIFIER,
suggestedAlternatives [2] IMPLICIT SEQUENCE OF
OBJECT IDENTIFIER
OPTIONAL}
}
END
RecordSyntax-explain
{Z39-50-recordSyntax explain (100)} DEFINITIONS ::=
BEGIN
IMPORTS AttributeSetId, Term, OtherInformation, DatabaseName, ElementSetName,
IntUnit, Unit, StringOrNumeric, Specification, InternationalString,
AttributeList, AttributeElement FROM Z39-50-APDU-1995;
Explain-Record ::= CHOICE{
-- Each of these may be used as search term
-- when Use attribute is 'explain-category'.
targetInfo [0] IMPLICIT TargetInfo,
databaseInfo [1] IMPLICIT DatabaseInfo,
schemaInfo [2] IMPLICIT SchemaInfo,
tagSetInfo [3] IMPLICIT TagSetInfo,
recordSyntaxInfo [4] IMPLICIT RecordSyntaxInfo,
attributeSetInfo [5] IMPLICIT AttributeSetInfo,
termListInfo [6] IMPLICIT TermListInfo,
extendedServicesInfo [7] IMPLICIT ExtendedServicesInfo,
attributeDetails [8] IMPLICIT AttributeDetails,
termListDetails [9] IMPLICIT TermListDetails,
elementSetDetails [10] IMPLICIT ElementSetDetails,
retrievalRecordDetails [11] IMPLICIT RetrievalRecordDetails,
sortDetails [12] IMPLICIT SortDetails,
processing [13] IMPLICIT ProcessingInformation,
variants [14] IMPLICIT VariantSetInfo,
units [15] IMPLICIT UnitInfo,
categoryList [100] IMPLICIT CategoryList}
-- Element set name 'B' (brief) retrieves:
-- - 'commonInfo' (except for otherInfo within commonInfo)
-- - key elements
-- - other elements designated as 'non-key brief elements'
-- Esn 'description' retrieves brief elements as well as 'description', and
-- specific additional descriptive elements if designated.
-- Element set name 'F' (full) retrieves all of the above, as well as those
-- designated as "non-brief elements". Some elements designated as OPTIONAL
-- may be madatory in full records, and are so identified. (Note that all
-- elements that are not part of the brief element set must be designated as
-- OPTIONAL in the ASN.1, otherwise it would be illegal to omit them).
-- Other esns are defined (below) as needed.
-- - - - - - - - - - - - - Info Records
-- Info records are mainly for software consumption
-- They describe individual entities within the target system:
-- The target itself
-- Individual databases
-- Schemas
-- Tag sets
-- Record syntaxes
-- Attribute sets
-- Term lists
-- Extended services
-- The information about each Schema, Tag Set, Record Syntax and Attribute
-- Set should match the universal definitions of these items. The only
-- exception is that a target may omit any- items it doesn't support, for
-- example the description of the BIB-1 attribute set may omit attributes
-- that the target does not support under any circumstances.
-- Databases that may be searched together can be listed in the
-- dbCominations element of the TargetInfo record.
TargetInfo ::= SEQUENCE {
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
name [1] IMPLICIT InternationalString,
-- Non-key brief elements follow:
recent-news [2] IMPLICIT HumanString OPTIONAL,
icon [3] IMPLICIT IconObject OPTIONAL,
namedResultSets [4] IMPLICIT BOOLEAN,
multipleDBsearch [5] IMPLICIT BOOLEAN,
maxResultSets [6] IMPLICIT INTEGER OPTIONAL,
maxResultSize [7] IMPLICIT INTEGER OPTIONAL,
maxTerms [8] IMPLICIT INTEGER OPTIONAL,
timeoutInterval [9] IMPLICIT IntUnit OPTIONAL,
welcomeMessage [10] IMPLICIT HumanString OPTIONAL,
-- non-brief elements follow:
-- 'description' esn retrieves the following two (as well as brief):
contactInfo [11] IMPLICIT ContactInfo OPTIONAL,
description [12] IMPLICIT HumanString OPTIONAL,
nicknames [13] IMPLICIT SEQUENCE OF InternationalString
OPTIONAL,
usage-restrictions [14] IMPLICIT HumanString OPTIONAL,
paymentAddr [15] IMPLICIT HumanString OPTIONAL,
hours [16] IMPLICIT HumanString OPTIONAL,
dbCombinations [17] IMPLICIT SEQUENCE OF DatabaseList OPTIONAL,
addresses [18] IMPLICIT SEQUENCE OF NetworkAddress OPTIONAL,
languages [101] IMPLICIT SEQUENCE OF InternationalStringOPTIONAL,
-- Languages supported for message strings. Each is a three-character
-- language code from Z39.53-1994.
-- characterSets [102] this tag reserved for "character sets supported for name and message strings".
-- commonAccessInfo elements list objects the target supports. All objects
-- listed in AccessInfo for any individual database should also be listed
-- here.
commonAccessInfo [19] IMPLICIT AccessInfo OPTIONAL}
--
DatabaseInfo ::= SEQUENCE {
-- A target may provide "virtual databases" that are combinations of
-- individual database. These databases are indicated by the
-- presence of subDbs in the combination database's
-- DatabaseDescription.
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
name [1] IMPLICIT DatabaseName,
-- Non-key brief elements follow:
explainDatabase [2] IMPLICIT NULL OPTIONAL,
-- If present, this database is the Explain
-- database, or an Explain database
-- for a different server,
-- possibly on a different host. The means
-- by which that server may be accessed is
-- not addressed by this standard. One
-- suggested possibility is an implementor
-- agreement whereby the database name is a
-- url which may be used to connect to the
-- server.
nicknames [3] IMPLICIT SEQUENCE OF DatabaseName OPTIONAL,
icon [4] IMPLICIT IconObject OPTIONAL,
user-fee [5] IMPLICIT BOOLEAN,
available [6] IMPLICIT BOOLEAN,
titleString [7] IMPLICIT HumanString OPTIONAL,
-- Non-brief elements follow:
keywords [8] IMPLICIT SEQUENCE OF HumanString OPTIONAL,
description [9] IMPLICIT HumanString OPTIONAL,
associatedDbs [10] IMPLICIT DatabaseList OPTIONAL,
-- databases that may be searched in
-- combination with this one
subDbs [11 IMPLICIT DatabaseList OPTIONAL,
-- When present, this database is a
-- composite representing the combined
-- databases 'subDbs'. The individual subDbs
-- are also available.
disclaimers [12] IMPLICIT HumanString OPTIONAL,
news [13] IMPLICIT HumanString OPTIONAL,
recordCount [14] CHOICE {
actualNumber [0] IMPLICIT INTEGER,
approxNumber [1] IMPLICIT INTEGER}
OPTIONAL,
defaultOrder [15] IMPLICIT HumanString OPTIONAL,
avRecordSize [16] IMPLICIT INTEGER OPTIONAL,
maxRecordSize [17] IMPLICIT INTEGER OPTIONAL,
hours [18] IMPLICIT HumanString OPTIONAL,
bestTime [19] IMPLICIT HumanString OPTIONAL,
lastUpdate [20] IMPLICIT GeneralizedTime OPTIONAL,
updateInterval [21] IMPLICIT IntUnit OPTIONAL,
coverage [22] IMPLICIT HumanString OPTIONAL,
proprietary [23] IMPLICIT BOOLEAN OPTIONAL,
-- mandatory in full record
copyrightText [24] IMPLICIT HumanString OPTIONAL,
copyrightNotice [25] IMPLICIT HumanString OPTIONAL,
producerContactInfo [26] IMPLICIT ContactInfo OPTIONAL,
supplierContactInfo [27] IMPLICIT ContactInfo OPTIONAL,
submissionContactInfo [28] IMPLICIT ContactInfo OPTIONAL,
-- accessInfo lists items connected with the database. All listed items
-- should be in the target's AccessInfo.
accessInfo [29] IMPLICIT AccessInfo OPTIONAL}
SchemaInfo ::= SEQUENCE {
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
schema [1] IMPLICIT OBJECT IDENTIFIER,
-- Non-key brief elements follow:
name [2] IMPLICIT InternationalString,
-- Non-brief elements follow:
description [3] IMPLICIT HumanString OPTIONAL,
tagTypeMapping [4] IMPLICIT SEQUENCE OF SEQUENCE {
tagType [0] IMPLICIT INTEGER,
tagSet [1] IMPLICIT OBJECT IDENTIFIER
OPTIONAL,
-- If tagSet is omitted, then
-- this tagType is for a tagSet
-- locally defined within the
-- schema that cannot be
-- referenced by another schema.
defaultTagType [2] IMPLICIT NULL OPTIONAL} OPTIONAL,
recordStructure [5] IMPLICIT SEQUENCE OF ElementInfo OPTIONAL}
-- ElementInfo referenced in SchemaInfo and RecordSyntaxInfo
ElementInfo ::= SEQUENCE {
elementName [1] IMPLICIT InternationalString,
elementTagPath [2] IMPLICIT Path,
dataType [3] ElementDataType OPTIONAL,
-- If omitted, not specified.
required [4] IMPLICIT BOOLEAN,
repeatable [5] IMPLICIT BOOLEAN,
description [6] IMPLICIT HumanString OPTIONAL}
-- Path is referenced by ElementInfo as well as PerElementDetails
Path ::= SEQUENCE OF SEQUENCE{
tagType [1] IMPLICIT INTEGER,
tagValue [2] StringOrNumeric}
ElementDataType ::= CHOICE{
primitive [0] IMPLICIT PrimitiveDataType,
structured [1] IMPLICIT SEQUENCE OF ElementInfo}
PrimitiveDataType ::= INTEGER{
octetString (0),
numeric (1),
date (2),
external (3),
string (4),
trueOrFalse (5),
oid (6),
intUnit (7),
empty (8),
noneOfTheAbove (100) -- see 'description'
}
TagSetInfo ::= SEQUENCE {
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
tagSet [1] IMPLICIT OBJECT IDENTIFIER,
-- non-key brief elements follow:
name [2] IMPLICIT InternationalString,
-- non-brief elements follow:
description [3] IMPLICIT HumanString OPTIONAL,
elements [4] IMPLICIT SEQUENCE OF SEQUENCE {
elementname [1] IMPLICIT InternationalString,
nicknames [2] IMPLICIT SEQUENCE OF
InternationalString OPTIONAL,
elementTag [3] StringOrNumeric,
description [4] IMPLICIT HumanString OPTIONAL,
dataType [5] PrimitiveDataType OPTIONAL,
-- If the data type is expected
-- to be structured, that is
-- described in the schema info,
-- and datatypeis omitted here.
otherTagInfo OtherInformation OPTIONAL} OPTIONAL}
RecordSyntaxInfo ::= SEQUENCE {
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
recordSyntax [1] IMPLICIT OBJECT IDENTIFIER,
-- Non-key brief elements follow:
name [2] IMPLICIT InternationalString,
-- non-brief elements follow:
transferSyntaxes [3] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
description [4] IMPLICIT HumanString OPTIONAL,
asn1Module [5] IMPLICIT InternationalString OPTIONAL,
abstractStructure [6] IMPLICIT SEQUENCE OF ElementInfo OPTIONAL
-- Omitting abstractStructure only means target
-- isn't using Explain to describe the structure,
-- not that there is no structure.
}
AttributeSetInfo ::= SEQUENCE {
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
attributeSet [1] IMPLICIT AttributeSetId,
-- non-key brief elements follow:
name [2] IMPLICIT InternationalString,
-- non-brief elements follow:
attributes [3] IMPLICIT SEQUENCE OF AttributeType OPTIONAL,
-- mandatory in full record
description [4] IMPLICIT HumanString OPTIONAL}
-- AttributeType referenced in AttributeSetInfo
AttributeType ::= SEQUENCE {
name [0] IMPLICIT InternationalString OPTIONAL,
description [1] IMPLICIT HumanString OPTIONAL,
attributeType [2] IMPLICIT INTEGER,
attributeValues [3] IMPLICIT SEQUENCE OF AttributeDescription}
AttributeDescription ::= SEQUENCE {
name [0] IMPLICIT InternationalString OPTIONAL,
description [1] IMPLICIT HumanString OPTIONAL,
attributeValue [2] StringOrNumeric,
equivalentAttributes [3] IMPLICIT SEQUENCE OF StringOrNumeric
OPTIONAL
-- each is an occurence of
-- 'attributeValue' from
--AttributeDescription for a
-- different attribute. Equivalences
-- listed here should be derived from the
-- attribute set definition, not from a
-- particular server's behavior.
}
TermListInfo ::= SEQUENCE{
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
databaseName [1] IMPLICIT DatabaseName,
-- Non-key brief elements follow:
termLists [2] IMPLICIT SEQUENCE OF SEQUENCE{
name [1] IMPLICIT InternationalString,
title [2] IMPLICIT HumanString OPTIONAL,
-- Title is for users to see
-- and can differ by language.
-- Name, on the other hand, is
-- typically a short string
-- not necessarily meant to be
-- human-readable, and not
-- variable by language.
searchCost [3] IMPLICIT INTEGER {
optimized (0),
-- The attribute (or combination)
-- associated with this list will
-- do fast searches.
normal (1),
-- The attribute (combination) will
-- work expected. So there's
-- probably an index for the
-- attribute (combination) or some
-- similar mechanism.
expensive (2),
-- Can use the attribute
-- (combination), but it might not
-- provide satisfactory results.
-- Probably there is no index, or
-- post-processing of records is
-- required.
filter (3)
-- can't search with this
-- attribute (combination) alone.
} OPTIONAL,
scanable [4] IMPLICIT BOOLEAN,
-- 'true' means this list can be
-- scanned.
broader [5] IMPLICIT SEQUENCE OF InternationalString
OPTIONAL,
narrower [6] IMPLICIT SEQUENCE OF InternationalString
OPTIONAL
-- broader and narrower list
-- alternative term lists related to
-- this one. The term lists so listed
-- should also be in this termLists
-- structure.
}
-- no non-brief elements
}
ExtendedServicesInfo ::= SEQUENCE {
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
type [1] IMPLICIT OBJECT IDENTIFIER,
-- Non-key brief elements follow:
name [2] IMPLICIT InternationalString OPTIONAL,
-- should be supplied if privateType is 'true'
privateType [3] IMPLICIT BOOLEAN,
restrictionsApply [5] IMPLICIT BOOLEAN, -- if 'true' see 'description'
feeApply [6] IMPLICIT BOOLEAN, -- if 'true' see 'description'
available [7] IMPLICIT BOOLEAN,
retentionSupported [8] IMPLICIT BOOLEAN,
waitAction [9] IMPLICIT INTEGER{
waitSupported (1),
waitAlways (2),
waitNotSupported (3),
depends (4),
notSaying (5)},
-- non-brief elements follow:
-- To get brief plus 'description' use esn 'description'
description [10] IMPLICIT HumanString OPTIONAL,
-- to get above elements and 'specificExplain' use esn
--'specificExplain'
specificExplain [11] IMPLICIT EXTERNAL OPTIONAL,
-- Use oid of specific ES, and select choice
-- [3] 'explain'. Format to be developed in
-- conjunction with the specific ES definition.
-- to get all elements except 'specificExplain', use esn 'asn'
esASN [12] IMPLICITInternationalString OPTIONAL
-- the ASN.1 for this ES
}
-- - - - - - - - - - - - - Detail records
-- The detail records describe relationships among entities supported by the
-- target. RetrievalRecordDetails describes the way that schema elements are
-- mapped into record elements. This mapping may be different for each
-- combination of database, schema, record syntax. The per-element details
-- describe the default mapping. Origin-request re-tagging can change that
-- mapping. When multiple databases are listed in a databaseNames element,
-- the record applies equally to all of the listed databases. This is
-- unrelated to searching the databases together. AttributeDetails describes
-- how databases can be searched. Each supported attribute is listed, and
-- the allowable combinations can be described.
AttributeDetails ::= SEQUENCE {
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
databaseName [1] IMPLICIT DatabaseName,
-- Non-brief elements follow:
attributesBySet [2] IMPLICIT SEQUENCE OF AttributeSetDetails
OPTIONAL,
-- mandatory in full record
attributeCombinations [3] IMPLICIT AttributeCombinations OPTIONAL}
-- AttributeSetDetails referenced by AttributeDetails
AttributeSetDetails ::= SEQUENCE {
attributeSet [0] IMPLICIT AttributeSetId,
attributesByType [1] IMPLICIT SEQUENCE OF AttributeTypeDetails}
AttributeTypeDetails ::= SEQUENCE {
attributeType [0] IMPLICIT INTEGER,
defaultIfOmitted [1] IMPLICIT OmittedAttributeInterpretation OPTIONAL,
attributeValues [2] IMPLICIT SEQUENCE OF AttributeValue OPTIONAL }
-- If no attributeValues are supplied, all
-- values of this type are fully supported, and
-- the descriptions in AttributeSetInfo are
-- adequate.
OmittedAttributeInterpretation ::= SEQUENCE {
defaultValue [0] StringOrNumeric OPTIONAL,
-- A default value is listed if that's how
-- the server works
defaultDescription [1] IMPLICIT HumanString OPTIONAL }
-- The human-readable description should
-- generally be provided. It is legal for
-- both default elements to be missing,
-- which means that the target will allow
-- the attribute type to be omitted, but
-- isn't saying what it will do.
AttributeValue ::= SEQUENCE {
value [0] StringOrNumeric,
description [1] IMPLICIT HumanString OPTIONAL,
subAttributes [2] IMPLICIT SEQUENCE OF StringOrNumeric OPTIONAL,
superAttributes [3] IMPLICIT SEQUENCE OF StringOrNumeric OPTIONAL,
partialSupport [4] IMPLICIT NULL OPTIONAL
-- partialSupport indicates that an attributeValue is
-- accepted, but may not be processed in the
-- "expected" way. One important reason for this is
-- composite databases: in this case partialSupport
-- may indicate that only some of the subDbs support
-- the attribute, and others ignore it.
}
TermListDetails ::= SEQUENCE{ -- one for each termList in TermListInfo
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
termListName [1] IMPLICIT InternationalString,
-- Non-key elements (all non-brief) follow:
description [2] IMPLICIT HumanString OPTIONAL,
attributes [3] IMPLICIT AttributeCombinations OPTIONAL,
-- Pattern for attributes that hit this list.
-- Mandatory in full record
scanInfo [4] IMPLICIT SEQUENCE {
maxStepSize [0] IMPLICIT INTEGER OPTIONAL,
collatingSequence [1] IMPLICIT HumanString OPTIONAL,
increasing [2] IMPLICIT BOOLEAN OPTIONAL}
OPTIONAL,
-- Occurs only if list is scanable.
-- If list is scanable and if scanInfo is omitted,
-- target doesn't consider these important.
estNumberTerms [5] IMPLICIT INTEGER OPTIONAL,
sampleTerms [6] IMPLICIT SEQUENCE OF Term OPTIONAL}
ElementSetDetails ::= SEQUENCE {
-- ElementSetDetails describes the way that database records are mapped to
-- record elements. This mapping may be different for each combination of
-- database name and element set. The database record description is a
-- schema, which may be private to the target. The schema's abstract
-- record structure and tag sets provide the vocabulary for discussing
-- record content; their presence in the Explain database does not imply
-- support for complex retrieval specification.
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
databaseName [1] IMPLICIT DatabaseName,
elementSetName [2] IMPLICIT ElementSetName,
recordSyntax [3] IMPLICIT OBJECT IDENTIFIER,
-- Non-key Brief elements follow:
schema [4] IMPLICIT OBJECT IDENTIFIER,
-- Non-brief elements follow:
description [5] IMPLICIT HumanString OPTIONAL,
detailsPerElement [6] IMPLICIT SEQUENCE OF PerElementDetails OPTIONAL
-- mandatory in full record
}
RetrievalRecordDetails ::= SEQUENCE {
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
databaseName [1] IMPLICIT DatabaseName,
schema [2] IMPLICIT OBJECT IDENTIFIER,
recordSyntax [3] IMPLICIT OBJECT IDENTIFIER,
-- Non-brief elements follow:
description [4] IMPLICIT HumanString OPTIONAL,
detailsPerElement [5] IMPLICIT SEQUENCE OF PerElementDetails OPTIONAL
-- mandatory in full record
}
-- PerElementDetails is referenced in RetreivalRecordDetails and
-- ElementSetDetails.
PerElementDetails ::= SEQUENCE {
name [0] IMPLICIT InternationalString OPTIONAL,
-- If the name is omitted, the record
-- syntax's name for this element is
-- appropriate.
recordTag [1] IMPLICIT RecordTag OPTIONAL,
-- The record tag may be omitted if tags are
-- inappropriate for the syntax, or if the
-- origin can be expected to know it for
-- some other reason.
schemaTags [2] IMPLICIT SEQUENCE OF Path OPTIONAL,
-- The information from the listed schema
-- elements is in some way to produce the
-- data sent in the listed record tag. The
-- 'contents' element below may describe the
-- the logic used.
maxSize [3] IMPLICIT INTEGER OPTIONAL,
minSize [4] IMPLICIT INTEGER OPTIONAL,
avgSize [5] IMPLICIT INTEGER OPTIONAL,
fixedSize [6] IMPLICIT INTEGER OPTIONAL,
repeatable [8] IMPLICIT BOOLEAN,
required [9] IMPLICIT BOOLEAN,
-- 'required' really means that target will
-- always supply the element.
description [12] IMPLICIT HumanString OPTIONAL,
contents [13] IMPLICIT HumanString OPTIONAL,
billingInfo [14] IMPLICIT HumanString OPTIONAL,
restrictions [15] IMPLICIT HumanString OPTIONAL,
alternateNames [16] IMPLICIT SEQUENCE OF InternationalString
OPTIONAL,
genericNames [17] IMPLICIT SEQUENCE OF InternationalString
OPTIONAL,
searchAccess [18] IMPLICIT AttributeCombinations OPTIONAL}
-- RecordTag referenced in PerElementDetails above
RecordTag ::= SEQUENCE {
qualifier [0] StringOrNumeric OPTIONAL,
-- E.g. tag set for GRS-1
tagValue [1] StringOrNumeric}
SortDetails ::= SEQUENCE {
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
databaseName [1] IMPLICIT DatabaseName,
-- No non-key brief elements
-- Non-brief elements follow:
sortKeys [2] IMPLICIT SEQUENCE OF SortKeyDetails OPTIONAL
-- mandatory in full record
}
SortKeyDetails ::= SEQUENCE {
description [0] IMPLICIT HumanString OPTIONAL,
elementSpecifications [1] IMPLICIT SEQUENCE OF Specification
OPTIONAL,
-- each specification is a way of
-- specifying this same sort key
attributeSpecifications [2] IMPLICIT AttributeCombinations OPTIONAL,
-- each combination is a way of
-- specifying this same sort key
sortType [3] CHOICE {
character [0] IMPLICIT NULL,
numeric [1] IMPLICIT NULL,
structured [2] IMPLICIT
HumanString} OPTIONAL,
caseSensitivity [4] IMPLICIT INTEGER {
always (0),
-- always case-sensitive
never (1),
-- never case-sensitive
default-yes (2),
-- case-sensitivity is as specified
-- on request, and if not
-- specified, case-sensitive.
default-no (3)
-- case-sensitivity is as specified
-- on request, and if not
-- specified, not case-sensitive.
}
OPTIONAL}
ProcessingInformation ::= SEQUENCE{
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
databaseName [1] IMPLICIT DatabaseName,
processingContext [2] IMPLICIT INTEGER {
access (0),
-- e.g. choosing databases
search (1),
-- e.g. "search strategies" or search forms
retrieval (2),
-- e.g. recommended element combinations
record-presentation (3),
-- display of retrieved records
record-handling (4)
-- handling (e.g. saving) of retrieved
-- records
},
name [3] IMPLICIT InternationalString,
oid [4] IMPLICIT OBJECT IDENTIFIER,
-- So origin can retreive brief record and
-- determine if it can handle 'instructions' when
-- retrieving the full record.
-- No non-key brief elements
-- Non-brief elements follow:
description [5] IMPLICIT HumanString OPTIONAL,
-- use element set name 'description'
-- to retrieve all except instructions.
instructions [6] IMPLICIT EXTERNAL OPTIONAL -- mandatory in full record
}
VariantSetInfo ::= SEQUENCE {
-- A record in this category describes a variant set definition, i.e.,
-- classes, types, and values, for a specific variant set definition
-- supported by the target. Support by the target of a particular
-- variant set definition does not imply that the definition is
-- supported for any specific database or element.
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
variantSet [1] IMPLICIT OBJECT IDENTIFIER,
-- Non-key brief elements follow:
name [2] IMPLICIT InternationalString,
-- Non-brief elements follow:
variants [3] IMPLICIT SEQUENCE OF VariantClass OPTIONAL
-- mandatory in full record
}
-- Subsidiary structures for VariantSetInfo
VariantClass ::= SEQUENCE {
name [0] IMPLICIT InternationalString OPTIONAL,
description [1] IMPLICIT HumanString OPTIONAL,
variantClass [2] IMPLICIT INTEGER,
variantTypes [3] IMPLICIT SEQUENCE OF VariantType}
VariantType ::= SEQUENCE {
name [0] IMPLICIT InternationalString OPTIONAL,
description [1] IMPLICIT HumanString OPTIONAL,
variantType [2] IMPLICIT INTEGER,
variantValue [3] IMPLICIT VariantValue OPTIONAL}
VariantValue ::= SEQUENCE {
dataType [0] PrimitiveDataType,
values [1] ValueSet OPTIONAL }
ValueSet ::= CHOICE {
range [0] IMPLICIT ValueRange,
enumerated [1] IMPLICIT SEQUENCE OF ValueDescription }
ValueRange ::= SEQUENCE {
-- At last one the following must be supplied, both
-- may be supplied.
lower [0] ValueDescription OPTIONAL,
upper [1] ValueDescription OPTIONAL }
ValueDescription ::= CHOICE{
integer INTEGER,
string InternationalString,
octets OCTET STRING,
oid OBJECT IDENTIFIER,
unit [1] IMPLICIT Unit,
valueAndUnit [2] IMPLICIT IntUnit
-- oid and unit can't be used in a ValueRange
}
UnitInfo ::= SEQUENCE {
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Key elements follow:
unitSystem [1] IMPLICIT InternationalString,
-- No non-key brief elements
-- Non-brief elements follow:
description [2] IMPLICIT HumanString OPTIONAL,
units [3] IMPLICIT SEQUENCE OF UnitType OPTIONAL }
-- mandatory in full record
-- Subsidiary structures for UnitInfo
UnitType ::= SEQUENCE {
name [0] IMPLICIT InternationalString OPTIONAL,
description [1] IMPLICIT HumanString OPTIONAL,
unitType [2] StringOrNumeric,
units [3] IMPLICIT SEQUENCE OF Units}
Units ::= SEQUENCE {
name [0] IMPLICIT InternationalString OPTIONAL,
description [1] IMPLICIT HumanString OPTIONAL,
unit [2] StringOrNumeric}
CategoryList ::= SEQUENCE {
commonInfo [0] IMPLICIT CommonInfo OPTIONAL,
-- Only one record expected per Explain database. All elements
-- appear in brief presentation.
categories [1] IMPLICIT SEQUENCE OF CategoryInfo }
CategoryInfo ::= SEQUENCE {
category [1] IMPLICIT InternationalString,
originalCategory [2] IMPLICIT InternationalString OPTIONAL,
description [3] IMPLICIT HumanString OPTIONAL,
asn1Module [4] IMPLICIT InternationalString OPTIONAL}
-- - - - - - - - - - - - - - Subsidiary definitions
CommonInfo ::= SEQUENCE {
dateAdded [0] IMPLICIT GeneralizedTime OPTIONAL,
dateChanged [1] IMPLICIT GeneralizedTime OPTIONAL,
expiry [2] IMPLICIT GeneralizedTime OPTIONAL,
humanString-Language [3] IMPLICIT LanguageCode OPTIONAL,
-- following not to occur for brief:
otherInfo OtherInformation OPTIONAL}
HumanString ::= SEQUENCE OF SEQUENCE {
language [0] IMPLICIT LanguageCode OPTIONAL,
text [1] IMPLICIT InternationalString}
IconObject ::= SEQUENCE OF SEQUENCE{
-- Note that the "SEQUENCE OF" is to allow alternative
-- representations of the same Icon; it is not intended to allow
-- multiple icons.
bodyType [1] CHOICE{
ianaType [1] IMPLICIT InternationalString,
z3950type [2] IMPLICIT InternationalString,
otherType [3] IMPLICIT InternationalString},
content [2] IMPLICIT OCTET STRING}
LanguageCode ::=InternationalString
-- from ANSI/NISO Z39.53-1994
ContactInfo ::= SEQUENCE {
name [0] IMPLICIT InternationalString OPTIONAL,
description [1] IMPLICIT HumanString OPTIONAL,
address [2] IMPLICIT HumanString OPTIONAL,
email [3] IMPLICIT InternationalString OPTIONAL,
phone [4] IMPLICIT InternationalString OPTIONAL}
NetworkAddress ::= CHOICE {
internetAddress [0] IMPLICIT SEQUENCE {
hostAddress [0] IMPLICIT
InternationalString,
port [1] IMPLICIT INTEGER},
osiPresentationAddress [1] IMPLICIT SEQUENCE {
pSel [0] IMPLICIT InternationalString,
sSel [1] IMPLICITInternationalString
OPTIONAL,
tSel [2] IMPLICITInternationalString
OPTIONAL,
nSap [3] IMPLICIT InternationalString},
other [2] IMPLICIT SEQUENCE {
type [0] IMPLICIT InternationalString,
address [1] IMPLICIT InternationalString}}
AccessInfo ::= SEQUENCE {
-- AccessInfo contains the fundmental information about what facilites
-- are required to use this target or server. For example, if an origin
-- can handle none of the record syntaxes a database can provide,
-- it might choose not to access the database.
queryTypesSupported [0] IMPLICIT SEQUENCE OF QueryTypeDetails OPTIONAL,
diagnosticsSets [1] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
attributeSetIds [2] IMPLICIT SEQUENCE OF AttributeSetId OPTIONAL,
schemas [3] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
recordSyntaxes [4] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
resourceChallenges [5] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
restrictedAccess [6] IMPLICIT AccessRestrictions OPTIONAL,
costInfo [8] IMPLICIT Costs OPTIONAL,
variantSets [9] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
elementSetNames [10] IMPLICIT SEQUENCE OF ElementSetName OPTIONAL,
unitSystems [11] IMPLICIT SEQUENCE OF InternationalString}
-- begin auxiliary definitions for AccessInfo
-- Begin Query Details
QueryTypeDetails ::= CHOICE {
private [0] IMPLICIT PrivateCapabilities,
rpn [1] IMPLICIT RpnCapabilities,
iso8777 [2] IMPLICIT Iso8777Capabilities,
z39-58 [100] IMPLICIT HumanString,
erpn [101] IMPLICIT RpnCapabilities,
rankedList [102] IMPLICIT HumanString}
PrivateCapabilities ::= SEQUENCE {
operators [0] IMPLICIT SEQUENCE OF SEQUENCE {
operator [0] IMPLICIT InternationalString,
description [1] IMPLICIT HumanString OPTIONAL } OPTIONAL,
searchKeys [1] IMPLICIT SEQUENCE OF SearchKey OPTIONAL,
-- field names that can be searched
description [2] IMPLICIT SEQUENCE OF HumanString OPTIONAL }
RpnCapabilities ::= SEQUENCE {
operators [0] IMPLICIT SEQUENCE OF INTEGER OPTIONAL,
-- Omitted means all operators are supported.
resultSetAsOperandSupported [1] IMPLICIT BOOLEAN,
restrictionOperandSupported [2] IMPLICIT BOOLEAN,
proximity [3] IMPLICIT ProximitySupport OPTIONAL}
Iso8777Capabilities ::= SEQUENCE {
searchKeys [0] IMPLICIT SEQUENCE OF SearchKey,
-- field names that may be searched
restrictions [1] IMPLICIT HumanString OPTIONAL
-- Omitted means supported, not specifying units.
}
ProximitySupport ::= SEQUENCE {
anySupport [0] IMPLICIT BOOLEAN,
-- 'false' means no proximity support, in which case
-- unitsSupported not supplied.
unitsSupported [1] IMPLICIT SEQUENCE OF CHOICE{
known [1] IMPLICIT INTEGER,
-- values from KnownProximityUnit
private [2] IMPLICIT SEQUENCE{
unit [0] IMPLICIT INTEGER,
description [1] HumanString OPTIONAL}}
OPTIONAL}
SearchKey ::= SEQUENCE {
searchKey [0] IMPLICIT InternationalString,
description [1] IMPLICIT HumanString OPTIONAL }
-- End Query details
AccessRestrictions ::= SEQUENCE OF SEQUENCE {
accessType [0] INTEGER {
any (0),
search (1),
present (2),
specific-elements (3),
extended-services (4),
by-database (5)},
accessText [1] IMPLICIT HumanString OPTIONAL,
accessChallenges [2] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL}
Costs ::= SEQUENCE {
connectCharge [0] IMPLICIT Charge OPTIONAL, -- Per-connection charge
connectTime [1] IMPLICIT Charge OPTIONAL, -- Time-based charge
displayCharge [2] IMPLICIT Charge OPTIONAL, -- Per-record charge
searchCharge [3] IMPLICIT Charge OPTIONAL, -- Per-search charge
subscriptCharge [4] IMPLICIT Charge OPTIONAL, -- Subscription charges
otherCharges [5] IMPLICIT SEQUENCE OF SEQUENCE{ -- Other charges
forWhat [1] IMPLICIT HumanString,
charge [2] IMPLICIT Charge} OPTIONAL}
Charge ::= SEQUENCE{
cost [1] IMPLICIT IntUnit,
perWhat [2] IMPLICIT Unit OPTIONAL,
-- e.g. "second," "minute," "line," "record"...
text [3] IMPLICIT HumanString OPTIONAL}
-- End Auxiliary definitions for AccessInfo
DatabaseList ::= SEQUENCE OF DatabaseName
AttributeCombinations ::= SEQUENCE {
defaultAttributeSet [0] IMPLICIT AttributeSetId,
-- Default for the combinations. Also probably
-- a good choice for the default
-- in searches, but that isn't required.
legalCombinations [1] IMPLICIT SEQUENCE OF AttributeCombination }
AttributeCombination ::= SEQUENCE OF AttributeOccurrence
-- An AttributeCombination is a pattern for legal combination of attributes
AttributeOccurrence ::= SEQUENCE {
-- An AttributeOccurrence lists the legal values for a
-- specific attribute type in a combination.
attributeSet [0] IMPLICIT AttributeSetId OPTIONAL,
attributeType [1] IMPLICIT INTEGER,
mustBeSupplied [2] IMPLICIT NULL OPTIONAL,
attributeValues CHOICE {
any-or-none [3] IMPLICIT NULL,
-- All supported values are OK
specific [4] IMPLICIT SEQUENCE OF
StringOrNumeric}}
-- Only these values allowed
END
RecordSyntax-SUTRS
{Z39-50-recordSyntax SUTRS (101)} DEFINITIONS ::=
BEGIN
IMPORTS InternationalString FROM Z39-50-APDU-1995;
SutrsRecord ::= InternationalString
-- Line terminator is ASCII LF (X'0A').
-- Recommended maximum line length is 72 characters.
END
RecordSyntax-opac
{Z39-50-recordSyntax opac (102)} DEFINITIONS ::=
BEGIN
IMPORTS InternationalString FROM Z39-50-APDU-1995;
OPACRecord ::= SEQUENCE {
bibliographicRecord [1] IMPLICIT EXTERNAL OPTIONAL,
holdingsData [2] IMPLICIT SEQUENCE OF HoldingsRecord OPTIONAL}
HoldingsRecord ::= CHOICE {
marcHoldingsRecord [1] IMPLICIT EXTERNAL,
holdingsAndCirc [2] IMPLICIT HoldingsAndCircData}
HoldingsAndCircData ::= SEQUENCE {
-- the following elements are required to display
-- holdings in conformance with NISO standards.
typeOfRecord [1] IMPLICIT InternationalString OPTIONAL,-- LDR 06
encodingLevel [2] IMPLICIT InternationalString OPTIONAL, -- LDR 017
format [3] IMPLICIT InternationalString OPTIONAL, -- 007
-- 00-01
receiptAcqStatus [4] IMPLICIT InternationalString OPTIONAL, -- 008 06
generalRetention [5] IMPLICIT InternationalString OPTIONAL, -- 008 12
completeness [6] IMPLICIT InternationalString OPTIONAL, -- 008 16
dateOfReport [7] IMPLICIT InternationalString OPTIONAL, -- 008
-- 26-31
nucCode [8] IMPLICIT InternationalString OPTIONAL, -- 852 $a
localLocation [9] IMPLICIT InternationalString OPTIONAL, -- 852 $b
shelvingLocation [10] IMPLICIT InternationalString OPTIONAL, -- 852 $c
callNumber [11] IMPLICIT InternationalString OPTIONAL, -- 852 $h
-- and $i
shelvingData [12] IMPLICIT InternationalString OPTIONAL, -- 852 $j
-- thru $m
copyNumber [13] IMPLICIT InternationalString OPTIONAL, -- 852 $t
publicNote [14] IMPLICIT InternationalString OPTIONAL, -- 852 $z
reproductionNote [15] IMPLICIT InternationalString OPTIONAL, -- 843
termsUseRepro [16] IMPLICIT InternationalString OPTIONAL, -- 845
enumAndChron [17] IMPLICIT InternationalString OPTIONAL, -- all 85x,
-- 86x
volumes [18] IMPLICIT SEQUENCE OF Volume OPTIONAL,
-- repeats for each volume held
circulationData [19] IMPLICIT SEQUENCE OF CircRecord OPTIONAL
-- repeats for each circulating item.
}
Volume ::= SEQUENCE {
enumeration [1] IMPLICIT InternationalString OPTIONAL,
chronology [2] IMPLICIT InternationalString OPTIONAL,
enumAndChron [3] IMPLICIT InternationalString OPTIONAL }
CircRecord ::= SEQUENCE {
availableNow [1] IMPLICIT BOOLEAN,
availablityDate [2] IMPLICIT InternationalString OPTIONAL,
availableThru [3] IMPLICIT InternationalString OPTIONAL,
restrictions [4] IMPLICIT InternationalString OPTIONAL,
itemId [5] IMPLICIT InternationalString OPTIONAL,
renewable [6] IMPLICIT BOOLEAN,
onHold [7] IMPLICIT BOOLEAN,
enumAndChron [8] IMPLICIT InternationalString OPTIONAL,
midspine [9] IMPLICIT InternationalString OPTIONAL,
temporaryLocation [10] IMPLICIT InternationalString OPTIONAL}
END
RecordSyntax-summary
{Z39-50-recordSyntax summary (103)} DEFINITIONS ::=
BEGIN
IMPORTS OtherInformation, InternationalString FROM Z39-50-APDU-1995;
BriefBib ::= SEQUENCE {
title [1] IMPLICIT InternationalString,
author [2] IMPLICIT InternationalString OPTIONAL,
callNumber [3] IMPLICIT InternationalString OPTIONAL,
recordType [4] IMPLICIT InternationalString OPTIONAL,
bibliographicLevel [5] IMPLICIT InternationalString OPTIONAL,
format [6] IMPLICIT SEQUENCE OF FormatSpec OPTIONAL,
publicationPlace [7] IMPLICIT InternationalString OPTIONAL,
publicationDate [8] IMPLICIT InternationalString OPTIONAL,
targetSystemKey [9] IMPLICIT InternationalString OPTIONAL,
satisfyingElement [10] IMPLICIT InternationalString OPTIONAL,
rank [11] IMPLICIT INTEGER OPTIONAL,
documentId [12] IMPLICIT InternationalString OPTIONAL,
abstract [13] IMPLICIT InternationalString OPTIONAL,
otherInfo OtherInformation OPTIONAL}
FormatSpec ::= SEQUENCE {
type [1] IMPLICIT InternationalString,
size [2] IMPLICIT INTEGER OPTIONAL,
bestPosn [3] IMPLICIT INTEGER OPTIONAL}
END
RecordSyntax-generic -- For detailed semantics, see Appendix RET.
{Z39-50-recordSyntax GRS-1 (105)} DEFINITIONS ::=
BEGIN
EXPORTS Variant;
IMPORTS IntUnit, Unit, InternationalString, StringOrNumeric, Term
FROM Z39-50-APDU-1995;
GenericRecord ::= SEQUENCE OF TaggedElement
TaggedElement ::= SEQUENCE {
tagType [1] IMPLICIT INTEGER OPTIONAL,
-- If omitted, default should be supplied dynamically
-- by tagSet-M; otherwise it should be statically
-- specified by the schema.
tagValue [2] StringOrNumeric,
tagOccurrence [3] IMPLICIT INTEGER OPTIONAL,
-- Occurrence within the database record, and
-- relative to the parent. No default; if omitted,
-- target not telling or it is irrelevant.
content [4] ElementData,
metaData [5] IMPLICIT ElementMetaData OPTIONAL,
appliedVariant [6] IMPLICIT Variant OPTIONAL}
ElementData ::= CHOICE{
octets OCTET STRING,
numeric INTEGER,
date GeneralizedTime,
ext EXTERNAL,
string InternationalString,
trueOrFalse BOOLEAN,
oid OBJECT IDENTIFIER,
intUnit [1] IMPLICIT IntUnit,
elementNotThere [2] IMPLICIT NULL, -- element requested but not there
elementEmpty [3] IMPLICIT NULL, -- element there, but empty
noDataRequested [4] IMPLICIT NULL, -- variant request said 'no data'
diagnostic [5] IMPLICIT EXTERNAL,
subtree [6] SEQUENCE OF TaggedElement
-- recursive, for nested tags
}
ElementMetaData ::= SEQUENCE{
seriesOrder [1] IMPLICIT Order OPTIONAL,
-- only for a non-leaf node
usageRight [2] IMPLICIT Usage OPTIONAL,
hits [3] IMPLICIT SEQUENCE OF HitVector OPTIONAL,
displayName [4] IMPLICIT InternationalString OPTIONAL,
-- name for element that origin can use for
-- display
supportedVariants [5] IMPLICIT SEQUENCE OF Variant OPTIONAL,
message [6] IMPLICIT InternationalString OPTIONAL,
elementDescriptor [7] IMPLICIT OCTET STRING OPTIONAL,
surrogateFor [8] IMPLICIT TagPath OPTIONAL,
-- the retrieved element is a surrogate for the
-- element given by this path
surrogateElement [9] IMPLICIT TagPath OPTIONAL,
-- the element given by this path is a
-- surrogate for the retrieved element
other [99] IMPLICIT EXTERNAL OPTIONAL}
TagPath ::= SEQUENCE OF SEQUENCE{
tagType [1] IMPLICIT INTEGER OPTIONAL,
tagValue [2] StringOrNumeric,
tagOccurrence [3] IMPLICIT INTEGER OPTIONAL}
Order ::= SEQUENCE{
ascending [1] IMPLICIT BOOLEAN,
-- "true" means monotonically increasing (i.e. non-
-- decreasing); "false" means monotonically
-- decreasing (i.e. non-increasing).
order [2] IMPLICIT INTEGER
-- Same as defined by 'elementOrdering' in tagSet-M,
-- though this may be overidden by schema.
}
Usage ::= SEQUENCE {
type [1] IMPLICIT INTEGER{
redistributable (1),
-- Element is freely redistributable.
restricted (2),
-- Restriction contains statement.
licensePointer (3)
-- Restriction contains license pointer.
},
restriction [2] IMPLICIT InternationalString OPTIONAL}
HitVector ::= SEQUENCE{
-- Each hit vector points to a fragment within the
-- element, via location and/or token.
satisfier Term OPTIONAL, -- sourceword, etc.
offsetIntoElement [1] IMPLICIT IntUnit OPTIONAL,
length [2] IMPLICIT IntUnit OPTIONAL,
hitRank [3] IMPLICIT INTEGER OPTIONAL,
targetToken [4] IMPLICIT OCTET STRING OPTIONAL
-- Origin may use token subsequently within a
-- variantRequest (in an elementRequest) to
-- retrieve (or to refer to) the fragment.
}
Variant ::= SEQUENCE{
globalVariantSetId [1] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
-- Applies to the triples below, when
-- variantSetId omitted. If
-- globalVariantSetId omitted, default applies.
-- Default may be provided by the tagSet-M
-- element defaultVariantSetId.
triples [2] IMPLICIT SEQUENCE OF SEQUENCE{
variantSetId [0] IMPLICIT OBJECT IDENTIFIER
OPTIONAL,
-- If omitted,
-- globalVariantSetId
-- (above) applies, unless
-- that too is omitted, in
-- which case, default
-- used.
class [1] IMPLICIT INTEGER,
type [2] IMPLICIT INTEGER,
value [3] CHOICE{
INTEGER,
InternationalString,
OCTET STRING,
OBJECT IDENTIFIER,
BOOLEAN,
NULL,
-- Following need context tags:
unit [1] IMPLICIT Unit,
valueAndUnit [2] IMPLICIT
IntUnit}}}
END
RecordSyntax-ESTaskPackage
{Z39-50-recordSyntax ESTaskPackage (106)} DEFINITIONS ::=
BEGIN
IMPORTS Permissions, InternationalString, IntUnit, DiagRec
FROM Z39-50-APDU-1995;
TaskPackage ::= SEQUENCE{
packageType [1] IMPLICIT OBJECT IDENTIFIER,
-- oid of specific ES definition
packageName [2] IMPLICIT InternationalString OPTIONAL,
userId [3] IMPLICIT InternationalString OPTIONAL,
retentionTime [4] IMPLICIT IntUnit OPTIONAL,
permissions [5] IMPLICIT Permissions OPTIONAL,
description [6] IMPLICIT InternationalString OPTIONAL,
targetReference [7] IMPLICIT OCTET STRING OPTIONAL,
creationDateTime [8] IMPLICIT GeneralizedTime OPTIONAL,
taskStatus [9] IMPLICIT INTEGER{
pending (0),
active (1),
complete (2),
aborted (3)},
packageDiagnostics [10] IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
taskSpecificParameters [11] IMPLICIT EXTERNAL
-- Use oid for specific ES definition
-- (same oid as packageType above)
-- and select [2] "taskPackage."
}
END
ResourceReport-Format-Resource-1
{Z39-50-resourceReport resource-1 (1)} DEFINITIONS ::=
BEGIN
IMPORTS InternationalString FROM Z39-50-APDU-1995;
--
ResourceReport ::= SEQUENCE{
estimates [1] IMPLICIT SEQUENCE OF Estimate,
message [2] IMPLICITInternationalString}
--
Estimate ::= SEQUENCE{
type [1] IMPLICIT EstimateType,
value [2] IMPLICIT INTEGER, -- the actual estimate
currency-code [3] IMPLICIT INTEGER OPTIONAL
-- code for representation of currencies defined in ISO
-- 4217-1990. Applicable only to monetary estimates.
}
EstimateType ::= INTEGER{
currentSearchRecords (1), -- estimated no. records in current
-- (incomplete) result set for search
finalSearchRecords (2), -- estimated no. records that will be in result
-- set if search completes
currentPresentRecords (3), -- estimated number of records in current
-- (incomplete) set of records to be returned
-- on Present
finalPresentRecords (4), -- estimated number of records that will be in
-- the set of records to be returned by Present
-- if Present completes
currentOpTimeProcessing (5), -- processing time (in .001 CPU seconds) used
-- by operation so far
finalOpTimeProcessing (6), -- estimated total processing time (in .001 CPU
-- seconds) that will be used by this operation
-- if it completes
currentAssocTime (7), -- estimated processing time used by
-- association (in .001 CPU sec.)
currentOperationCost (8), -- estimated cost for this operation so far
finalOperationCost (9), -- estimated cost for this operation if it
-- completes
currentAssocCost (10), -- estimated cost for this association so far
finalOpTimeElapsed (11), -- estimated elapsed time for operation if it
-- completes (in .001 sec.)
percentComplete (12), -- estimated percent complete
currentSearchAssocCost (13), -- estimated search cost for association so far
currentPresentAssocCost (14), -- estimated present cost for this association
-- so far
currentConnectAssocCost (15), -- estimated connect time cost for association
-- so far
currentOtherAssocCost (16) -- estimated other cost (not included in 13-15)
-- for association so far
}
END
ResourceReport-Format-Resource-2
{Z39-50-resourceReport resource-2 (2)} DEFINITIONS ::=
BEGIN
IMPORTS InternationalString, StringOrNumeric, IntUnit FROM
Z39-50-APDU-1995;
--
ResourceReport ::= SEQUENCE{
estimates [1] IMPLICIT SEQUENCE OF Estimate OPTIONAL,
message [2] IMPLICITInternationalString OPTIONAL}
--
Estimate ::= SEQUENCE{
type [1] StringOrNumeric,
-- Numeric values of 1-16 are the same as used in Resource-1.
value [2] IMPLICIT IntUnit
-- When expressing currency:
-- unitSystem (of Unit) is 'z3950' (case insensitive)
-- unitType is 'iso4217-1990' (case insensitive)
-- unit is currency code from ISO 4217-1990.
}
END
AccessControlFormat-prompt-1
{Z39-50-accessControl prompt-1 (1)} DEFINITIONS ::=
BEGIN
IMPORTS InternationalString, DiagRec FROM Z39-50-APDU-1995;
--
PromptObject ::= CHOICE{
challenge [1] IMPLICIT Challenge,
response [2] IMPLICIT Response}
Challenge ::= SEQUENCE OF SEQUENCE {
promptId [1] PromptId,
-- Target supplies a number (for an enumerated
-- prompt) or string (for a non-enumerated
-- prompt), for each prompt, and the origin
-- returns it in response, for this prompt, so
-- target may correlate the prompt response with
-- the prompt.
defaultResponse [2] IMPLICIT InternationalString OPTIONAL,
promptInfo [3] CHOICE{
character [1] IMPLICIT InternationalString,
encrypted [2] IMPLICIT Encryption} OPTIONAL,
-- Information corresponding to an
-- emumerated prompt. For example if 'type',
-- within PromptId, is 'copyright', then
-- promptInfo may contain a copyright
-- statement.
regExpr [4] IMPLICIT InternationalString OPTIONAL,
-- A regular expression that promptResponse should
-- match. See IEEE 1003.2 Volume 1, Section 2.8
-- "Regular Expression Notation." For example if
-- promptId is "Year of publication," regExpr
-- might be "19[89][0-9]|20[0-9][0-9]".
responseRequired [5] IMPLICIT NULL OPTIONAL,
allowedValues [6] IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
-- e.g. promptId="Desired color"; allowed = 'red',
-- 'blue','Green'.
shouldSave [7] IMPLICIT NULL OPTIONAL,
-- Target recommends that origin save the data
-- that it prompts from the user corresponding to
-- this prompt, because it is likely to be
-- requested again (so origin might not have to
-- prompt the user next time).
dataType [8] IMPLICIT INTEGER{
integer (1),
date (2),
float (3),
alphaNumeric (4),
url-urn (5),
boolean (6)} OPTIONAL,
-- Target telling origin type of data it
-- wants. E.g., if "date" is specified,
-- presumably the origin will try to prompt
-- something "date-like" from the user.
diagnostic [9] IMPLICIT EXTERNAL OPTIONAL
-- Intended for repeat requests when there is an
-- error the origin should report to the user from
-- previous attempt.
}
Response ::= SEQUENCE OF SEQUENCE {
promptId [1] PromptId,
-- Corresponds to a prompt in the challenge, or
-- may be unprompted, for example "newPassword."
-- If unprompted, should be "enumerated."
-- If this responds to a non-enumerated prompt,
-- then nonEnumeratedPrompt should contain the
-- prompt string from the challenge.
promptResponse [2] CHOICE{
string [1] IMPLICIT InternationalString,
accept [2] IMPLICIT BOOLEAN,
acknowledge [3] IMPLICIT NULL,
diagnostic [4] DiagRec,
encrypted [5] IMPLICIT Encryption}}
PromptId ::= CHOICE{
enummeratedPrompt [1] IMPLICIT SEQUENCE{
type [1] IMPLICIT INTEGER{
groupId (0),
userId (1),
password (2),
newPassword (3),
copyright (4),
-- When type on Challenge is
-- 'copyright', promptInfo has text of
-- copyright message to be displayed
-- verbatim to the user. If
-- promptResponse indicates
-- 'acceptance', this indicates the
-- user has been shown, and accepted,
-- the terms of the copyright. This is
-- not intended to be legally binding,
-- but provides a good-faith attempt
-- on the part of the target to inform
-- the user of the copyright.
sessionId (5)},
suggestedString [2] IMPLICIT
InternationalString OPTIONAL},
nonEnumeratedPrompt [2] IMPLICIT InternationalString}
Encryption ::= SEQUENCE{
cryptType [1] IMPLICIT OCTET STRING OPTIONAL,
credential [2] IMPLICIT OCTET STRING OPTIONAL,
--random number, SALT, or other factor
data [3] IMPLICIT OCTET STRING}
END
AccessControlFormat-des-1
{Z39-50-accessControlFormat des-1 (2)} DEFINITIONS ::=
BEGIN
DES-RN-Object ::= CHOICE {
challenge [1] IMPLICIT DRNType,
response [2] IMPLICIT DRNType}
DRNType ::= SEQUENCE{
userId [1] IMPLICIT OCTET STRING OPTIONAL,
salt [2] IMPLICIT OCTET STRING OPTIONAL,
randomNumber [3] IMPLICIT OCTET STRING}
END
AccessControlFormat-krb-1
{Z39-50-accessControlFormat krb-1 (3)} DEFINITIONS ::=
BEGIN
IMPORTS InternationalString FROM Z39-50-APDU-1995;
KRBObject ::= CHOICE {
challenge [1] IMPLICIT KRBRequest,
response [2] IMPLICIT KRBResponse}
KRBRequest ::= SEQUENCE{
service [1] IMPLICIT InternationalString,
instance [2] IMPLICIT InternationalString OPTIONAL,
realm [3] IMPLICIT InternationalString OPTIONAL
-- target requests a ticket for the given service,
-- instance, and realm
}
KRBResponse ::= SEQUENCE{
userid [1] IMPLICIT InternationalString OPTIONAL,
ticket [2] IMPLICIT OCTET STRING
-- origin responds with a ticket for the requested
-- service
}
END
ESFormat-PersistentResultSet
{Z39-50-extendedService PersistentResultSet (1)} DEFINITIONS ::=
BEGIN
IMPORTS InternationalString FROM Z39-50-APDU-1995;
PersistentResultSet ::= CHOICE{
esRequest [1] IMPLICIT SEQUENCE{
toKeep [1] IMPLICIT NULL,
notToKeep [2] OriginPartNotToKeep OPTIONAL},
taskPackage [2] IMPLICIT SEQUENCE{
originPart [1] IMPLICIT NULL,
targetPart [2] TargetPart OPTIONAL}}
OriginPartNotToKeep ::= SEQUENCE{
originSuppliedResultSet [1] IMPLICIT InternationalString OPTIONAL,
-- name of transient result set, supplied on
-- request, mandatory unless function is
'delete'
replaceOrAppend [2] IMPLICIT INTEGER{
-- only if function is "modify"
replace (1),
append (2)} OPTIONAL}
TargetPart ::= SEQUENCE{
targetSuppliedResultSet [1] IMPLICIT InternationalString OPTIONAL,
-- Name of transient result set, supplied by
-- target, representing the persistent
-- result set to which package pertains.
-- Meaningful only when package is
-- presented. (i.e. not on ES response)
numberOfRecords [2] IMPLICIT INTEGER OPTIONAL}
END
ESFormat-PersistentQuery
{Z39-50-extendedService PersistentQuery (2)} DEFINITIONS ::=
BEGIN
IMPORTS Query, InternationalString, OtherInformation FROM Z39-50-APDU-1995;
PersistentQuery ::= CHOICE{
esRequest [1] IMPLICIT SEQUENCE{
toKeep [1] OriginPartToKeep OPTIONAL,
notToKeep [2] OriginPartNotToKeep},
taskPackage [2] IMPLICIT SEQUENCE{
originPart [1] OriginPartToKeep OPTIONAL,
targetPart [2] TargetPart}}
OriginPartToKeep ::= SEQUENCE{
dbNames [2] IMPLICIT SEQUENCE OF InternationalString
OPTIONAL,
additionalSearchInfo [3] OtherInformation OPTIONAL}
OriginPartNotToKeep ::= CHOICE{
package [1] IMPLICIT InternationalString,
query [2] Query}
TargetPart ::= Query
END
ESFormat-PeriodicQuerySchedule
{Z39-50-extendedService PeriodicQuerySchedule (3)} DEFINITIONS ::=
BEGIN
IMPORTS Query, InternationalString, IntUnit FROM Z39-50-APDU-1995
ExportSpecification, Destination FROM ESFormat-ExportSpecification;
PeriodicQuerySchedule ::= CHOICE{
esRequest [1] IMPLICIT SEQUENCE{
toKeep [1] OriginPartToKeep,
notToKeep [2] OriginPartNotToKeep},
taskPackage [2] IMPLICIT SEQUENCE{
originPart [1] OriginPartToKeep,
targetPart [2] TargetPart}}
OriginPartToKeep ::=SEQUENCE{
activeFlag [1] IMPLICIT BOOLEAN,
databaseNames [2] IMPLICIT SEQUENCE OF InternationalString
OPTIONAL,
resultSetDisposition [3] IMPLICIT INTEGER{
replace (1),
append (2),
createNew (3)
-- Only if origin and target have agreement
-- about naming convention for the resulting
-- package, and only if no resut set is
-- specified.
} OPTIONAL,
-- Mandatory on 'create' if result set is
-- specified, in which case it must be
-- 'replace' or 'append.
alertDestination [4] Destination OPTIONAL,
exportParameters [5] CHOICE{
packageName [1] IMPLICIT
InternationalString,
exportPackage [2] ExportSpecification}
OPTIONAL}
OriginPartNotToKeep ::= SEQUENCE{
querySpec [1] CHOICE{
actualQuery [1] Query,
packageName [2] IMPLICIT
InternationalString} OPTIONAL,
-- mandatory for 'create'
originSuggestedPeriod [2] Period OPTIONAL, -- mandatory for 'create'
expiration [3] IMPLICIT GeneralizedTime OPTIONAL,
resultSetPackage [4] IMPLICIT InternationalString OPTIONAL}
TargetPart ::= SEQUENCE{
actualQuery [1] Query,
targetStatedPeriod [2] Period,
-- Target supplies the period, which may be
-- same as origin proposed.
expiration [3] IMPLICIT GeneralizedTime OPTIONAL,
-- Target supplies value for task package. It
-- may be the same as origin proposed or
-- different from (and overrides) origin
-- proposal, but if omitted, there is no
-- expiration.
resultSetPackage [4] IMPLICIT InternationalString OPTIONAL,
-- May be omitted only if exportParameters was
-- supplied. Target supplies same name as
-- origin supplied, if origin did supply a
-- name.
lastQueryTime [5] IMPLICIT GeneralizedTime,
lastResultNumber [6] IMPLICIT INTEGER,
numberSinceModify [7] IMPLICIT INTEGER OPTIONAL}
Period ::= CHOICE{
unit [1] IMPLICIT IntUnit,
businessDaily [2] IMPLICIT NULL,
continuous [3] IMPLICIT NULL,
other [4] IMPLICIT InternationalString}
END
ESFormat-ItemOrder
{Z39-50-extendedService ItemOrder (4)} DEFINITIONS ::=
BEGIN
IMPORTS InternationalString FROM Z39-50-APDU-1995;
ItemOrder ::= CHOICE{
esRequest [1] IMPLICIT SEQUENCE{
toKeep [1] OriginPartToKeep OPTIONAL,
notToKeep [2] OriginPartNotToKeep},
taskPackage [2] IMPLICIT SEQUENCE{
originPart [1] OriginPartToKeep OPTIONAL,
targetPart [2] TargetPart}}
OriginPartToKeep ::= SEQUENCE{
supplDescription [1] IMPLICIT EXTERNAL OPTIONAL,
contact [2] IMPLICIT SEQUENCE{
name [1] IMPLICIT InternationalString OPTIONAL,
phone [2] IMPLICIT InternationalString OPTIONAL,
email [3] IMPLICIT InternationalString OPTIONAL}
OPTIONAL,
addlBilling [3] IMPLICIT SEQUENCE{
paymentMethod [1] CHOICE{
billInvoice [0] IMPLICIT NULL,
prepay [1] IMPLICIT NULL,
depositAccount [2] IMPLICIT NULL,
creditCard [3] IMPLICIT
CreditCardInfo,
cardInfoPreviouslySupplied [4] IMPLICIT NULL,
privateKnown [5] IMPLICIT NULL,
privateNotKnown [6] IMPLICIT
EXTERNAL},
customerReference [2] IMPLICITInternationalString
OPTIONAL,
customerPONumber [3] IMPLICITInternationalString
OPTIONAL} OPTIONAL}
CreditCardInfo ::= SEQUENCE{
nameOnCard [1] IMPLICIT InternationalString,
expirationDate [2] IMPLICIT InternationalString,
cardNumber [3] IMPLICIT InternationalString}
OriginPartNotToKeep ::= SEQUENCE{
-- Corresponds to 'requestedItem' in service
-- definition. Must supply at least one, and may
-- supply both.
resultSetItem [1] IMPLICIT SEQUENCE{
resultSetId [1] IMPLICIT InternationalString,
item [2] IMPLICIT INTEGER} OPTIONAL,
itemRequest [2] IMPLICIT EXTERNAL OPTIONAL
-- When itemRequest is an ILL-Request APDU,
-- use OID {iso standard 10161 abstract-syntax (2)
-- ill-apdus (1)}
}
TargetPart ::= SEQUENCE{
itemRequest [1] IMPLICIT EXTERNAL OPTIONAL,
-- When itemRequest is an ILL-Request APDU, use
-- OID 1.0.10161.2.1 (as above)
statusOrErrorReport [2] IMPLICIT EXTERNAL,
-- When statusOrErrorReport is an ILL
-- Status-Or-Error-Report APDU, use OID
-- 1.0.10161.2.1 (as above)
auxiliaryStatus [3] IMPLICIT INTEGER{
notReceived (1),
loanQueue (2),
forwarded (3),
unfilledCopyright (4),
filledCopyright (5)} OPTIONAL}
END
ESFormat-Update
{Z39-50-extendedService Update (5)} DEFINITIONS ::=
BEGIN
IMPORTS DiagRec, InternationalString FROM Z39-50-APDU-1995;
Update ::= CHOICE{
esRequest [1] IMPLICIT SEQUENCE{
toKeep [1] OriginPartToKeep,
notToKeep [2] OriginPartNotToKeep},
taskPackage [2] IMPLICIT SEQUENCE{
originPart [1] OriginPartToKeep,
targetPart [2] TargetPart}}
OriginPartToKeep ::= SEQUENCE{
action [1] IMPLICIT INTEGER{
recordInsert (1),
recordReplace (2),
recordDelete (3),
elementUpdate (4)},
databaseName [2] IMPLICIT InternationalString,
schema [3] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
elementSetName [4] IMPLICIT InternationalString OPTIONAL}
OriginPartNotToKeep ::= SuppliedRecords
TargetPart ::= SEQUENCE{
updateStatus [1] IMPLICIT INTEGER{
success (1),
partial (2),
failure (3)},
globalDiagnostics [2] IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
-- These are non-surrogate diagnostics relating
-- to the task, not to individual records.
taskPackageRecords [3] IMPLICIT SEQUENCE OF TaskPackageRecordStructure
-- There should be a TaskPackageRecordStructure
-- for every record supplied. The target should
-- create such a structure for every record
-- immediately upon creating the task package
-- to include correlation information and
-- status. The record itself would not be
-- included until processing for that record is
-- complete.
}
-- Auxiliary definitions for Update
SuppliedRecords ::= SEQUENCE OF SEQUENCE{
recordId [1] CHOICE{
number [1] IMPLICIT INTEGER,
string [2] IMPLICIT InternationalString,
opaque [3] IMPLICIT OCTET STRING} OPTIONAL,
supplementalId [2] CHOICE{
timeStamp [1] IMPLICIT GeneralizedTime,
versionNumber [2] IMPLICIT
InternationalString,
previousVersion [3] IMPLICIT EXTERNAL} OPTIONAL,
correlationInfo [3] IMPLICIT CorrelationInfo OPTIONAL,
record [4] IMPLICIT EXTERNAL}
CorrelationInfo ::= SEQUENCE{
-- origin may supply one or both for any record:
note [1] IMPLICIT InternationalString OPTIONAL,
id [2] IMPLICIT INTEGER OPTIONAL}
TaskPackageRecordStructure ::= SEQUENCE{
recordOrSurDiag [1] CHOICE {
record [1] IMPLICIT EXTERNAL,
-- Choose 'record' if
-- recordStatus is 'success',
-- and elementSetName was
-- supplied.
diagnostic [2] DiagRec
-- Choose 'diagnostic', if
-- RecordStatus is failure.
} OPTIONAL,
-- The parameter recordOrSurDiag will thus be
-- omitted only if 'elementSetName' was omitted
-- and recordStatus is 'success'; or if record
-- status is 'queued' or in 'process'.
correlationInfo [2] IMPLICIT CorrelationInfo OPTIONAL,
-- This should be included if it was supplied
-- by the origin.
recordStatus [3] IMPLICIT INTEGER{
success (1),
queued (2),
inProcess (3),
failure (4)}}
END
ESFormat-ExportSpecification
{Z39-50-extendedService ExportSpecification (6)} DEFINITIONS ::=
BEGIN
EXPORTS ExportSpecification, Destination; IMPORTS CompSpec,
InternationalString FROM Z39-50-APDU-1995;
ExportSpecification ::= CHOICE{
esRequest [1] IMPLICIT SEQUENCE{
toKeep [1] OriginPartToKeep,
notToKeep [2] IMPLICIT NULL},
taskPackage [2] IMPLICIT SEQUENCE{
originPart [1] OriginPartToKeep,
targetPart [2] IMPLICIT NULL}}
OriginPartToKeep ::= SEQUENCE{
composition [1] IMPLICIT CompSpec,
exportDestination [2] Destination}
Destination ::= CHOICE{
phoneNumber [1] IMPLICIT InternationalString,
faxNumber [2] IMPLICIT InternationalString,
x400address [3] IMPLICIT InternationalString,
emailAddress [4] IMPLICIT InternationalString,
pagerNumber [5] IMPLICIT InternationalString,
ftpAddress [6] IMPLICIT InternationalString,
ftamAddress [7] IMPLICIT InternationalString,
printerAddress [8] IMPLICIT InternationalString,
other [100] IMPLICIT SEQUENCE{
vehicle [1] IMPLICIT InternationalString
OPTIONAL,
destination [2] IMPLICIT InternationalString}}
END
ESFormat-ExportInvocation
{Z39-50-extendedService ExportInvocation (7)} DEFINITIONS ::=
BEGIN
IMPORTS InternationalString, IntUnit FROM Z39-50-APDU-1995
ExportSpecification FROM ESFormat-ExportSpecification;
ExportInvocation ::= CHOICE{
esRequest [1] IMPLICIT SEQUENCE{
toKeep [1] OriginPartToKeep,
notToKeep [2] OriginPartNotToKeep},
taskPackage [2] IMPLICIT SEQUENCE{
originPart [1] OriginPartToKeep,
targetPart [2] TargetPart OPTIONAL}}
OriginPartToKeep ::= SEQUENCE{
exportSpec [1] CHOICE{
packageName [1] IMPLICIT InternationalString,
packageSpec [2] ExportSpecification},
numberOfCopies [2] IMPLICIT INTEGER}
OriginPartNotToKeep ::= SEQUENCE{
resultSetId [1] IMPLICIT InternationalString,
records [2] CHOICE{
all [1] IMPLICIT NULL,
ranges [2] IMPLICIT SEQUENCE OF SEQUENCE{
start [1] IMPLICIT INTEGER,
count [2] IMPLICIT INTEGER OPTIONAL
-- Count may be omitted only on
-- last range, to indicate "all
-- remaining records beginning with
-- 'start'."
}}}
TargetPart ::= SEQUENCE{
estimatedQuantity [1] IMPLICIT IntUnit OPTIONAL,
quantitySoFar [2] IMPLICIT IntUnit OPTIONAL,
estimatedCost [3] IMPLICIT IntUnit OPTIONAL,
costSoFar [4] IMPLICIT IntUnit OPTIONAL}
END
UserInfoFormat-searchResult-1
{Z39-50-userInfoFormat searchResult-1 (1)} DEFINITIONS ::=
BEGIN
IMPORTS DatabaseName, Term, Query, IntUnit, InternationalString
FROM Z39-50-APDU-1995;
SearchInfoReport ::= SEQUENCE OF SEQUENCE{
subqueryId [1] IMPLICIT InternationalString OPTIONAL,
-- shorthand identifier of subquery
fullQuery [2] IMPLICIT BOOLEAN,
-- 'true' means this is the full query;
-- 'false', a sub-query
subqueryExpression [3] QueryExpression OPTIONAL,
-- A subquery of the query as submitted. May
-- be whole query; if so, "fullQuery" should
-- be 'true'.
subqueryInterpretation [4] QueryExpression OPTIONAL,
-- how target interpreted subquery
subqueryRecommendation [5] QueryExpression OPTIONAL,
-- target-recommended alternative
subqueryCount [6] IMPLICIT INTEGER OPTIONAL,
-- Number of records for this subQuery,
-- across all of the specified databases.
-- (If during search, via resource control,
-- number of records so far).
subqueryWeight [7] IMPLICIT IntUnit OPTIONAL,
-- relative weight of this subquery
resultsByDB [8] IMPLICIT ResultsByDB OPTIONAL}
ResultsByDB ::= SEQUENCE OF SEQUENCE{
databases [1] CHOICE{
all [1] IMPLICIT NULL,
-- applies across all of the databases in
-- Search PDU
list [2] IMPLICIT SEQUENCE OF DatabaseName
-- applies across all databases in this
-- list
},
count [2] IMPLICIT INTEGER OPTIONAL,
-- Number of records for query component (and, as
-- above, if during search, via resource control,
-- number of records so far).
resultSetName [3] IMPLICIT InternationalString OPTIONAL
-- Target-assigned result set by which subQuery is
-- available. Should not be provided unless
-- processing for this query component is concluded
-- (i.e., when this report comes during search, via
-- resource control, as opposed to after search, via
-- additionalSearchInfo).
}
QueryExpression ::= CHOICE {
term [1] IMPLICIT SEQUENCE{
queryTerm [1] Term,
termComment [2] IMPLICIT InternationalString OPTIONAL},
query [2] Query}
END
{Z39-50-elementSpec eSpec-1 (1)} DEFINITIONS ::=
BEGIN
IMPORTS Variant FROM RecordSyntax-generic
StringOrNumeric, InternationalString FROM Z39-50-APDU-1995;
--
Espec-1 ::= SEQUENCE{
elementSetNames [1] IMPLICIT SEQUENCE OF InternationalString
OPTIONAL,
-- Origin may include one or more element
-- set names, each specifying a set of
-- elements. Each of the elements is to be
-- treated as an elementRequest in the form
-- of simpleElement, where occurrence is 1.
defaultVariantSetId [2] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
-- If supplied, applies whenever
-- variantRequest does not include
-- variantSetId.
defaultVariantRequest [3] IMPLICIT Variant OPTIONAL,
-- If supplied, then for each simple
-- elementRequest that does not include a
-- variantRequest, the defaultVariantRequest
-- applies. (defaultVariantRequest does not
-- apply to a compositeRequest.)
defaultTagType [4] IMPLICIT INTEGER OPTIONAL,
-- If supplied, applies whenever 'tagType'
-- (within 'tag' within TagPath) is omitted.
elements [5] IMPLICIT SEQUENCE OF ElementRequest OPTIONAL}
--
ElementRequest::= CHOICE{
simpleElement [1] IMPLICIT SimpleElement,
compositeElement [2] IMPLICIT SEQUENCE{
elementList [1] CHOICE{
primitives [1] IMPLICIT SEQUENCE
OF InternationalString,
-- Origin may specify one or
-- more element set names, each
-- identifying a set of
-- elements, and the composite
-- element is the union.
specs [2] IMPLICIT SEQUENCE
OF SimpleElement},
deliveryTag [2] IMPLICIT TagPath,
-- DeliveryTag tagPath for
-- compositeElement may not
-- include wildThing or wildPath.
variantRequest [3] IMPLICIT Variant OPTIONAL}}
SimpleElement ::= SEQUENCE{
path [1] IMPLICIT TagPath,
variantRequest [2] IMPLICIT Variant OPTIONAL}
TagPath ::= SEQUENCE OF CHOICE{
specificTag [1] IMPLICIT SEQUENCE{
tagType [1] IMPLICIT INTEGER OPTIONAL,
-- If omitted, then 'defaultTagType'
-- (above) applies, if supplied, and
-- if not supplied, then default listed
-- in schema applies.
tagValue [2] StringOrNumeric,
occurrence [3] Occurrences OPTIONAL
-- default is "first occurrence"
},
wildThing [2] Occurrences,
-- Get Nth "thing" at this level, regardless of tag, for
-- each N specified by "Occurrences" (which may be 'all'
-- meaning match every element at this level). E.g., if
-- "Occurrences" is 3, get third element regardless of
-- its tag or the tag of the first two elements.
wildPath [3] IMPLICIT NULL
-- Match any tag, at this level or below, that is on a
-- path for which next tag in this TagPath sequence
-- occurs. WildPath may not be last member of the
-- TagPath sequence.
}
--
Occurrences ::= CHOICE{
all [1] IMPLICIT NULL,
last [2] IMPLICIT NULL,
values [3] IMPLICIT SEQUENCE{
start [1] IMPLICIT INTEGER,
-- if 'start' alone is included, then single
-- occurrence is requested
howMany [2] IMPLICIT INTEGER OPTIONAL
-- For example, if 'start' is 5 and
-- 'howMany' is 6, then request is for
-- "occurrences 5 through 10."
}}
END