z39.50/z3950v3.asn

   1 Z39-50-APDU-1995 -- OID for this definition, assigned in OID.3.1, is {Z39-50 2 1}
   2 DEFINITIONS ::=
   3 BEGIN   -- Z39.50 Maintenance Agency Official Text for ANSI/NISO Z39.50-1995 - July 1995
   4 --
   5 EXPORTS OtherInformation, Term, AttributeSetId, AttributeList, AttributeElement, ElementSetName, SortElement, DatabaseName,
   6 CompSpec, Specification, Permissions, InternationalString, IntUnit, Unit, StringOrNumeric, Query, Records, ResultSetId,
   7 DefaultDiagFormat, DiagRec;
   8 --
   9
  10 PDU ::= CHOICE{
  11  initRequest        [20] IMPLICIT InitializeRequest,
  12  initResponse      [21] IMPLICIT InitializeResponse,
  13  searchRequest      [22] IMPLICIT SearchRequest,
  14  searchResponse      [23] IMPLICIT SearchResponse,
  15  presentRequest      [24] IMPLICIT PresentRequest,
  16  presentResponse      [25] IMPLICIT PresentResponse,
  17  deleteResultSetRequest    [26] IMPLICIT DeleteResultSetRequest,
  18  deleteResultSetResponse    [27] IMPLICIT DeleteResultSetResponse,
  19  accessControlRequest    [28] IMPLICIT AccessControlRequest,
  20  accessControlResponse    [29] IMPLICIT AccessControlResponse,
  21  resourceControlRequest         [30] IMPLICIT ResourceControlRequest,
  22  resourceControlResponse    [31] IMPLICIT ResourceControlResponse,
  23  triggerResourceControlRequest  [32] IMPLICIT TriggerResourceControlRequest,
  24  resourceReportRequest          [33] IMPLICIT ResourceReportRequest,
  25  resourceReportResponse    [34] IMPLICIT ResourceReportResponse,
  26  scanRequest         [35] IMPLICIT ScanRequest,
  27  scanResponse      [36] IMPLICIT ScanResponse,
  28               -- [37] through [42] reserved
  29  sortRequest        [43] IMPLICIT SortRequest,
  30  sortResponse      [44] IMPLICIT SortResponse,
  31  segmentRequest      [45] IMPLICIT Segment,
  32  extendedServicesRequest    [46] IMPLICIT ExtendedServicesRequest,
  33  extendedServicesResponse    [47] IMPLICIT ExtendedServicesResponse,
  34  close          [48] IMPLICIT Close,
  35  duplicateDetectionRequest      [49] IMPLICIT DuplicateDetectionRequest,
  36  duplicateDetectionResponse     [50] IMPLICIT DuplicateDetectionResponse}
  37
  38
  39 -- Initialize APDUs
  40 --
  41   InitializeRequest ::= SEQUENCE{
  42   referenceId        ReferenceId OPTIONAL,
  43   protocolVersion      ProtocolVersion,
  44   options        Options,
  45   preferredMessageSize  [5]  IMPLICIT INTEGER,
  46    exceptionalRecordSize  [6]  IMPLICIT INTEGER,
  47    idAuthentication    [7]    IdAuthentication OPTIONAL, -- see note below
  48   implementationId    [110]  IMPLICIT InternationalString OPTIONAL,
  49   implementationName  [111]  IMPLICIT InternationalString OPTIONAL,
  50    implementationVersion  [112]  IMPLICIT InternationalString OPTIONAL,
  51   userInformationField  [11]  EXTERNAL OPTIONAL,
  52   otherInfo        OtherInformation OPTIONAL}
  53 --Note:
  54 -- For idAuthentication, the type ANY is retained for compatibility with earlier versions.
  55 -- For interoperability, the following is recommended:
  56 IdAuthentication ::=
  57    CHOICE{
  58       open   VisibleString,
  59       idPass  SEQUENCE {
  60       groupId  [0]  IMPLICIT InternationalString OPTIONAL,
  61       userId   [1]  IMPLICIT InternationalString OPTIONAL,
  62       password  [2]  IMPLICIT InternationalString OPTIONAL },
  63       anonymous  NULL,
  64       other    EXTERNAL
  65    }
  66 -- May use access control formats for 'other'.  See Appendix 7 ACC.
  67 --
  68   InitializeResponse ::= SEQUENCE{
  69   referenceId        ReferenceId OPTIONAL,
  70    protocolVersion                ProtocolVersion,
  71   options              Options,
  72   preferredMessageSize  [5]  IMPLICIT INTEGER,
  73    exceptionalRecordSize  [6]  IMPLICIT INTEGER,
  74   result        [12]  IMPLICIT BOOLEAN,    -- reject = FALSE; Accept = TRUE
  75   implementationId    [110]  IMPLICIT InternationalString OPTIONAL,
  76   implementationName  [111]  IMPLICIT InternationalString OPTIONAL,
  77    implementationVersion  [112]  IMPLICIT InternationalString OPTIONAL,
  78   userInformationField  [11]  EXTERNAL OPTIONAL,
  79   otherInfo        OtherInformation OPTIONAL}
  80 -- Begin auxiliary definitions for Init PDUs
  81   ProtocolVersion  ::=  [3]   IMPLICIT BIT STRING{
  82     version-1      (0),       -- This bit should always be set, but does not
  83               -- correspond to any Z39.50 version.
  84     version-2      (1),              -- "Version 2 supported."
  85               -- This bit should always be set.
  86     version-3      (2)        -- "Version 3 supported."
  87 -- Values higher than 'version-3' should be ignored. Both the Initialize request and Initialize Response APDUs
  88 -- include a value string corresponding to the supported versions. The highest common version is selected
  89 -- for use. If there are no versions in common, "Result" in the Init Response should indicate "reject."
  90 -- Note: Versions 1 and 2 are identical. Systems supporting version 2 should indicate support for version
  91 -- 1 as well, for interoperability with systems that indicate support for version 1 only (e.g. ISO 10163-1991
  92 -- implementations).
  93   }
  94   Options  ::= [4] IMPLICIT BIT STRING{
  95       search        (0),
  96       present       (1),
  97       delSet        (2),
  98        resourceReport    (3),
  99       triggerResourceCtrl    (4),
 100       resourceCtrl       (5),
 101       accessCtrl       (6),
 102       scan         (7),
 103       sort        (8),
 104       --        (9) (reserved)
 105       extendedServices    (10),
 106       level-1Segmentation    (11),
 107       level-2Segmentation    (12),
 108       concurrentOperations  (13),
 109       namedResultSets    (14),
 110       encapsulation    (15),
 111       resultCount    (16),
 112       negotiationModel    (17),
 113       duplicateDetection    (18),
 114       queryType104    (19)}
 115 -- end auxiliary definitions for Init PDUs
 116
 117
 118 --Search APDUs
 119   SearchRequest ::= SEQUENCE{
 120   referenceId          ReferenceId OPTIONAL,
 121       smallSetUpperBound    [13]  IMPLICIT INTEGER,
 122   largeSetLowerBound    [14]  IMPLICIT INTEGER,
 123   mediumSetPresentNumber    [15]  IMPLICIT INTEGER,
 124   replaceIndicator      [16]  IMPLICIT BOOLEAN,
 125   resultSetName      [17]  IMPLICIT InternationalString,
 126    databaseNames      [18]   IMPLICIT SEQUENCE OF DatabaseName,
 127    smallSetElementSetNames    [100]  ElementSetNames OPTIONAL,
 128     mediumSetElementSetNames  [101]  ElementSetNames OPTIONAL,
 129   preferredRecordSyntax    [104]  IMPLICIT OBJECT IDENTIFIER OPTIONAL,
 130   query          [21]  Query,
 131     -- Following two parameters may be used only if version 3 is in force.
 132    additionalSearchInfo    [203]  IMPLICIT OtherInformation OPTIONAL,
 133   otherInfo          OtherInformation OPTIONAL}
 134
 135
 136 -- Query Definitions
 137   Query  ::=  CHOICE{
 138       type-0  [0]  ANY,
 139         type-1    [1]  IMPLICIT RPNQuery,
 140         type-2      [2]  OCTET STRING,
 141         type-100  [100]  OCTET STRING,
 142         type-101  [101]  IMPLICIT RPNQuery,
 143        type-102  [102]  OCTET STRING,
 144        type-104  [104]  IMPLICIT EXTERNAL
 145 }
 146 --
 147 -- Definitions for RPN query
 148      RPNQuery ::= SEQUENCE{
 149       attributeSet    AttributeSetId,
 150       rpn      RPNStructure}
 151 --
 152   RPNStructure ::= CHOICE{
 153     op    [0] Operand,
 154      rpnRpnOp  [1] IMPLICIT SEQUENCE{
 155           rpn1    RPNStructure,
 156                 rpn2    RPNStructure,
 157                 op    Operator }}
 158   Operand ::= CHOICE{
 159     attrTerm  AttributesPlusTerm,
 160     resultSet  ResultSetId,
 161           -- If version 2 is in force:
 162           --   - If query type is 1, one of the above two must be chosen;
 163           --   - resultAttr (below) may be used only if query type is 101.
 164     resultAttr  ResultSetPlusAttributes}
 165
 166   AttributesPlusTerm ::= [102] IMPLICIT SEQUENCE{
 167          attributes  AttributeList,
 168         term    Term}
 169   ResultSetPlusAttributes ::= [214] IMPLICIT SEQUENCE{
 170         resultSet  ResultSetId,
 171         attributes  AttributeList}
 172   AttributeList ::=    [44]  IMPLICIT SEQUENCE OF AttributeElement
 173 --
 174   Term ::= CHOICE{
 175     general      [45]  IMPLICIT OCTET STRING,
 176               -- values below may be used only if version 3 is in force
 177     numeric      [215]  IMPLICIT INTEGER,
 178     characterString    [216]  IMPLICIT InternationalString,
 179     oid        [217]  IMPLICIT OBJECT IDENTIFIER,
 180     dateTime      [218]  IMPLICIT GeneralizedTime,
 181     external      [219]  IMPLICIT EXTERNAL,
 182     integerAndUnit    [220] IMPLICIT IntUnit,
 183     null        [221] IMPLICIT NULL}
 184
 185   Operator ::= [46] CHOICE{
 186          and    [0] IMPLICIT NULL,
 187             or    [1] IMPLICIT NULL,
 188                 and-not  [2] IMPLICIT NULL,
 189               -- If version 2 is in force:
 190               --  - For query type 1, one of the above three must be chosen;
 191               --  - prox (below) may be used only if query type is 101.
 192         prox    [3] IMPLICIT ProximityOperator}
 193   AttributeElement  ::=  SEQUENCE{
 194     attributeSet    [1]    IMPLICIT AttributeSetId OPTIONAL,
 195                 -- Must be omitted if version 2 is in force.
 196                 -- If included, overrides value of attributeSet
 197                 -- in RPNQuery above, but only for this attribute.
 198     attributeType  [120]  IMPLICIT INTEGER,
 199     attributeValue    CHOICE{
 200               numeric  [121]   IMPLICIT INTEGER,
 201                   -- If version 2 is in force,
 202                   -- Must select 'numeric' for attributeValue.
 203
 204       complex  [224] IMPLICIT SEQUENCE{
 205                list      [1] IMPLICIT SEQUENCE OF StringOrNumeric,
 206                     semanticAction  [2] IMPLICIT SEQUENCE OF INTEGER OPTIONAL}}}
 207
 208
 209   ProximityOperator ::= SEQUENCE{
 210     exclusion      [1] IMPLICIT BOOLEAN OPTIONAL,
 211     distance      [2] IMPLICIT INTEGER,
 212     ordered      [3] IMPLICIT BOOLEAN,
 213     relationType      [4] IMPLICIT INTEGER{
 214               lessThan      (1),
 215               lessThanOrEqual    (2),
 216               equal        (3),
 217               greaterThanOrEqual    (4),
 218               greaterThan      (5),
 219               notEqual      (6)},
 220     proximityUnitCode    [5] CHOICE{
 221               known  [1] IMPLICIT KnownProximityUnit,
 222               private  [2] IMPLICIT INTEGER}}
 223 --
 224     KnownProximityUnit ::= INTEGER{
 225           character  (1),
 226           word     (2),
 227           sentence   (3),
 228           paragraph   (4),
 229           section   (5),
 230           chapter   (6),
 231           document   (7),
 232           element  (8),
 233           subelement  (9),
 234           elementType  (10),
 235            byte    (11) -- Version 3 only
 236           }
 237 -- End definitions for RPN Query
 238
 239
 240 SearchResponse ::= SEQUENCE{
 241   referenceId        ReferenceId OPTIONAL,
 242   resultCount       [23]  IMPLICIT INTEGER,
 243   numberOfRecordsReturned  [24]  IMPLICIT INTEGER,
 244   nextResultSetPosition  [25]  IMPLICIT INTEGER,
 245   searchStatus      [22]  IMPLICIT BOOLEAN,
 246   resultSetStatus    [26]  IMPLICIT INTEGER{
 247               subset    (1),
 248                  interim  (2),
 249                none    (3)} OPTIONAL,
 250   presentStatus        PresentStatus  OPTIONAL,
 251     records        Records OPTIONAL,
 252     -- Following two parameters may be used only if version 3 is in force.
 253   additionalSearchInfo  [203]  IMPLICIT OtherInformation OPTIONAL,
 254   otherInfo        OtherInformation OPTIONAL}
 255 --Retrieval APDUs
 256   PresentRequest ::= SEQUENCE{
 257   referenceId          ReferenceId OPTIONAL,
 258       resultSetId          ResultSetId,
 259   resultSetStartPoint      [30]  IMPLICIT INTEGER,
 260   numberOfRecordsRequested  [29]  IMPLICIT INTEGER,
 261   additionalRanges      [212]  IMPLICIT SEQUENCE OF Range OPTIONAL,
 262       -- additionalRanges may be included only if version 3 is in force.
 263   recordComposition      CHOICE{
 264                 simple  [19]         ElementSetNames,
 265                 -- must choose 'simple' if version 2 is in force
 266                 complex  [209]               IMPLICIT CompSpec} OPTIONAL,
 267   preferredRecordSyntax    [104]  IMPLICIT OBJECT IDENTIFIER OPTIONAL,
 268   maxSegmentCount      [204]  IMPLICIT INTEGER OPTIONAL, -- level 1 or 2
 269   maxRecordSize      [206]  IMPLICIT INTEGER OPTIONAL, -- level 2 only
 270   maxSegmentSize      [207]  IMPLICIT INTEGER OPTIONAL, -- level 2 only
 271   otherInfo          OtherInformation OPTIONAL}
 272 --
 273   Segment ::= SEQUENCE{
 274       -- Segment PDU may only be used when version 3 is in force,
 275       -- and only when segmentation is in effect.
 276    referenceId          ReferenceId OPTIONAL,
 277      numberOfRecordsReturned    [24]  IMPLICIT INTEGER,
 278   segmentRecords      [0]  IMPLICIT SEQUENCE OF NamePlusRecord,
 279   otherInfo          OtherInformation OPTIONAL}
 280 --
 281   PresentResponse ::= SEQUENCE{
 282   referenceId          ReferenceId OPTIONAL,
 283   numberOfRecordsReturned    [24]  IMPLICIT INTEGER,
 284    nextResultSetPosition    [25]  IMPLICIT INTEGER,
 285     presentStatus          PresentStatus,
 286   records          Records OPTIONAL,
 287   otherInfo          OtherInformation OPTIONAL}
 288 -- begin auxiliary definitions for Search and Present APDUs
 289
 290 -- begin definition of records
 291   Records ::= CHOICE{
 292   responseRecords      [28]  IMPLICIT SEQUENCE OF NamePlusRecord,
 293   nonSurrogateDiagnostic     [130]  IMPLICIT DefaultDiagFormat,
 294   multipleNonSurDiagnostics   [205]  IMPLICIT SEQUENCE OF DiagRec}
 295 --
 296   NamePlusRecord  ::=  SEQUENCE{
 297   name    [0] IMPLICIT DatabaseName OPTIONAL,
 298   record  [1] CHOICE{
 299         retrievalRecord        [1] EXTERNAL,
 300         surrogateDiagnostic    [2] DiagRec,
 301           -- Must select one of the above two, retrievalRecord or
 302           -- surrogateDiagnostic, unless 'level 2 segmentation' is in effect.
 303         startingFragment    [3] FragmentSyntax,
 304         intermediateFragment  [4] FragmentSyntax,
 305         finalFragment    [5] FragmentSyntax}}
 306   FragmentSyntax ::= CHOICE{
 307     externallyTagged    EXTERNAL,
 308     notExternallyTagged  OCTET STRING}
 309
 310   DiagRec ::= CHOICE{
 311       defaultFormat    DefaultDiagFormat,
 312                 -- Must choose defaultFormat if version 2 is in effect.
 313       externallyDefined    EXTERNAL}
 314
 315   DefaultDiagFormat::= SEQUENCE{
 316   diagnosticSetId  OBJECT IDENTIFIER,
 317   condition    INTEGER,
 318   addinfo      CHOICE{
 319            v2Addinfo  VisibleString,  -- version 2
 320            v3Addinfo  InternationalString  -- version 3
 321             }}
 322   -- end definition of records
 323   Range  ::= SEQUENCE{
 324     startingPosition    [1] IMPLICIT INTEGER,
 325     numberOfRecords    [2] IMPLICIT INTEGER}
 326 --
 327   ElementSetNames ::= CHOICE {
 328     genericElementSetName  [0] IMPLICIT InternationalString,
 329     databaseSpecific    [1] IMPLICIT SEQUENCE OF SEQUENCE{
 330               dbName  DatabaseName,
 331               esn    ElementSetName}}
 332
 333   PresentStatus   ::=    [27]  IMPLICIT INTEGER{
 334                             success  (0),
 335                              partial-1   (1),
 336                               partial-2   (2),
 337               partial-3   (3),
 338                                       partial-4   (4),
 339                                failure    (5)}
 340
 341 -- begin definition of composition specification
 342   CompSpec ::= SEQUENCE{
 343   selectAlternativeSyntax  [1] IMPLICIT BOOLEAN,
 344             -- See comment for recordSyntax, below.
 345   generic             [2] IMPLICIT Specification OPTIONAL,
 346   dbSpecific      [3] IMPLICIT SEQUENCE OF SEQUENCE{
 347                 db  [1] DatabaseName,
 348                 spec  [2] IMPLICIT Specification} OPTIONAL,
 349     -- At least one of generic and dbSpecific must occur, and both may occur. If both, then for
 350      -- any record not in the list of databases within dbSpecific, generic applies.
 351    recordSyntax               [4] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL
 352                -- For each record, the target selects the first record syntax
 353                -- in this list that it can support.  If the list is exhausted, the
 354                -- target may select an alternative syntax if
 355                -- selectAlternativeSyntax is 'true'.
 356         }
 357   Specification ::= SEQUENCE{
 358   schema    [1] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
 359   elementSpec    [2] CHOICE{
 360               elementSetName   [1] IMPLICIT InternationalString,
 361           externalEspec  [2] IMPLICIT EXTERNAL} OPTIONAL}
 362 -- end definition of composition specification
 363 -- end auxiliary definitions for search and response APDUs
 364
 365 -- Delete APDUs
 366   DeleteResultSetRequest ::= SEQUENCE{
 367   referenceId          ReferenceId OPTIONAL,
 368       deleteFunction      [32]  IMPLICIT INTEGER{
 369                     list   (0),
 370                     all   (1)},
 371    resultSetList          SEQUENCE OF ResultSetId OPTIONAL,
 372   otherInfo          OtherInformation OPTIONAL}
 373 --
 374   DeleteResultSetResponse ::= SEQUENCE{
 375   referenceId          ReferenceId OPTIONAL,
 376     deleteOperationStatus    [0]  IMPLICIT DeleteSetStatus,
 377   deleteListStatuses      [1]  IMPLICIT ListStatuses OPTIONAL,
 378   numberNotDeleted       [34]  IMPLICIT INTEGER OPTIONAL,
 379      bulkStatuses        [35]   IMPLICIT ListStatuses OPTIONAL,
 380    deleteMessage      [36]  IMPLICIT InternationalString OPTIONAL,
 381   otherInfo          OtherInformation OPTIONAL}
 382   ListStatuses ::= SEQUENCE OF SEQUENCE{
 383         id  ResultSetId,
 384         status  DeleteSetStatus}
 385
 386   DeleteSetStatus ::= [33] IMPLICIT INTEGER{
 387                   success          (0),
 388                    resultSetDidNotExist      (1),
 389                     previouslyDeletedByTarget      (2),
 390                      systemProblemAtTarget      (3),
 391                    accessNotAllowed        (4),
 392       resourceControlAtOrigin      (5),
 393                    resourceControlAtTarget      (6),
 394                     bulkDeleteNotSupported      (7),
 395                    notAllRsltSetsDeletedOnBulkDlte    (8),
 396       notAllRequestedResultSetsDeleted    (9),
 397       resultSetInUse        (10)}
 398 --
 399
 400 --Access- and Resource-control APDUs
 401 --
 402   AccessControlRequest ::= SEQUENCE{
 403   referenceId        ReferenceId OPTIONAL,
 404   securityChallenge      CHOICE{
 405               simpleForm      [37] IMPLICIT OCTET STRING,
 406                externallyDefined    [0]  EXTERNAL},
 407   otherInfo        OtherInformation OPTIONAL}
 408
 409   AccessControlResponse ::= SEQUENCE{
 410   referenceId        ReferenceId OPTIONAL,
 411   securityChallengeResponse  CHOICE{
 412               simpleForm      [38]   IMPLICIT OCTET STRING,
 413                externallyDefined    [0]  EXTERNAL} OPTIONAL,
 414               -- Optional only in version 3; mandatory in version 2. If
 415               -- omitted (in version 3) then diagnostic must occur.
 416   diagnostic    [223]    DiagRec OPTIONAL, -- Version 3 only.
 417   otherInfo        OtherInformation OPTIONAL}
 418
 419
 420
 421   ResourceControlRequest ::= SEQUENCE{
 422   referenceId          ReferenceId OPTIONAL,
 423   suspendedFlag      [39]  IMPLICIT BOOLEAN OPTIONAL,
 424   resourceReport      [40]  ResourceReport OPTIONAL,
 425   partialResultsAvailable    [41]  IMPLICIT INTEGER{
 426                 subset    (1),
 427                 interim  (2),
 428                 none    (3)} OPTIONAL,
 429   responseRequired      [42]   IMPLICIT BOOLEAN,
 430   triggeredRequestFlag    [43]   IMPLICIT BOOLEAN OPTIONAL,
 431   otherInfo          OtherInformation OPTIONAL}
 432
 433
 434   ResourceControlResponse ::= SEQUENCE{
 435      referenceId          ReferenceId OPTIONAL,
 436     continueFlag       [44]   IMPLICIT BOOLEAN,
 437   resultSetWanted      [45]  IMPLICIT BOOLEAN OPTIONAL,
 438   otherInfo          OtherInformation OPTIONAL}
 439
 440
 441
 442   TriggerResourceControlRequest ::= SEQUENCE{
 443      referenceId          ReferenceId OPTIONAL,
 444   requestedAction      [46]  IMPLICIT INTEGER{
 445                 resourceReport  (1),
 446                 resourceControl  (2),
 447                 cancel      (3)},
 448   prefResourceReportFormat    [47]   IMPLICIT ResourceReportId OPTIONAL,
 449   resultSetWanted      [48]   IMPLICIT BOOLEAN OPTIONAL,
 450   otherInfo          OtherInformation OPTIONAL}
 451
 452
 453
 454   ResourceReportRequest ::= SEQUENCE{
 455      referenceId          ReferenceId OPTIONAL,
 456   opId          [210]  IMPLICIT ReferenceId OPTIONAL,
 457   prefResourceReportFormat    [49]   IMPLICIT ResourceReportId OPTIONAL,
 458   otherInfo          OtherInformation OPTIONAL}
 459 --
 460   ResourceReportResponse ::= SEQUENCE{
 461      referenceId          ReferenceId OPTIONAL,
 462   resourceReportStatus    [50]   IMPLICIT INTEGER{
 463                 success    (0),
 464                 partial    (1),
 465                 failure-1    (2),
 466                 failure-2    (3),
 467                 failure-3    (4),
 468                 failure-4    (5),
 469                 failure-5    (6),
 470                 failure-6    (7)},
 471   resourceReport               [51]   ResourceReport OPTIONAL,
 472   otherInfo          OtherInformation OPTIONAL}
 473 --
 474    ResourceReport     ::=   EXTERNAL
 475   ResourceReportId    ::=    OBJECT IDENTIFIER
 476
 477 --Scan APDUs
 478   ScanRequest ::= SEQUENCE{
 479   referenceId              ReferenceId OPTIONAL,
 480     databaseNames        [3]  IMPLICIT SEQUENCE OF DatabaseName,
 481     attributeSet            AttributeSetId OPTIONAL,
 482     termListAndStartPoint        AttributesPlusTerm,
 483     stepSize           [5]   IMPLICIT INTEGER OPTIONAL,
 484     numberOfTermsRequested         [6]   IMPLICIT INTEGER,
 485     preferredPositionInResponse      [7]   IMPLICIT INTEGER OPTIONAL,
 486     otherInfo            OtherInformation OPTIONAL}
 487
 488   ScanResponse ::= SEQUENCE{
 489    referenceId              ReferenceId OPTIONAL,
 490    stepSize           [3]  IMPLICIT INTEGER OPTIONAL,
 491    scanStatus           [4]  IMPLICIT INTEGER {
 492                                 success   (0),
 493                                 partial-1   (1),
 494                                 partial-2   (2),
 495                                 partial-3   (3),
 496                                 partial-4   (4),
 497                                 partial-5   (5),
 498                                 failure  (6) },
 499    numberOfEntriesReturned       [5]  IMPLICIT INTEGER,
 500    positionOfTerm         [6]  IMPLICIT INTEGER OPTIONAL,
 501    entries           [7]  IMPLICIT ListEntries  OPTIONAL,
 502    attributeSet          [8]  IMPLICIT AttributeSetId OPTIONAL,
 503    otherInfo            OtherInformation OPTIONAL}
 504
 505 -- begin auxiliary definitions for Scan
 506   ListEntries ::= SEQUENCE{
 507   entries        [1]   IMPLICIT SEQUENCE OF Entry OPTIONAL,
 508     nonsurrogateDiagnostics    [2]  IMPLICIT SEQUENCE OF DiagRec OPTIONAL
 509     -- At least one of entries and nonsurrogateDiagnostics must occur
 510           }
 511
 512   Entry  ::= CHOICE {
 513      termInfo               [1]   IMPLICIT TermInfo,
 514      surrogateDiagnostic    [2]   DiagRec}
 515 --
 516   TermInfo ::= SEQUENCE {
 517    term                    Term,
 518      displayTerm      [0]   IMPLICIT InternationalString OPTIONAL,
 519                                      -- Presence of displayTerm means that term is not considered by
 520               -- the target to be suitable for display, and displayTerm should
 521               -- instead be displayed. 'term' is the actual term in the term list;
 522                -- 'displayTerm' is for display purposes only, and is not an actual
 523               -- term in the term list.
 524   suggestedAttributes            AttributeList OPTIONAL,
 525      alternativeTerm    [4]  IMPLICIT SEQUENCE OF AttributesPlusTerm OPTIONAL,
 526      globalOccurrences    [2]  IMPLICIT INTEGER OPTIONAL,
 527      byAttributes      [3]  IMPLICIT OccurrenceByAttributes OPTIONAL,
 528      otherTermInfo      OtherInformation OPTIONAL}
 529
 530   OccurrenceByAttributes ::= SEQUENCE OF SEQUENCE{
 531      attributes    [1]  AttributeList,
 532      occurrences       CHOICE{
 533                global    [2] INTEGER,
 534             byDatabase  [3] IMPLICIT SEQUENCE OF SEQUENCE{
 535               db      DatabaseName,
 536               num     [1]  IMPLICIT INTEGER OPTIONAL,
 537               otherDbInfo    OtherInformation OPTIONAL}} OPTIONAL,
 538      otherOccurInfo    OtherInformation OPTIONAL}
 539 -- end auxiliary definitions for Scan
 540
 541 -- Sort APDUs
 542 SortRequest  ::= SEQUENCE{
 543   referenceId              ReferenceId OPTIONAL,
 544   inputResultSetNames  [3]  IMPLICIT SEQUENCE OF InternationalString,
 545   sortedResultSetName  [4]    IMPLICIT InternationalString,
 546   sortSequence     [5]  IMPLICIT SEQUENCE OF SortKeySpec,
 547               -- order of occurrence is from major to minor
 548   otherInfo        OtherInformation OPTIONAL}
 549
 550 SortResponse  ::= SEQUENCE{
 551   referenceId          ReferenceId OPTIONAL,
 552   sortStatus         [3]  IMPLICIT INTEGER{
 553                             success  (0),
 554               partial-1  (1),
 555               failure  (2)},
 556   resultSetStatus    [4]  IMPLICIT INTEGER{
 557               empty    (1),
 558                   interim  (2),
 559                   unchanged  (3),
 560               none    (4)} OPTIONAL,
 561   diagnostics        [5]             IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
 562   otherInfo        OtherInformation OPTIONAL}
 563
 564 -- begin auxiliary definitions for Sort
 565   SortKeySpec ::= SEQUENCE{
 566     sortElement      SortElement,
 567        sortRelation    [1]  IMPLICIT INTEGER{
 568                                 ascending      (0),
 569               descending      (1),
 570               ascendingByFrequency    (3),
 571               descendingByfrequency  (4)},
 572       caseSensitivity    [2]   IMPLICIT INTEGER{
 573                                  caseSensitive      (0),
 574               caseInsensitive    (1)},
 575       missingValueAction    [3]   CHOICE{
 576                                      abort    [1] IMPLICIT NULL,
 577                                      null      [2] IMPLICIT NULL,
 578                     --supply a null value for missing value
 579           missingValueData  [3] IMPLICIT OCTET STRING} OPTIONAL}
 580
 581   SortElement ::=   CHOICE{
 582     generic        [1] SortKey,
 583        datbaseSpecific    [2] IMPLICIT SEQUENCE OF SEQUENCE{
 584                        databaseName  DatabaseName,
 585                        dbSort    SortKey}}
 586
 587   SortKey ::= CHOICE{
 588     sortfield       [0]  IMPLICIT InternationalString,
 589                   -- An element, element-group-tag, or alias supported by the target
 590                -- and denoting a set of elements associated with each record.
 591      elementSpec    [1]  IMPLICIT Specification,
 592         sortAttributes    [2]  IMPLICIT SEQUENCE{
 593               id  AttributeSetId,
 594               list  AttributeList}}
 595 -- end auxiliary definitions for sort
 596
 597
 598
 599 -- Extended Service APDUs
 600   ExtendedServicesRequest  ::= SEQUENCE{
 601   referenceId              ReferenceId OPTIONAL,
 602   function      [3]  IMPLICIT INTEGER {
 603               create    (1),
 604               delete    (2),
 605               modify  (3)},
 606   packageType      [4]  IMPLICIT OBJECT IDENTIFIER,
 607   packageName    [5]  IMPLICIT InternationalString OPTIONAL,
 608               -- PackageName mandatory for 'modify' or 'delete'; optional for
 609               -- 'create'. Following four parameters mandatory for 'create'; should
 610               -- be included on 'modify' if being modified; not needed on 'delete'.
 611   userId        [6]   IMPLICIT InternationalString OPTIONAL,
 612   retentionTime    [7]   IMPLICIT IntUnit OPTIONAL,
 613   permissions      [8]   IMPLICIT Permissions OPTIONAL,
 614   description      [9]   IMPLICIT InternationalString OPTIONAL,
 615
 616 -- (ExtendedServiceRequest APDU continued)
 617   taskSpecificParameters  [10]  IMPLICIT EXTERNAL OPTIONAL,
 618               -- Mandatory for 'create'; included on 'modify' if specific
 619               -- parameters being modified; not necessary on 'delete'. For the
 620               -- 'EXTERNAL,' use OID of specific ES definition and select
 621               --  CHOICE [1]: 'esRequest'.
 622   waitAction      [11]  IMPLICIT INTEGER{
 623               wait      (1),
 624               waitIfPossible  (2),
 625               dontWait    (3),
 626               dontReturnPackage  (4)},
 627   elements          ElementSetName OPTIONAL,
 628   otherInfo          OtherInformation OPTIONAL}
 629 --
 630
 631 ExtendedServicesResponse ::= SEQUENCE{
 632   referenceId                ReferenceId OPTIONAL,
 633   operationStatus    [3]    IMPLICIT INTEGER{
 634                 done      (1),
 635                 accepted    (2),
 636                 failure    (3)},
 637   diagnostics      [4]    IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
 638   taskPackage      [5]    IMPLICIT EXTERNAL OPTIONAL,
 639                 -- Use OID: {Z39-50-recordSyntax (106)} and corresponding
 640                 -- syntax. For the EXTERNAL, 'taskSpecific,' within that
 641                 -- definition, use OID of the specific es, and choose [2],
 642                 -- 'taskPackage'.
 643   otherInfo          OtherInformation OPTIONAL}
 644
 645  Permissions ::= SEQUENCE OF SEQUENCE{
 646   userId      [1] IMPLICIT InternationalString,
 647   allowableFunctions  [2] IMPLICIT SEQUENCE OF INTEGER{
 648               delete      (1),
 649               modifyContents  (2),
 650               modifyPermissions  (3),
 651               present    (4),
 652                  invoke    (5)}}
 653
 654 Close ::= SEQUENCE{
 655   referenceId          ReferenceId OPTIONAL,  -- See 3.2.11.1.5.
 656   closeReason          CloseReason,
 657   diagnosticInformation    [3]  IMPLICIT InternationalString OPTIONAL,
 658   resourceReportFormat    [4]  IMPLICIT ResourceReportId OPTIONAL,
 659                 -- For use by origin only, and only on Close request;
 660                 -- origin requests target to include report in response.
 661    resourceReport      [5]  ResourceReport OPTIONAL,
 662                 -- For use by target only, unilaterally on Close request;
 663                 -- on Close response may be unilateral or in response
 664                 -- to origin request.
 665   otherInfo          OtherInformation OPTIONAL}
 666
 667   CloseReason ::=  [211]  IMPLICIT INTEGER{
 668             finished      (0),
 669             shutdown      (1),
 670             systemProblem    (2),
 671             costLimit      (3),
 672             resources      (4),
 673             securityViolation    (5),
 674             protocolError    (6),
 675             lackOfActivity    (7),
 676             peerAbort      (8),
 677             unspecified      (9)}
 678
 679 --Duplicate detection APDUs
 680 DuplicateDetectionRequest ::= SEQUENCE {
 681   referenceId                      ReferenceId  OPTIONAL,
 682   inputResultSetIds            [3] IMPLICIT SEQUENCE OF InternationalString,
 683   outputResultSetName          [4] IMPLICIT InternationalString,
 684   applicablePortionOfRecord    [5] IMPLICIT EXTERNAL OPTIONAL,
 685   duplicateDetectionCriteria   [6] IMPLICIT SEQUENCE OF
 686                                    DuplicateDetectionCriterion OPTIONAL,
 687   clustering                   [7] IMPLICIT BOOLEAN OPTIONAL,
 688                                         -- 'true' means "clustered".
 689                                         -- This parameter may be omitted
 690                                         -- only if retentionCriteria CHOICE is
 691                                         -- 'numberOfEntries' and its value is 1.
 692   retentionCriteria            [8] IMPLICIT SEQUENCE OF
 693                                             RetentionCriterion,
 694   sortCriteria                 [9] IMPLICIT SEQUENCE OF
 695                                             SortCriterion OPTIONAL,
 696   otherInfo                        OtherInformation OPTIONAL}
 697
 698 DuplicateDetectionCriterion ::= CHOICE{
 699                            levelOfMatch         [1] IMPLICIT INTEGER,
 700                                 -- a percentage; 1-100.
 701                            caseSensitive        [2] IMPLICIT NULL,
 702                            punctuationSensitive [3] IMPLICIT NULL,
 703                            regularExpression    [4] IMPLICIT EXTERNAL,
 704                            rsDuplicates         [5] IMPLICIT NULL
 705                  -- values 6-100 reserved for future assignment.
 706                                                        }
 707
 708 RetentionCriterion ::= CHOICE{
 709                           numberOfEntries       [1] IMPLICIT INTEGER,
 710                                                         --  greater than 0
 711                           percentOfEntries      [2] IMPLICIT INTEGER,
 712                                                         -- 1-100,
 713                           duplicatesOnly        [3] IMPLICIT NULL,
 714                                                  -- should not be chosen
 715                                                  -- if clustering is 'true'
 716                           discardRsDuplicates   [4] IMPLICIT NULL
 717                  -- values 5-100 reserved for future assignment.
 718                                                        }
 719
 720 SortCriterion ::= CHOICE{
 721                          mostComprehensive      [1] IMPLICIT NULL,
 722                          leastConmprehensive    [2] IMPLICIT NULL,
 723                          mostRecent             [3] IMPLICIT NULL,
 724                          oldest                 [4] IMPLICIT NULL,
 725                          leastCost              [5] IMPLICIT NULL,
 726                          preferredDatabases     [6] IMPLICIT
 727                                      SEQUENCE OF InternationalString
 728                  -- values 7-100 reserved for future assignment.
 729 }
 730
 731 DuplicateDetectionResponse ::= SEQUENCE {
 732   referenceId                          ReferenceId  OPTIONAL,
 733   status                       [3]     IMPLICIT INTEGER{
 734                                          success               (0),
 735                                          failure               (1)},
 736   resultSetCount               [4]     IMPLICIT INTEGER OPTIONAL,
 737   diagnostics                  [5]     IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
 738   otherInfo                           OtherInformation OPTIONAL}
 739
 740 -- Global auxiliary definitions
 741   ReferenceId       ::=      [2]  IMPLICIT OCTET STRING
 742   ResultSetId        ::=      [31]    IMPLICIT InternationalString
 743   ElementSetName     ::=     [103]   IMPLICIT InternationalString
 744   DatabaseName     ::=    [105]   IMPLICIT InternationalString
 745   AttributeSetId     ::=       OBJECT IDENTIFIER
 746
 747
 748 -- OtherInformation
 749   OtherInformation   ::= [201] IMPLICIT SEQUENCE OF SEQUENCE{
 750     category            [1]   IMPLICIT InfoCategory OPTIONAL,
 751     information        CHOICE{
 752       characterInfo        [2]  IMPLICIT InternationalString,
 753       binaryInfo        [3]  IMPLICIT OCTET STRING,
 754       externallyDefinedInfo    [4]  IMPLICIT EXTERNAL,
 755       oid          [5]  IMPLICIT OBJECT IDENTIFIER}}
 756 --
 757   InfoCategory ::= SEQUENCE{
 758       categoryTypeId  [1]   IMPLICIT OBJECT IDENTIFIER OPTIONAL,
 759       categoryValue  [2]   IMPLICIT INTEGER}
 760
 761
 762 -- Units
 763   -- IntUnit is used when value and unit are supplied together. Unit, alone, is used when just
 764   -- specifying a unit (without a value).  For example, IntUnit is used in Term, in an RPNQuery, or
 765   -- it can be the datatype of an element within a retrieval record. Unit (alone) would be used in an
 766   -- element request, when requesting data be returned according to a particular unit.
 767
 768   IntUnit ::= SEQUENCE{
 769     value    [1] IMPLICIT INTEGER,
 770     unitUsed  [2] IMPLICIT Unit}
 771 --
 772   Unit ::= SEQUENCE{
 773     unitSystem    [1] InternationalString OPTIONAL,    -- e.g. 'SI'
 774     unitType    [2] StringOrNumeric OPTIONAL,    -- e.g. 'mass'
 775     unit      [3] StringOrNumeric OPTIONAL,    -- e.g. 'kilograms'
 776     scaleFactor    [4] IMPLICIT INTEGER OPTIONAL    -- e.g. 9 means 10**9
 777         }
 778
 779 --CharacterString
 780   InternationalString ::= GeneralString
 781     -- When version 2 is in force, this collapses to VisibleString. That is, only characters in the
 782     -- visibleString repertoire may be used. (Datatype compatibility with version 2 is not affected,
 783      -- because references are IMPLICIT.)  When version 3 is in force, the semantics of the
 784     -- GeneralString content may be altered by negotiation during initialization. If no such
 785     -- negotiation is in effect, then GeneralString semantics are in force.
 786
 787 StringOrNumeric ::= CHOICE{
 788   string    [1] IMPLICIT InternationalString,
 789   numeric  [2] IMPLICIT INTEGER}
 790
 791 END -- IR DEFINITIONS
 792
 793
 794
 795 DiagnosticFormatDiag1
 796 {Z39-50-diagnosticFormat diag-1 (2)} DEFINITIONS ::=
 797 BEGIN
 798 IMPORTS Term, Specification, AttributeList, SortElement, DatabaseName,
 799 DefaultDiagFormat, InternationalString FROM Z39-50-APDU-1995;
 800
 801
 802 DiagnosticFormat ::=  SEQUENCE OF SEQUENCE{
 803   diagnostic  [1] CHOICE{
 804               defaultDiagRec    [1]  IMPLICIT DefaultDiagFormat,
 805               explicitDiagnostic    [2]  DiagFormat} OPTIONAL,
 806   message  [2] IMPLICIT InternationalString OPTIONAL}
 807
 808
 809 DiagFormat ::= CHOICE{
 810
 811 tooMany  [1000]   IMPLICIT SEQUENCE{
 812                 tooManyWhat   [1]  IMPLICIT INTEGER{
 813                                   argumentWords        (1),
 814                                   truncatedWords        (2),
 815                                   booleanOperators      (3),
 816                                   incompleteSubfields    (4),
 817                                   characters          (5),
 818                                   recordsRetrieved      (6),
 819                                   dataBasesSpecified      (7),
 820                                   resultSetsCreated      (8),
 821                                   indexTermsProcessed    (9)},
 822                 max        [2]  IMPLICIT INTEGER OPTIONAL},
 823
 824
 825
 826
 827
 828
 829
 830 badSpec    [1001]  IMPLICIT SEQUENCE{  -- element set name or specification
 831                 spec        [1] IMPLICIT Specification, -- esn or element spec not supported
 832                 db        [2] IMPLICIT DatabaseName OPTIONAL,
 833                             -- if db specified, above spec not supported for db; otherwise,
 834                             -- spec not supported period.
 835                 goodOnes    [3] IMPLICIT SEQUENCE OF Specification OPTIONAL
 836                             -- target supplies ones that are supported
 837                             },
 838
 839
 840 dbUnavail  [1002]  IMPLICIT SEQUENCE{ -- database unavailable
 841                 db  [1] IMPLICIT DatabaseName,
 842                 why  [2] IMPLICIT SEQUENCE{
 843                         reasonCode  [1] IMPLICIT INTEGER{
 844                                       doesNotExist    (0),
 845                                       existsButUnavail  (1),
 846                                       locked      (2),
 847                                       accessDenied    (3)} OPTIONAL,
 848                         message    [2] IMPLICIT InternationalString OPTIONAL}},
 849
 850
 851 unSupOp  [1003]  IMPLICIT INTEGER{  -- unsupported operator
 852                 and     (0),
 853                 or      (1),
 854                 and-not  (2),
 855                 prox    (3)},
 856
 857
 858 attribute    [1004]  IMPLICIT SEQUENCE{
 859                     -- Applies for unsupported attribute set, attribute type,
 860                     -- attribute value, or term (for a given attribute type or value).
 861
 862                 id      [1]  IMPLICIT OBJECT IDENTIFIER,
 863                    -- if only "id" occurs, then attribute set is not supported
 864                 type    [2]  IMPLICIT INTEGER OPTIONAL,
 865                    -- must occur if value occurs.
 866                 value    [3]   IMPLICIT INTEGER OPTIONAL,
 867                     -- if omitted, and Type occurs, then Type is what is unsupported
 868                 term    [4]  Term OPTIONAL
 869                     -- If occurs, term is illegal or not supported, for attribute value,
 870                     -- if value occurs; otherwise, for type.
 871                                 },
 872
 873
 874 attCombo  [1005]  IMPLICIT SEQUENCE{ -- attribute combination not supported
 875               unsupportedCombination  [1] IMPLICIT AttributeList,
 876               recommendedAlternatives  [2] IMPLICIT SEQUENCE OF AttributeList OPTIONAL},
 877
 878
 879
 880
 881 term      [1006]  IMPLICIT SEQUENCE{
 882                 problem    [1] IMPLICIT INTEGER{
 883                             codedValue  (1),
 884                             unparsable  (2),
 885                             tooShort    (3),
 886                             type      (4)} OPTIONAL,
 887                 term      [2] Term},
 888
 889
 890 proximity  [1007] CHOICE{        -- proximity diagnostics:
 891                resultSets  [1]    IMPLICIT NULL,         -- proximity between sets not supported
 892               badSet    [2]    IMPLICIT InternationalString,  -- bad result set specified
 893                  relation    [3]   IMPLICIT INTEGER,      -- 1 to 6 ; relation not supported
 894               unit      [4]  IMPLICIT INTEGER,      -- unsupported unit code
 895               distance    [5]  IMPLICIT INTEGER,      -- unsupported distance
 896               attributes  [6]  AttributeList,             --  proximity not supported with specified
 897                                                    -- attribute combination
 898               ordered    [7]  IMPLICIT NULL,        -- ordered flag not supported
 899               exclusion  [8]  IMPLICIT NULL          -- exclusion flag not supported
 900                     },
 901
 902
 903
 904
 905
 906 scan     [1008] CHOICE{      -- scan diagnostics:
 907               nonZeroStepSize  [0] IMPLICIT NULL,  -- only zero step size supported
 908               specifiedStepSize  [1] IMPLICIT NULL,  -- specified step size not supported
 909               termList1      [3] IMPLICIT NULL,  -- term list not supported (no alternative supplied)
 910               termList2      [4] IMPLICIT SEQUENCE OF AttributeList,
 911                                           -- term list not supported (alternatives supplied)
 912               posInResponse    [5] IMPLICIT INTEGER{  --value of positionInResponse not supported
 913                               mustBeOne        (1),
 914                               mustBePositive    (2),
 915                               mustBeNonNegative  (3),
 916                               other            (4)},
 917               resources      [6] IMPLICIT NULL,   -- resources exhausted looking for satisfying terms
 918               endOfList      [7] IMPLICIT NULL  -- beginning or end of term list
 919                 },
 920
 921
 922 sort       [1009] CHOICE{
 923               sequence    [0]  IMPLICIT NULL,        -- cannot sort according to sequence
 924               noRsName    [1]  IMPLICIT NULL,        -- no result set name supplied
 925               tooMany    [2]  IMPLICIT INTEGER,      --  Too many input result sets,
 926                                                 --  maximum supplied.
 927               incompatible  [3]  IMPLICIT NULL,        -- records with different formats
 928                                                  -- not compatible for sorting
 929               generic      [4]  IMPLICIT NULL,        -- generic sort not supported
 930                                                 -- (db specific only)
 931               dbSpecific    [5]  IMPLICIT NULL,        -- db specific sort not supported
 932               sortElement    [6]  SortElement,
 933               key        [7]  IMPLICIT INTEGER{
 934                               tooMany  (1),    -- too many sort keys
 935                               duplicate  (2)},    -- duplicate sort keys
 936               action      [8]  IMPLICIT NULL,  -- unsupported missing data action
 937               illegal      [9]  IMPLICIT INTEGER{
 938                               relation  (1),  -- illegal sort relation
 939                               case    (2),  -- illegal case value
 940                               action  (3),   -- illegal missing data action
 941                               sort    (4)},  -- illegal sort
 942             inputTooLarge    [10]  IMPLICIT SEQUENCE OF InternationalString,
 943                                       --   one or more of the input result sets too large to sort
 944           aggregateTooLarge  [11]  IMPLICIT NULL  --  aggregate result set too large
 945                           },
 946
 947 segmentation  [1010]  CHOICE{
 948                 segmentCount  [0]    IMPLICIT NULL,
 949                                   -- Cannot guarantee record will fit within max segments. Target
 950                                   -- suggests that origin try again to retrieve record, without
 951                                   -- including max-segment-count.
 952                 segmentSize  [1]    IMPLICIT INTEGER
 953                                 -- record cannot be segmented into fragments such that the largest
 954                                 -- will fit within max segment size specified. Target supplies (in
 955                                 -- bytes) the smallest acceptable value of Max-segment-size to
 956                                 -- retrieve the record.
 957                           },
 958
 959
 960 extServices  [1011] CHOICE{
 961                 req        [1] IMPLICIT INTEGER{   -- bad request
 962                             nameInUse    (1),  -- package name already in use
 963                             noSuchName  (2),  -- no such package, on modify/delete
 964                             quota        (3),  -- quota exceeded
 965                             type        (4)},  -- extended service type not supported
 966                 permission  [2] IMPLICIT INTEGER{ -- permission denied on ES, because:
 967                             id         (1),    --   id not authorized, or
 968                             modifyDelete  (2)},    -- cannot modify or delete
 969                 immediate  [3] IMPLICIT INTEGER{ -- immediate execution:
 970                             failed      (1),    -- failed,
 971                             service      (2),    -- not supported for this service, or
 972                             parameters    (3)    -- for these parameters.
 973                                 }},
 974
 975
 976 accessCtrl    [1012] CHOICE{
 977                 noUser    [1] IMPLICIT NULL,    -- no user to display challenge to
 978                 refused    [2] IMPLICIT NULL,    -- access control information refused by user
 979                 simple    [3] IMPLICIT NULL,    -- only simple form supported (target used
 980                                           -- externally defined)
 981                 oid      [4] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER,
 982                                           -- oid not supported (origin supplies alternative
 983                                           -- suggested oids)
 984                 alternative  [5] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER,
 985                                           -- origin insists that target use an alternative
 986                                           -- challenge for this data (e.g. stronger
 987
 988                                           -- authentication or stronger Access control). The
 989               -- origin supplies suggested alternative oids.
 990                 pwdInv    [6] IMPLICIT NULL,    -- password invalid
 991                 pwdExp    [7] IMPLICIT NULL      -- password expired
 992                     },
 993
 994
 995 recordSyntax  [1013] IMPLICIT SEQUENCE{ -- record cannot be transferred in requested syntax
 996               unsupportedSyntax    [1] IMPLICIT OBJECT IDENTIFIER,
 997               suggestedAlternatives  [2] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL}
 998 }
 999
1000 END
1001
1002
1003
1004
1005
1006 RecordSyntax-explain
1007 {Z39-50-recordSyntax explain (100)} DEFINITIONS ::=
1008
1009 BEGIN
1010 IMPORTS AttributeSetId, Term, OtherInformation, DatabaseName, ElementSetName, IntUnit, Unit,
1011  StringOrNumeric, Specification, InternationalString, AttributeList, AttributeElement FROM Z39-50-APDU-1995;
1012
1013 Explain-Record ::= CHOICE{
1014   -- Each of these may be used as search term  when Use attribute is 'explain-category'.
1015   targetInfo         [0]    IMPLICIT TargetInfo,
1016   databaseInfo      [1]    IMPLICIT DatabaseInfo,
1017   schemaInfo        [2]    IMPLICIT SchemaInfo,
1018   tagSetInfo         [3]    IMPLICIT TagSetInfo,
1019   recordSyntaxInfo    [4]    IMPLICIT RecordSyntaxInfo,
1020   attributeSetInfo    [5]    IMPLICIT AttributeSetInfo,
1021   termListInfo      [6]    IMPLICIT TermListInfo,
1022   extendedServicesInfo  [7]    IMPLICIT ExtendedServicesInfo,
1023   attributeDetails      [8]    IMPLICIT AttributeDetails,
1024   termListDetails    [9]    IMPLICIT TermListDetails,
1025   elementSetDetails    [10]  IMPLICIT ElementSetDetails,
1026   retrievalRecordDetails  [11]   IMPLICIT RetrievalRecordDetails,
1027   sortDetails             [12]   IMPLICIT SortDetails,
1028   processing           [13]  IMPLICIT ProcessingInformation,
1029   variants          [14]  IMPLICIT VariantSetInfo,
1030   units          [15]    IMPLICIT UnitInfo,
1031   categoryList            [100]  IMPLICIT CategoryList}
1032
1033 -- Element set name 'B' (brief)  retrieves:
1034 --  -  'commonInfo' (except for otherInfo within commonInfo)
1035 --  -  key elements
1036 --  -  other elements designated as 'non-key brief elements'
1037 -- Esn 'description' retrieves brief elements as well as 'description', and specific additional descriptive
1038 -- elements if designated.
1039 -- Element set name 'F' (full) retrieves all of the above, as well as those designated as "non-brief elements". Some
1040 -- elements designated as OPTIONAL may be mandatory in full records, and are so identified. (Note that all elements
1041 -- that are not part of the brief element set must be designated as OPTIONAL in the ASN.1, otherwise it would be
1042 -- illegal to omit them.)
1043 -- Other esns are defined (below) as needed.
1044
1045 -- - - - - - - - - - - - -   Info Records
1046   -- Info records are mainly for software consumption
1047   -- They describe individual entities within the target system:
1048   --   The target itself
1049   --   Individual databases
1050   --   Schemas
1051   --   Tag sets
1052   --   Record syntaxes
1053   --   Attribute sets
1054   --   Term lists
1055   --   Extended services
1056  --     The information about each Schema, Tag Set, Record Syntax and Attribute Set should
1057   -- match the universal definitions of these items. The only exception is that a target may omit any
1058   -- items it doesn't support, for example the description of the bib-1 attribute set may omit attributes
1059   -- that the target does not support under any circumstances.
1060   --      Databases that may be searched together can be listed in the dbCominations element of the TargetInfo record.
1061 TargetInfo ::= SEQUENCE {
1062   commonInfo      [0]    IMPLICIT CommonInfo OPTIONAL,
1063     -- Key elements follow:
1064   name          [1]    IMPLICIT InternationalString,
1065     -- Non-key brief elements follow:
1066   recent-news      [2]    IMPLICIT HumanString OPTIONAL,
1067   icon          [3]    IMPLICIT IconObject OPTIONAL,
1068   namedResultSets    [4]    IMPLICIT BOOLEAN,
1069   multipleDBsearch    [5]    IMPLICIT BOOLEAN,
1070   maxResultSets      [6]    IMPLICIT INTEGER OPTIONAL,
1071   maxResultSize      [7]    IMPLICIT INTEGER OPTIONAL,
1072   maxTerms        [8]    IMPLICIT INTEGER OPTIONAL,
1073   timeoutInterval      [9]    IMPLICIT IntUnit OPTIONAL,
1074   welcomeMessage    [10]  IMPLICIT HumanString OPTIONAL,
1075     -- non-brief elements follow:
1076   -- 'description' esn retrieves the following two (as well as brief):
1077   contactInfo      [11]  IMPLICIT ContactInfo OPTIONAL,
1078   description      [12]  IMPLICIT HumanString OPTIONAL,
1079   nicknames        [13]  IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
1080   usage-restrictions    [14]  IMPLICIT HumanString OPTIONAL,
1081   paymentAddr      [15]  IMPLICIT HumanString OPTIONAL,
1082   hours          [16]  IMPLICIT HumanString OPTIONAL,
1083   dbCombinations    [17]  IMPLICIT SEQUENCE OF DatabaseList OPTIONAL,
1084   addresses        [18]  IMPLICIT SEQUENCE OF NetworkAddress OPTIONAL,
1085   languages        [101]  IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
1086                   -- Languages supported for message strings.  Each is a three-character
1087                   -- language code from Z39.53-1994.
1088 -- characterSets      [102]  this tag reserved for "character sets supported for name and message strings".
1089   -- commonAccessInfo elements list objects the target supports. All objects listed in
1090   -- AccessInfo for any individual database should also be listed here.
1091   commonAccessInfo  [19]  IMPLICIT AccessInfo OPTIONAL}
1092
1093
1094 DatabaseInfo ::= SEQUENCE {
1095       -- A target may provide "virtual databases" that are combinations of individual database. These
1096       -- databases are indicated by the presence of subDbs in the combination database's DatabaseDescription.
1097   commonInfo        [0]    IMPLICIT CommonInfo OPTIONAL,
1098     -- Key elements follow:
1099   name            [1]    IMPLICIT DatabaseName,
1100     -- Non-key brief elements follow:
1101   explainDatabase      [2]             IMPLICIT NULL OPTIONAL,
1102                        -- If present, this database is the Explain database, or an Explain database
1103                     -- for a different server, possibly on a different host. The means by which
1104                     -- that server may be accessed is not addressed by this standard. One
1105                     -- suggested possibility is an implementor agreement whereby the
1106                     -- database name is a url which may be used to connect to the server.
1107   nicknames          [3]    IMPLICIT SEQUENCE OF DatabaseName OPTIONAL,
1108   icon            [4]    IMPLICIT IconObject OPTIONAL,
1109   user-fee          [5]    IMPLICIT BOOLEAN,
1110   available          [6]    IMPLICIT BOOLEAN,
1111   titleString          [7]    IMPLICIT HumanString OPTIONAL,
1112     -- Non-brief elements follow:
1113   keywords          [8]    IMPLICIT SEQUENCE OF HumanString OPTIONAL,
1114   description        [9]    IMPLICIT HumanString OPTIONAL,
1115   associatedDbs        [10]  IMPLICIT DatabaseList OPTIONAL,
1116                     -- databases that may be searched in combination with this one
1117
1118   subDbs          [11]  IMPLICIT DatabaseList OPTIONAL,
1119                         -- When present, this database is a composite representing the combined
1120                      -- databases 'subDbs'. The individual subDbs are also available.
1121   disclaimers        [12]  IMPLICIT HumanString OPTIONAL,
1122   news            [13]  IMPLICIT HumanString OPTIONAL,
1123   recordCount           [14]    CHOICE {
1124                                    actualNumber  [0] IMPLICIT INTEGER,
1125                                     approxNumber  [1] IMPLICIT INTEGER} OPTIONAL,
1126   defaultOrder        [15]  IMPLICIT HumanString OPTIONAL,
1127   avRecordSize        [16]  IMPLICIT INTEGER OPTIONAL,
1128   maxRecordSize      [17]  IMPLICIT INTEGER OPTIONAL,
1129   hours            [18]  IMPLICIT HumanString OPTIONAL,
1130   bestTime          [19]  IMPLICIT HumanString OPTIONAL,
1131   lastUpdate          [20]  IMPLICIT GeneralizedTime OPTIONAL,
1132   updateInterval        [21]  IMPLICIT IntUnit OPTIONAL,
1133   coverage          [22]  IMPLICIT HumanString OPTIONAL,
1134   proprietary        [23]  IMPLICIT BOOLEAN OPTIONAL, -- mandatory in full record
1135   copyrightText        [24]  IMPLICIT HumanString OPTIONAL,
1136   copyrightNotice      [25]  IMPLICIT HumanString OPTIONAL,
1137   producerContactInfo    [26]  IMPLICIT ContactInfo OPTIONAL,
1138   supplierContactInfo      [27]  IMPLICIT ContactInfo OPTIONAL,
1139   submissionContactInfo    [28]  IMPLICIT ContactInfo OPTIONAL,
1140     -- accessInfo lists items connected with the database. All listed items should be in the target's AccessInfo.
1141   accessInfo                [29]  IMPLICIT AccessInfo OPTIONAL}
1142
1143
1144 SchemaInfo ::= SEQUENCE {
1145   commonInfo    [0]  IMPLICIT CommonInfo OPTIONAL,
1146     -- Key elements follow:
1147   schema      [1]  IMPLICIT OBJECT IDENTIFIER,
1148     -- Non-key brief elements follow:
1149   name        [2]  IMPLICIT InternationalString,
1150     -- Non-brief elements follow:
1151   description    [3]  IMPLICIT HumanString OPTIONAL,
1152   tagTypeMapping  [4]  IMPLICIT SEQUENCE OF SEQUENCE {
1153               tagType    [0] IMPLICIT INTEGER,
1154               tagSet       [1] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
1155                 -- If tagSet is omitted, then this tagType is for a tagSet locally defined
1156                 -- within the schema that cannot be referenced by another schema.
1157               defaultTagType  [2] IMPLICIT NULL OPTIONAL
1158                         } OPTIONAL,
1159   recordStructure  [5]  IMPLICIT SEQUENCE OF ElementInfo OPTIONAL}
1160
1161
1162   --  ElementInfo referenced in SchemaInfo and RecordSyntaxInfo
1163     ElementInfo ::= SEQUENCE {
1164       elementName  [1] IMPLICIT InternationalString,
1165       elementTagPath  [2] IMPLICIT Path,
1166       dataType      [3] ElementDataType OPTIONAL, -- If omitted, not specified.
1167        required         [4] IMPLICIT BOOLEAN,
1168       repeatable     [5] IMPLICIT BOOLEAN,
1169        description    [6] IMPLICIT HumanString OPTIONAL}
1170
1171
1172   -- Path is referenced by ElementInfo as well as PerElementDetails
1173              Path ::= SEQUENCE OF SEQUENCE{
1174               tagType  [1] IMPLICIT INTEGER,
1175               tagValue     [2] StringOrNumeric}
1176       ElementDataType ::= CHOICE{
1177             primitive  [0] IMPLICIT PrimitiveDataType,
1178            structured  [1] IMPLICIT SEQUENCE OF ElementInfo}
1179       PrimitiveDataType ::= INTEGER{
1180             octetString        (0),
1181             numeric           (1),
1182             date            (2),
1183             external        (3),
1184             string          (4),
1185             trueOrFalse       (5),
1186             oid         (6),
1187             intUnit        (7),
1188         empty        (8),
1189             noneOfTheAbove  (100) -- see 'description'
1190             }
1191
1192
1193 TagSetInfo ::= SEQUENCE {
1194   commonInfo  [0]  IMPLICIT CommonInfo OPTIONAL,
1195     -- Key elements follow:
1196   tagSet      [1]  IMPLICIT OBJECT IDENTIFIER,
1197     -- non-key brief elements follow:
1198   name      [2]  IMPLICIT InternationalString,
1199     -- non-brief elements follow:
1200   description  [3]  IMPLICIT HumanString OPTIONAL,
1201   elements    [4]  IMPLICIT SEQUENCE OF SEQUENCE {
1202               elementname  [1]  IMPLICIT InternationalString,
1203                nicknames    [2]  IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
1204               elementTag     [3]  StringOrNumeric,
1205               description    [4]  IMPLICIT HumanString OPTIONAL,
1206             dataType       [5]  PrimitiveDataType OPTIONAL,
1207               -- If the data type is expected to be structured, that is described in the schema info,
1208               -- and datatype is omitted here.
1209              otherTagInfo       OtherInformation OPTIONAL} OPTIONAL}
1210
1211 RecordSyntaxInfo ::= SEQUENCE {
1212   commonInfo    [0]  IMPLICIT CommonInfo OPTIONAL,
1213     -- Key elements follow:
1214   recordSyntax    [1]  IMPLICIT OBJECT IDENTIFIER,
1215     -- Non-key brief elements follow:
1216   name        [2]  IMPLICIT InternationalString,
1217     -- non-brief elements follow:
1218   transferSyntaxes  [3]  IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
1219   description    [4]  IMPLICIT HumanString OPTIONAL,
1220   asn1Module    [5]  IMPLICIT InternationalString OPTIONAL,
1221   abstractStructure  [6]  IMPLICIT SEQUENCE OF ElementInfo OPTIONAL
1222                -- Omitting abstractStructure only means target isn't using
1223                  -- Explain to describe the structure, not that there is no structure.
1224               }
1225
1226 AttributeSetInfo ::= SEQUENCE {
1227   commonInfo  [0]  IMPLICIT CommonInfo OPTIONAL,
1228     -- Key elements follow:
1229   attributeSet  [1]  IMPLICIT AttributeSetId,
1230     -- non-key brief elements follow:
1231   name      [2]  IMPLICIT InternationalString,
1232     -- non-brief elements follow:
1233   attributes    [3]  IMPLICIT SEQUENCE OF AttributeType OPTIONAL,
1234             -- mandatory in full record
1235   description   [4] IMPLICIT HumanString OPTIONAL}
1236 -- AttributeType referenced in AttributeSetInfo
1237   AttributeType ::= SEQUENCE {
1238       name             [0] IMPLICIT InternationalString OPTIONAL,
1239       description      [1] IMPLICIT HumanString OPTIONAL,
1240        attributeType    [2] IMPLICIT INTEGER,
1241       attributeValues  [3] IMPLICIT SEQUENCE OF AttributeDescription}
1242     AttributeDescription ::= SEQUENCE {
1243         name                 [0] IMPLICIT InternationalString OPTIONAL,
1244         description          [1] IMPLICIT HumanString OPTIONAL,
1245         attributeValue       [2] StringOrNumeric,
1246         equivalentAttributes  [3]  IMPLICIT SEQUENCE OF StringOrNumeric OPTIONAL
1247                   -- each is an occurrence of 'attributeValue' from AttributeDescription for a
1248                   -- different attribute. Equivalences listed here should be derived from the
1249                   -- attribute set definition, not from a particular server's behavior.
1250                     }
1251
1252
1253 TermListInfo ::= SEQUENCE{
1254   commonInfo    [0]  IMPLICIT CommonInfo OPTIONAL,
1255     -- Key elements follow:
1256   databaseName  [1]  IMPLICIT DatabaseName,
1257     -- Non-key brief elements follow:
1258   termLists      [2] IMPLICIT SEQUENCE OF SEQUENCE{
1259             name    [1] IMPLICIT InternationalString,
1260             title    [2] IMPLICIT HumanString OPTIONAL,
1261                                             -- Title is for users to see and can differ by language. Name, on the
1262                       -- other hand is typically a short string not necessarily meant to be
1263                        -- human-readable, and not variable by language.
1264             searchCost   [3]   IMPLICIT INTEGER {
1265                   optimized  (0),    -- The attribute (or combination) associated
1266                             -- with this   list will do fast searches.
1267                       normal      (1),    -- The attribute (combination) will work as
1268                             -- expected. So there's probably an index for the
1269                             -- attribute (combination) or some similar
1270                              -- mechanism.
1271                       expensive   (2),    -- Can use the attribute (combination), but it
1272                             -- might not provide satisfactory results.
1273                             -- Probably there is no index, or post-
1274                             -- processing of records is required.
1275                       filter      (3)    -- can't search with this attribute (combination) alone.
1276                          } OPTIONAL,
1277               scanable  [4]  IMPLICIT BOOLEAN, -- 'true' means this list can be scanned.
1278                broader    [5] IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
1279                narrower  [6] IMPLICIT SEQUENCE OF InternationalString OPTIONAL
1280                        -- broader and narrower list alternative term lists related to this one.
1281                        -- The term lists so listed should also be in this termLists structure.
1282                           }
1283   -- no non-brief elements
1284             }
1285
1286
1287 ExtendedServicesInfo ::= SEQUENCE {
1288   commonInfo          [0]  IMPLICIT CommonInfo OPTIONAL,
1289     -- Key elements follow:
1290   type          [1]  IMPLICIT OBJECT IDENTIFIER,
1291     -- Non-key brief elements follow:
1292   name                [2]  IMPLICIT InternationalString OPTIONAL,
1293                 -- should be supplied if privateType is 'true'
1294   privateType      [3]  IMPLICIT BOOLEAN,
1295   restrictionsApply    [5]  IMPLICIT BOOLEAN,  -- if 'true' see 'description'
1296   feeApply              [6]  IMPLICIT BOOLEAN,  -- if 'true' see 'description'
1297   available             [7]  IMPLICIT BOOLEAN,
1298   retentionSupported    [8]  IMPLICIT BOOLEAN,
1299   waitAction      [9]  IMPLICIT INTEGER{
1300                 waitSupported    (1),
1301                 waitAlways      (2),
1302                 waitNotSupported  (3),
1303                 depends      (4),
1304                 notSaying      (5)},
1305   -- non-brief elements follow:
1306     -- To get brief plus 'description' use esn 'description'
1307   description           [10]  IMPLICIT HumanString OPTIONAL,
1308       -- to get above elements and 'specificExplain' use esn 'specificExplain'
1309   specificExplain    [11]  IMPLICIT EXTERNAL OPTIONAL,
1310                   -- Use oid of specific ES, and select choice [3] 'explain'. Format
1311                   -- to be developed in conjunction with the specific ES definition.
1312     -- to get all elements except 'specificExplain', use esn 'asn'
1313   esASN          [12]  IMPLICIT InternationalString OPTIONAL -- the ASN.1 for this ES
1314                 }
1315
1316 -- - - - - - - - - - - - - Detail records
1317  -- The detail records describe relationships among entities supported by the target. RetrievalRecordDetails describes
1318  -- the way that schema elements are mapped into record elements. This mapping may be different for each
1319  -- combination of database, schema, record syntax. The per-element details describe the default mapping.
1320  -- Origin-request re-tagging can change that mapping. When multiple databases are listed in a databaseNames
1321  -- element, the record applies equally to all of the listed databases.  This is unrelated to searching the databases
1322  -- together. AttributeDetails describes how databases can be searched. Each supported attribute is listed, and the
1323  -- allowable combinations can be described.
1324
1325
1326 AttributeDetails ::= SEQUENCE {
1327   commonInfo        [0]  IMPLICIT CommonInfo OPTIONAL,
1328     -- Key elements follow:
1329   databaseName        [1]  IMPLICIT DatabaseName,
1330     -- Non-brief elements follow:
1331   attributesBySet        [2]  IMPLICIT SEQUENCE OF AttributeSetDetails OPTIONAL,
1332                   -- mandatory in full record
1333   attributeCombinations    [3]  IMPLICIT AttributeCombinations OPTIONAL}
1334
1335
1336
1337
1338 -- AttributeSetDetails referenced by AttributeDetails
1339   AttributeSetDetails ::= SEQUENCE {
1340         attributeSet      [0] IMPLICIT AttributeSetId,
1341           attributesByType  [1] IMPLICIT SEQUENCE OF AttributeTypeDetails }
1342     AttributeTypeDetails ::= SEQUENCE {
1343          attributeType     [0] IMPLICIT INTEGER,
1344           defaultIfOmitted    [1] IMPLICIT OmittedAttributeInterpretation OPTIONAL,
1345           attributeValues    [2] IMPLICIT SEQUENCE OF AttributeValue OPTIONAL }
1346                           -- If no attributeValues are supplied, all values of this type are fully
1347                     -- supported, and the descriptions in AttributeSetInfo are adequate.
1348
1349     OmittedAttributeInterpretation ::= SEQUENCE {
1350         defaultValue           [0] StringOrNumeric OPTIONAL,
1351                                 -- A default value is listed if that's how the server works
1352         defaultDescription  [1] IMPLICIT HumanString OPTIONAL }
1353                           -- The human-readable description should generally be provided.
1354                     -- It is legal for both default elements to be missing, which
1355                     -- means that the target will allow the attribute type to be
1356                     -- omitted, but isn't saying what it will do.
1357
1358     AttributeValue ::= SEQUENCE {
1359         value              [0]  StringOrNumeric,
1360         description        [1]  IMPLICIT HumanString OPTIONAL,
1361         subAttributes     [2]  IMPLICIT SEQUENCE OF StringOrNumeric OPTIONAL,
1362         superAttributes    [3]  IMPLICIT SEQUENCE OF StringOrNumeric OPTIONAL,
1363         partialSupport    [4]  IMPLICIT NULL OPTIONAL }
1364         -- partialSupport indicates that an attributeValue is accepted, but may not be processed in the
1365         -- "expected" way. One important reason for this is composite databases: in this case partialSupport
1366         -- may indicate that only some of the subDbs support the attribute, and others ignore it.
1367
1368
1369
1370 TermListDetails ::= SEQUENCE{  -- one for each termList in TermListInfo
1371   commonInfo    [0]  IMPLICIT CommonInfo OPTIONAL,
1372     -- Key elements follow:
1373   termListName    [1]  IMPLICIT InternationalString,
1374     -- Non-key elements (all non-brief) follow:
1375   description    [2]  IMPLICIT HumanString OPTIONAL,
1376   attributes      [3]  IMPLICIT AttributeCombinations OPTIONAL,
1377                           -- Pattern for attributes that hit this list. Mandatory in full record
1378   scanInfo      [4]  IMPLICIT SEQUENCE {
1379                 maxStepSize         [0] IMPLICIT INTEGER OPTIONAL,
1380                 collatingSequence  [1] IMPLICIT HumanString OPTIONAL,
1381                 increasing            [2] IMPLICIT BOOLEAN OPTIONAL} OPTIONAL,
1382             -- Occurs only if list is scanable. If list is scanable and if scanInfo is omitted,
1383             -- target doesn't consider these important.
1384   estNumberTerms  [5]  IMPLICIT INTEGER OPTIONAL,
1385   sampleTerms    [6]  IMPLICIT SEQUENCE OF Term OPTIONAL}
1386
1387
1388
1389 ElementSetDetails ::= SEQUENCE {
1390   -- ElementSetDetails describes the way that database records are mapped to record elements. This
1391   -- mapping may be different for each combination of database name and element set. The database record
1392    -- description is a schema, which may be private to the target. The schema's abstract record structure
1393   -- and tag sets provide the vocabulary for discussing record content; their presence in the Explain
1394   -- database does not imply support for complex retrieval specification.
1395   commonInfo      [0]  IMPLICIT CommonInfo OPTIONAL,
1396     -- Key elements follow:
1397   databaseName      [1]  IMPLICIT DatabaseName,
1398   elementSetName    [2]  IMPLICIT ElementSetName,
1399   recordSyntax      [3]  IMPLICIT OBJECT IDENTIFIER,
1400     -- Non-key Brief elements follow:
1401   schema        [4]  IMPLICIT OBJECT IDENTIFIER,
1402     -- Non-brief elements follow:
1403   description      [5]  IMPLICIT HumanString OPTIONAL,
1404   detailsPerElement    [6]  IMPLICIT SEQUENCE OF PerElementDetails OPTIONAL -- mandatory in full record
1405               }
1406
1407
1408 RetrievalRecordDetails ::= SEQUENCE {
1409   commonInfo      [0]  IMPLICIT CommonInfo OPTIONAL,
1410     -- Key elements follow:
1411   databaseName      [1]  IMPLICIT DatabaseName,
1412   schema        [2]  IMPLICIT OBJECT IDENTIFIER,
1413   recordSyntax      [3]  IMPLICIT OBJECT IDENTIFIER,
1414     -- Non-brief elements follow:
1415   description      [4]  IMPLICIT HumanString OPTIONAL,
1416   detailsPerElement    [5]  IMPLICIT SEQUENCE OF PerElementDetails OPTIONAL
1417                 -- mandatory in full record
1418             }
1419
1420 -- PerElementDetails is referenced in RetrievalRecordDetails and ElementSetDetails.
1421   PerElementDetails ::= SEQUENCE {
1422       name      [0]    IMPLICIT InternationalString OPTIONAL,
1423                    -- If the name is omitted, the record syntax's name for this element
1424                   -- is appropriate.
1425       recordTag    [1]    IMPLICIT RecordTag OPTIONAL,
1426                    -- The record tag may be omitted if tags are inappropriate for the record
1427                   -- syntax, or if the origin can be expected to know it for some other reason.
1428       schemaTags    [2]    IMPLICIT SEQUENCE OF Path OPTIONAL,
1429                       -- The information from the listed schema elements is combined
1430                   -- in some way to produce the data sent in the listed record tag. The
1431                   -- 'contents' element below may describe the logic used.
1432       maxSize    [3]    IMPLICIT INTEGER OPTIONAL,
1433       minSize    [4]    IMPLICIT INTEGER OPTIONAL,
1434       avgSize      [5]    IMPLICIT INTEGER OPTIONAL,
1435       fixedSize    [6]    IMPLICIT INTEGER OPTIONAL,
1436       repeatable    [8]    IMPLICIT BOOLEAN,
1437       required    [9]    IMPLICIT BOOLEAN,
1438                   -- 'required' really means that target will always supply the element.
1439       description    [12]  IMPLICIT HumanString OPTIONAL,
1440       contents    [13]  IMPLICIT HumanString OPTIONAL,
1441       billingInfo    [14]  IMPLICIT HumanString OPTIONAL,
1442       restrictions    [15]  IMPLICIT HumanString OPTIONAL,
1443       alternateNames  [16]  IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
1444       genericNames  [17]  IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
1445       searchAccess  [18]  IMPLICIT AttributeCombinations OPTIONAL }
1446       -- RecordTag referenced in PerElementDetails above
1447         RecordTag ::= SEQUENCE {
1448               qualifier  [0] StringOrNumeric OPTIONAL,
1449                     -- E.g. tag set for GRS-1
1450               tagValue  [1] StringOrNumeric}
1451
1452 SortDetails ::= SEQUENCE {
1453   commonInfo    [0]  IMPLICIT CommonInfo OPTIONAL,
1454   -- Key elements follow:
1455   databaseName    [1]  IMPLICIT DatabaseName,
1456     -- No non-key brief elements
1457     -- Non-brief elements follow:
1458   sortKeys      [2]  IMPLICIT SEQUENCE OF SortKeyDetails OPTIONAL
1459               -- mandatory in full record
1460           }
1461   SortKeyDetails ::= SEQUENCE {
1462       description        [0]  IMPLICIT HumanString OPTIONAL,
1463       elementSpecifications  [1]  IMPLICIT SEQUENCE OF Specification OPTIONAL,
1464                       -- each specification is a way of specifying this same sort key
1465       attributeSpecifications  [2]  IMPLICIT AttributeCombinations OPTIONAL,
1466                       -- each combination is a way of specifying this same sort key
1467       sortType                   [3]  CHOICE {
1468                     character    [0]  IMPLICIT NULL,
1469                     numeric    [1]  IMPLICIT NULL,
1470                     structured    [2]  IMPLICIT HumanString} OPTIONAL,
1471       caseSensitivity      [4]  IMPLICIT INTEGER {
1472                       always    (0),  -- always case-sensitive
1473                     never    (1),            -- never case-sensitive
1474                     default-yes  (2),               -- case-sensitivity is as specified on request, and if not
1475                             -- specified, case-sensitive.
1476                     default-no  (3)} -- case-sensitivity is as specified on request, and if not
1477                             -- specified, not case-sensitive.
1478                           OPTIONAL}
1479
1480 ProcessingInformation ::= SEQUENCE{
1481   commonInfo      [0]  IMPLICIT CommonInfo OPTIONAL,
1482     -- Key elements follow:
1483   databaseName      [1]  IMPLICIT DatabaseName,
1484   processingContext    [2]  IMPLICIT INTEGER {
1485                   access        (0),   -- e.g. choosing databases
1486                   search        (1),   -- e.g. "search strategies" or search forms
1487                   retrieval      (2),   -- e.g. recommended element combinations
1488                   record-presentation  (3),    -- display of retrieved records
1489                   record-handling    (4)    -- handling (e.g. saving) of retrieved records
1490         },
1491   name          [3]  IMPLICIT InternationalString,
1492   oid          [4]  IMPLICIT OBJECT IDENTIFIER,
1493     -- No non-key brief elements
1494     -- Non-brief elements follow:
1495   description      [5]  IMPLICIT HumanString OPTIONAL,
1496                 -- use element set name 'description' to retrieve all except instructions.
1497   instructions      [6]  IMPLICIT EXTERNAL OPTIONAL -- mandatory in full record
1498               }
1499
1500
1501 VariantSetInfo ::= SEQUENCE {
1502     -- A record in this category describes a variant set definition, i.e., classes, types, and values, for a specific
1503     -- variant set definition supported by the target. Support by the target of a particular variant set definition
1504     -- does not imply that the definition is supported for any specific database or element.
1505   commonInfo    [0] IMPLICIT CommonInfo OPTIONAL,
1506   -- Key elements follow:
1507   variantSet    [1] IMPLICIT OBJECT IDENTIFIER,
1508   -- Non-key brief elements follow:
1509   name      [2] IMPLICIT InternationalString,
1510   -- Non-brief elements follow:
1511   variants    [3] IMPLICIT SEQUENCE OF VariantClass OPTIONAL
1512                    -- mandatory in full record
1513            }
1514
1515   -- Subsidiary structures for VariantSetInfo
1516     VariantClass ::= SEQUENCE {
1517           name        [0] IMPLICIT InternationalString OPTIONAL,
1518           description    [1] IMPLICIT HumanString OPTIONAL,
1519           variantClass    [2] IMPLICIT INTEGER,
1520           variantTypes  [3] IMPLICIT SEQUENCE OF VariantType}
1521     VariantType ::= SEQUENCE {
1522           name            [0] IMPLICIT InternationalString OPTIONAL,
1523           description     [1] IMPLICIT HumanString OPTIONAL,
1524           variantType    [2] IMPLICIT INTEGER,
1525           variantValue  [3] IMPLICIT VariantValue OPTIONAL}
1526     VariantValue ::= SEQUENCE {
1527           dataType     [0] PrimitiveDataType,
1528           values        [1] ValueSet OPTIONAL }
1529     ValueSet ::= CHOICE {
1530           range       [0] IMPLICIT ValueRange,
1531           enumerated  [1] IMPLICIT SEQUENCE OF ValueDescription }
1532     ValueRange ::= SEQUENCE {
1533             -- At last one the following must be supplied, both may be supplied.
1534           lower      [0] ValueDescription OPTIONAL,
1535           upper     [1] ValueDescription OPTIONAL }
1536     ValueDescription ::= CHOICE{
1537       integer             INTEGER,
1538           string              InternationalString,
1539           octets              OCTET STRING,
1540           oid                 OBJECT IDENTIFIER,
1541           unit               [1]  IMPLICIT Unit,
1542           valueAndUnit   [2]  IMPLICIT IntUnit
1543             -- oid and unit can't be used in a ValueRange
1544             }
1545
1546
1547
1548 UnitInfo ::= SEQUENCE {
1549   commonInfo  [0] IMPLICIT CommonInfo OPTIONAL,
1550   -- Key elements follow:
1551   unitSystem   [1] IMPLICIT InternationalString,
1552    -- No non-key brief elements
1553    -- Non-brief elements follow:
1554   description   [2] IMPLICIT HumanString OPTIONAL,
1555   units      [3] IMPLICIT SEQUENCE OF UnitType OPTIONAL
1556                          -- mandatory in full record
1557            }
1558
1559   -- Subsidiary structures for UnitInfo
1560     UnitType ::= SEQUENCE {
1561       name    [0] IMPLICIT InternationalString OPTIONAL,
1562       description  [1] IMPLICIT HumanString OPTIONAL,
1563       unitType  [2] StringOrNumeric,
1564       units     [3] IMPLICIT SEQUENCE OF Units}
1565
1566     Units ::= SEQUENCE {
1567       name     [0] IMPLICIT InternationalString OPTIONAL,
1568       description  [1] IMPLICIT HumanString OPTIONAL,
1569       unit      [2] StringOrNumeric}
1570
1571 CategoryList ::= SEQUENCE {
1572   commonInfo      [0] IMPLICIT CommonInfo OPTIONAL,
1573     -- Only one record expected per Explain database. All elements appear in brief presentation.
1574   categories      [1] IMPLICIT SEQUENCE OF CategoryInfo }
1575     CategoryInfo ::= SEQUENCE {
1576            category          [1] IMPLICIT InternationalString,
1577             originalCategory    [2] IMPLICIT InternationalString OPTIONAL,
1578           description         [3] IMPLICIT HumanString OPTIONAL,
1579          asn1Module      [4] IMPLICIT InternationalString OPTIONAL}
1580
1581
1582 -- - - - - - - - - - - - - - Subsidiary definitions
1583
1584 CommonInfo ::= SEQUENCE {
1585   dateAdded         [0] IMPLICIT GeneralizedTime OPTIONAL,
1586   dateChanged       [1] IMPLICIT GeneralizedTime OPTIONAL,
1587   expiry                [2] IMPLICIT GeneralizedTime OPTIONAL,
1588   humanString-Language  [3] IMPLICIT LanguageCode OPTIONAL,
1589   -- following not to occur for brief:
1590   otherInfo          OtherInformation OPTIONAL}
1591
1592
1593 HumanString ::= SEQUENCE OF SEQUENCE {
1594           language  [0] IMPLICIT LanguageCode OPTIONAL,
1595         text        [1] IMPLICIT InternationalString}
1596
1597 IconObject ::= SEQUENCE OF SEQUENCE{
1598       -- Note that the "SEQUENCE OF" is to allow alternative representations of the same Icon; it is not
1599       -- intended to allow multiple icons.
1600   bodyType [1] CHOICE{
1601            ianaType  [1] IMPLICIT InternationalString,
1602           z3950type  [2] IMPLICIT InternationalString,
1603            otherType  [3] IMPLICIT InternationalString},
1604   content  [2] IMPLICIT OCTET STRING}
1605
1606
1607 LanguageCode ::= InternationalString  -- from ANSI/NISO Z39.53-1994
1608
1609 ContactInfo ::= SEQUENCE {
1610   name           [0] IMPLICIT InternationalString OPTIONAL,
1611   description  [1] IMPLICIT HumanString OPTIONAL,
1612   address        [2] IMPLICIT HumanString OPTIONAL,
1613   email         [3] IMPLICIT InternationalString OPTIONAL,
1614   phone         [4] IMPLICIT InternationalString OPTIONAL}
1615
1616 NetworkAddress ::= CHOICE {
1617   internetAddress      [0] IMPLICIT SEQUENCE {
1618                   hostAddress    [0]  IMPLICIT InternationalString,
1619                   port       [1]  IMPLICIT INTEGER},
1620   osiPresentationAddress    [1] IMPLICIT SEQUENCE {
1621                     pSel         [0] IMPLICIT InternationalString,
1622                     sSel         [1] IMPLICIT InternationalString OPTIONAL,
1623                     tSel        [2] IMPLICIT InternationalString OPTIONAL,
1624                     nSap      [3] IMPLICIT InternationalString},
1625   other            [2] IMPLICIT SEQUENCE {
1626                       type        [0] IMPLICIT InternationalString,
1627                 address    [1] IMPLICIT InternationalString}}
1628
1629 AccessInfo ::= SEQUENCE {
1630     -- AccessInfo contains the fundamental information about what facilities are required to use this target
1631     -- or server. For example, if an origin can handle none of the record syntaxes a database can provide,
1632     -- it might choose not to access the database.
1633   queryTypesSupported  [0]    IMPLICIT SEQUENCE OF QueryTypeDetails OPTIONAL,
1634   diagnosticsSets        [1]    IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
1635   attributeSetIds          [2]    IMPLICIT SEQUENCE OF AttributeSetId OPTIONAL,
1636   schemas                [3]    IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
1637   recordSyntaxes         [4]    IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
1638   resourceChallenges    [5]    IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
1639   restrictedAccess       [6]    IMPLICIT AccessRestrictions OPTIONAL,
1640   costInfo                 [8]    IMPLICIT Costs OPTIONAL,
1641   variantSets       [9]    IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
1642   elementSetNames    [10]  IMPLICIT SEQUENCE OF ElementSetName OPTIONAL,
1643   unitSystems      [11]  IMPLICIT SEQUENCE OF InternationalString}
1644
1645 -- begin auxiliary definitions for AccessInfo
1646 -- Begin Query Details
1647 QueryTypeDetails ::= CHOICE {
1648   private       [0]    IMPLICIT PrivateCapabilities,
1649   rpn            [1]    IMPLICIT RpnCapabilities,
1650   iso8777          [2]    IMPLICIT Iso8777Capabilities,
1651   z39-58      [100]  IMPLICIT HumanString,
1652   erpn        [101]  IMPLICIT RpnCapabilities,
1653   rankedList      [102]  IMPLICIT HumanString}
1654
1655 PrivateCapabilities ::= SEQUENCE {
1656   operators       [0]  IMPLICIT SEQUENCE OF SEQUENCE {
1657               operator  [0] IMPLICIT InternationalString,
1658               description  [1] IMPLICIT HumanString OPTIONAL } OPTIONAL,
1659   searchKeys    [1]  IMPLICIT SEQUENCE OF SearchKey OPTIONAL,  -- field names that can be searched
1660   description    [2]  IMPLICIT SEQUENCE OF HumanString OPTIONAL }
1661
1662 RpnCapabilities ::= SEQUENCE {
1663   operators                    [0] IMPLICIT SEQUENCE OF INTEGER OPTIONAL,
1664                                         -- Omitted means all operators are supported.
1665   resultSetAsOperandSupported  [1] IMPLICIT BOOLEAN,
1666   restrictionOperandSupported    [2] IMPLICIT BOOLEAN,
1667   proximity                    [3] IMPLICIT ProximitySupport OPTIONAL}
1668
1669 Iso8777Capabilities ::= SEQUENCE {
1670   searchKeys  [0]  IMPLICIT SEQUENCE OF SearchKey,  -- field names that may be searched
1671   restrictions   [1]  IMPLICIT HumanString OPTIONAL
1672             -- Omitted means supported, not specifying units.
1673               }
1674
1675 ProximitySupport ::= SEQUENCE {
1676   anySupport      [0]   IMPLICIT BOOLEAN,
1677           -- 'false' means no proximity support, in which case unitsSupported not supplied.
1678   unitsSupported  [1]   IMPLICIT SEQUENCE OF CHOICE{
1679              known  [1] IMPLICIT INTEGER, -- values from KnownProximityUnit
1680           private  [2] IMPLICIT SEQUENCE{
1681                       unit    [0] IMPLICIT INTEGER,
1682                 description  [1] HumanString OPTIONAL}} OPTIONAL}
1683
1684 SearchKey ::= SEQUENCE {
1685   searchKey     [0]  IMPLICIT InternationalString,
1686   description     [1]  IMPLICIT HumanString OPTIONAL }
1687 -- End Query details
1688 AccessRestrictions ::= SEQUENCE OF SEQUENCE {
1689   accessType      [0] INTEGER {
1690                   any         (0),
1691                   search         (1),
1692                   present         (2),
1693                   specific-elements  (3),
1694                   extended-services  (4),
1695             by-database      (5)},
1696   accessText         [1]  IMPLICIT HumanString OPTIONAL,
1697   accessChallenges  [2]  IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL}
1698
1699 Costs ::= SEQUENCE {
1700   connectCharge    [0] IMPLICIT Charge OPTIONAL,    -- Per-connection charge
1701   connectTime    [1] IMPLICIT Charge OPTIONAL,    -- Time-based charge
1702   displayCharge     [2] IMPLICIT Charge OPTIONAL,    -- Per-record charge
1703   searchCharge     [3] IMPLICIT Charge OPTIONAL,    -- Per-search charge
1704   subscriptCharge  [4]  IMPLICIT Charge OPTIONAL,  -- Subscription charges
1705   otherCharges    [5] IMPLICIT SEQUENCE OF SEQUENCE{   -- Other charges
1706             forWhat  [1]  IMPLICIT HumanString,
1707             charge    [2]  IMPLICIT Charge} OPTIONAL}
1708     Charge ::= SEQUENCE{
1709         cost          [1] IMPLICIT IntUnit,
1710         perWhat  [2] IMPLICIT Unit OPTIONAL,
1711                       -- e.g. "second," "minute," "line," "record"...
1712         text          [3] IMPLICIT HumanString OPTIONAL}
1713 -- End Auxiliary definitions for AccessInfo
1714
1715 DatabaseList ::= SEQUENCE OF DatabaseName
1716
1717 AttributeCombinations ::= SEQUENCE {
1718   defaultAttributeSet  [0] IMPLICIT AttributeSetId,
1719                  -- Default for the combinations. Also probably a good choice for the default
1720               -- in searches, but that isn't required.
1721   legalCombinations  [1] IMPLICIT SEQUENCE OF AttributeCombination }
1722
1723
1724 AttributeCombination ::= SEQUENCE OF AttributeOccurrence
1725             -- An AttributeCombination is a pattern for legal combination of attributes
1726
1727
1728 AttributeOccurrence ::= SEQUENCE {
1729       -- An AttributeOccurrence lists the legal values for a specific attribute type in a combination.
1730        attributeSet       [0]  IMPLICIT AttributeSetId OPTIONAL,
1731        attributeType      [1]  IMPLICIT INTEGER,
1732        mustBeSupplied  [2]  IMPLICIT NULL OPTIONAL,
1733        attributeValues    CHOICE {
1734                       any-or-none  [3] IMPLICIT NULL, -- All supported values are OK
1735                       specific    [4] IMPLICIT SEQUENCE OF StringOrNumeric}}
1736                                                   -- Only these values allowed
1737 END
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747 RecordSyntax-SUTRS
1748 {Z39-50-recordSyntax SUTRS (101)} DEFINITIONS ::=
1749 BEGIN
1750 IMPORTS InternationalString  FROM Z39-50-APDU-1995;
1751         SutrsRecord ::=  InternationalString
1752 -- Line terminator is ASCII LF (X'0A').
1753 -- Recommended maximum line length is 72 characters.
1754 END
1755
1756
1757
1758
1759
1760 RecordSyntax-opac
1761 {Z39-50-recordSyntax opac (102)} DEFINITIONS ::=
1762 BEGIN
1763 IMPORTS InternationalString  FROM Z39-50-APDU-1995;
1764 OPACRecord ::= SEQUENCE {
1765   bibliographicRecord   [1]   IMPLICIT EXTERNAL OPTIONAL,
1766   holdingsData     [2]   IMPLICIT SEQUENCE OF HoldingsRecord OPTIONAL}
1767 HoldingsRecord ::=  CHOICE {
1768   marcHoldingsRecord  [1]   IMPLICIT EXTERNAL,
1769   holdingsAndCirc  [2]  IMPLICIT HoldingsAndCircData}
1770 HoldingsAndCircData ::=  SEQUENCE {
1771 -- the following elements are required to display holdings in conformance with NISO standards.
1772   typeOfRecord    [1]   IMPLICIT InternationalString OPTIONAL, -- LDR 06
1773   encodingLevel    [2]   IMPLICIT InternationalString OPTIONAL, -- LDR 017
1774   format      [3]   IMPLICIT InternationalString OPTIONAL, -- 007 00-01
1775   receiptAcqStatus    [4]   IMPLICIT InternationalString OPTIONAL, -- 008 06
1776   generalRetention    [5]   IMPLICIT InternationalString OPTIONAL, -- 008 12
1777   completeness    [6]   IMPLICIT InternationalString OPTIONAL, -- 008 16
1778        dateOfReport     [7]   IMPLICIT InternationalString OPTIONAL, -- 008 26-31
1779   nucCode    [8]   IMPLICIT InternationalString OPTIONAL, -- 852 $a
1780   localLocation    [9]   IMPLICIT InternationalString OPTIONAL, -- 852 $b
1781   shelvingLocation  [10]   IMPLICIT InternationalString OPTIONAL, -- 852 $c
1782   callNumber    [11]   IMPLICIT InternationalString OPTIONAL, -- 852 $h and $i
1783   shelvingData     [12]   IMPLICIT InternationalString OPTIONAL, -- 852 $j thru $m
1784   copyNumber    [13]   IMPLICIT InternationalString OPTIONAL, -- 852 $t
1785   publicNote    [14]   IMPLICIT InternationalString OPTIONAL, -- 852 $z
1786   reproductionNote  [15]   IMPLICIT InternationalString OPTIONAL, -- 843
1787   termsUseRepro     [16]   IMPLICIT InternationalString OPTIONAL, -- 845
1788   enumAndChron    [17]   IMPLICIT InternationalString OPTIONAL, -- all 85x, 86x
1789   volumes     [18]   IMPLICIT SEQUENCE OF Volume OPTIONAL,
1790             -- repeats for each volume held
1791   circulationData    [19]   IMPLICIT SEQUENCE OF CircRecord OPTIONAL
1792             -- repeats for each circulating item.
1793             }
1794 Volume ::=  SEQUENCE {
1795   enumeration    [1]   IMPLICIT InternationalString OPTIONAL,
1796   chronology     [2]   IMPLICIT InternationalString OPTIONAL,
1797   enumAndChron    [3]   IMPLICIT InternationalString OPTIONAL }
1798 CircRecord ::=  SEQUENCE {
1799   availableNow    [1]   IMPLICIT BOOLEAN,
1800   availablityDate    [2]   IMPLICIT InternationalString OPTIONAL,
1801   availableThru      [3]   IMPLICIT InternationalString OPTIONAL,
1802   restrictions     [4]   IMPLICIT InternationalString OPTIONAL,
1803   itemId        [5]   IMPLICIT InternationalString OPTIONAL,
1804   renewable        [6]   IMPLICIT BOOLEAN,
1805   onHold        [7]   IMPLICIT BOOLEAN,
1806   enumAndChron     [8]   IMPLICIT InternationalString OPTIONAL,
1807   midspine    [9]   IMPLICIT InternationalString OPTIONAL,
1808   temporaryLocation  [10]   IMPLICIT InternationalString OPTIONAL}
1809 END
1810
1811
1812
1813 RecordSyntax-summary
1814
1815 {Z39-50-recordSyntax summary (103)} DEFINITIONS ::=
1816 BEGIN
1817 IMPORTS OtherInformation, InternationalString  FROM Z39-50-APDU-1995;
1818 BriefBib ::= SEQUENCE {
1819   title           [1]   IMPLICIT InternationalString,
1820   author            [2]   IMPLICIT InternationalString OPTIONAL,
1821   callNumber         [3]   IMPLICIT InternationalString OPTIONAL,
1822   recordType      [4]   IMPLICIT InternationalString OPTIONAL,
1823   bibliographicLevel  [5]   IMPLICIT InternationalString OPTIONAL,
1824   format        [6]   IMPLICIT SEQUENCE OF FormatSpec OPTIONAL,
1825   publicationPlace    [7]   IMPLICIT InternationalString OPTIONAL,
1826   publicationDate     [8]   IMPLICIT InternationalString OPTIONAL,
1827   targetSystemKey   [9]   IMPLICIT InternationalString OPTIONAL,
1828   satisfyingElement  [10]   IMPLICIT InternationalString OPTIONAL,
1829   rank         [11]   IMPLICIT INTEGER OPTIONAL,
1830   documentId     [12]   IMPLICIT InternationalString OPTIONAL,
1831   abstract       [13]   IMPLICIT InternationalString OPTIONAL,
1832   otherInfo        OtherInformation OPTIONAL}
1833
1834 FormatSpec     ::=  SEQUENCE {
1835   type         [1]   IMPLICIT InternationalString,
1836   size      [2]   IMPLICIT INTEGER OPTIONAL,
1837   bestPosn     [3]   IMPLICIT INTEGER OPTIONAL}
1838 END
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849 RecordSyntax-generic  -- For detailed semantics, see Appendix RET.
1850 {Z39-50-recordSyntax GRS-1 (105)} DEFINITIONS ::=
1851 BEGIN
1852 EXPORTS Variant;
1853 IMPORTS IntUnit, Unit, InternationalString, StringOrNumeric, Term FROM Z39-50-APDU-1995;
1854
1855 GenericRecord ::= SEQUENCE OF TaggedElement
1856 TaggedElement ::= SEQUENCE {
1857   tagType    [1] IMPLICIT INTEGER OPTIONAL,
1858               -- If omitted, default should be supplied dynamically by tagSet-M;
1859               -- otherwise it should be statically specified by the schema.
1860   tagValue    [2] StringOrNumeric,
1861   tagOccurrence  [3] IMPLICIT INTEGER OPTIONAL,
1862                              -- Occurrence within the database record, and relative to the parent. No
1863               -- default; if omitted, target not telling or it is irrelevant.
1864   content      [4] ElementData,
1865   metaData    [5] IMPLICIT ElementMetaData OPTIONAL,
1866   appliedVariant  [6] IMPLICIT Variant OPTIONAL}
1867
1868 ElementData ::= CHOICE{
1869   octets      OCTET STRING,
1870   numeric    INTEGER,
1871   date      GeneralizedTime,
1872   ext        EXTERNAL,
1873   string      InternationalString,
1874   trueOrFalse    BOOLEAN,
1875   oid        OBJECT IDENTIFIER,
1876   intUnit          [1]  IMPLICIT IntUnit,
1877    elementNotThere    [2] IMPLICIT NULL,  -- element requested but not there
1878   elementEmpty      [3] IMPLICIT NULL,  -- element there, but empty
1879   noDataRequested    [4] IMPLICIT NULL,  -- variant request said 'no data'
1880   diagnostic        [5] IMPLICIT EXTERNAL,
1881   subtree          [6] SEQUENCE OF TaggedElement -- recursive, for nested tags
1882               }
1883
1884
1885 ElementMetaData ::= SEQUENCE{
1886   seriesOrder        [1]   IMPLICIT Order OPTIONAL, -- only for a non-leaf node
1887   usageRight        [2]   IMPLICIT Usage OPTIONAL,
1888   hits            [3]    IMPLICIT SEQUENCE OF HitVector OPTIONAL,
1889   displayName      [4]    IMPLICIT InternationalString OPTIONAL,
1890                     -- name for element that origin can use for display
1891   supportedVariants    [5]   IMPLICIT SEQUENCE OF Variant OPTIONAL,
1892   message        [6]    IMPLICIT InternationalString OPTIONAL,
1893   elementDescriptor    [7]   IMPLICIT OCTET STRING OPTIONAL,
1894   surrogateFor      [8]   IMPLICIT TagPath OPTIONAL,
1895                     -- the retrieved element is a surrogate for the element given by this path
1896   surrogateElement    [9]   IMPLICIT TagPath OPTIONAL,
1897                     -- the element given by this path is a surrogate for the retrieved element
1898     other          [99]  IMPLICIT EXTERNAL OPTIONAL}
1899
1900         TagPath ::= SEQUENCE  OF SEQUENCE{
1901           tagType      [1]  IMPLICIT INTEGER OPTIONAL,
1902             tagValue      [2]  StringOrNumeric,
1903             tagOccurrence    [3]  IMPLICIT INTEGER OPTIONAL}
1904
1905
1906
1907 Order ::= SEQUENCE{
1908   ascending    [1] IMPLICIT BOOLEAN,
1909               -- "true" means monotonically increasing (i.e. non-decreasing);
1910               -- "false" means monotonically decreasing (i.e. non-increasing).
1911   order      [2] IMPLICIT INTEGER
1912               -- Same as defined by 'elementOrdering' in tagSet-M, though this may be
1913               -- overridden by schema.
1914           }
1915
1916
1917
1918 Usage ::= SEQUENCE  {
1919   type        [1] IMPLICIT INTEGER{
1920               redistributable    (1),   -- Element is freely redistributable.
1921               restricted      (2),   -- Restriction contains statement.
1922               licensePointer    (3)   -- Restriction contains license pointer.
1923               },
1924   restriction    [2] IMPLICIT InternationalString OPTIONAL}
1925
1926
1927
1928 HitVector ::= SEQUENCE{
1929     -- Each hit vector points to a fragment within the element, via location and/or token.
1930   satisfier            Term OPTIONAL, -- sourceword, etc.
1931   offsetIntoElement    [1] IMPLICIT IntUnit OPTIONAL,
1932   length          [2] IMPLICIT IntUnit OPTIONAL,
1933   hitRank          [3] IMPLICIT INTEGER OPTIONAL,
1934   targetToken        [4] IMPLICIT OCTET STRING OPTIONAL
1935                   -- Origin may use token subsequently within a variantRequest (in
1936                   --  an elementRequest) to retrieve (or to refer to) the fragment.
1937               }
1938
1939
1940
1941
1942 Variant ::= SEQUENCE{
1943     globalVariantSetId    [1] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
1944                   -- Applies to the triples below, when variantSetId omitted. If
1945                   -- globalVariantSetId omitted, default applies. Default may be provided by
1946                   -- the tagSet-M element defaultVariantSetId.
1947
1948
1949
1950
1951   triples          [2]  IMPLICIT SEQUENCE OF SEQUENCE{
1952                   variantSetId  [0]  IMPLICIT OBJECT IDENTIFIER OPTIONAL,
1953                               -- If omitted, globalVariantSetId (above)
1954                               -- applies, unless that too is omitted, in
1955                                -- which case, default used.
1956                   class      [1]  IMPLICIT INTEGER,
1957                   type      [2]  IMPLICIT INTEGER,
1958                   value      [3]  CHOICE{
1959                                integer INTEGER,
1960                                internationalString InternationalString,
1961                                octetString OCTET STRING,
1962                                objectIdentifier OBJECT IDENTIFIER,
1963                                boolean BOOLEAN,
1964                               null NULL,
1965                           -- Following need context tags:
1966                             unit      [1] IMPLICIT Unit,
1967                             valueAndUnit  [2] IMPLICIT IntUnit}}}
1968 END
1969
1970
1971
1972 RecordSyntax-ESTaskPackage
1973 {Z39-50-recordSyntax ESTaskPackage (106)} DEFINITIONS ::=
1974 BEGIN
1975 IMPORTS Permissions, InternationalString, IntUnit, DiagRec FROM Z39-50-APDU-1995;
1976
1977 TaskPackage ::= SEQUENCE{
1978   packageType      [1]   IMPLICIT OBJECT IDENTIFIER,
1979                     -- oid of specific ES definition
1980   packageName      [2]   IMPLICIT InternationalString OPTIONAL,
1981   userId          [3]   IMPLICIT InternationalString OPTIONAL,
1982   retentionTime      [4]   IMPLICIT IntUnit OPTIONAL,
1983   permissions        [5]   IMPLICIT Permissions OPTIONAL,
1984   description        [6]   IMPLICIT InternationalString OPTIONAL,
1985   targetReference      [7]   IMPLICIT OCTET STRING OPTIONAL,
1986   creationDateTime    [8]   IMPLICIT GeneralizedTime OPTIONAL,
1987   taskStatus        [9]   IMPLICIT INTEGER{
1988                       pending    (0),
1989                       active    (1),
1990                       complete  (2),
1991                       aborted    (3)},
1992   packageDiagnostics    [10]  IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
1993   taskSpecificParameters  [11]  IMPLICIT EXTERNAL
1994                     -- Use oid for specific ES definition
1995                     -- (same oid as packageType above)
1996                     -- and select [2] "taskPackage."
1997     }
1998 END
1999
2000
2001
2002
2003 ResourceReport-Format-Resource-1
2004 {Z39-50-resourceReport resource-1 (1)} DEFINITIONS ::=
2005 BEGIN
2006 IMPORTS InternationalString FROM Z39-50-APDU-1995;
2007 --
2008 ResourceReport ::= SEQUENCE{
2009 estimates    [1]   IMPLICIT SEQUENCE OF Estimate,
2010 message      [2]   IMPLICIT InternationalString}
2011 --
2012 Estimate ::= SEQUENCE{
2013 type        [1]   IMPLICIT EstimateType,
2014 value        [2]   IMPLICIT INTEGER,  -- the actual estimate
2015 currency-code  [3]   IMPLICIT INTEGER OPTIONAL
2016                 -- code for representation of currencies defined in ISO 4217-1990.
2017                 -- Applicable only to monetary estimates.
2018                               }
2019 EstimateType ::= INTEGER{
2020 currentSearchRecords    (1),         -- estimated no. records in current (incomplete) result set for search
2021 finalSearchRecords       (2),        -- estimated no. records that will be in result set if search completes
2022 currentPresentRecords    (3),        -- estimated number of records in current (incomplete) set of
2023                       -- records to be returned on Present
2024 finalPresentRecords      (4),  -- estimated number of records that will be in the set of records
2025                       -- to be returned by Present if Present completes
2026 currentOpTimeProcessing  (5),  -- processing time (in .001 CPU seconds) used by operation so far
2027 finalOpTimeProcessing    (6),                -- estimated total processing time (in .001 CPU seconds) that will
2028                               -- be used by this operation if it completes
2029 currentAssocTime      (7),  -- estimated processing time used by association (in .001 CPU sec.)
2030 currentOperationCost      (8),  -- estimated cost for this operation so far
2031 finalOperationCost      (9),  -- estimated cost for this operation if it completes
2032 currentAssocCost        (10),  -- estimated cost for this association so far
2033 finalOpTimeElapsed            (11),  -- estimated elapsed time for operation if it completes (in .001 sec.)
2034 percentComplete         (12), -- estimated percent complete
2035 currentSearchAssocCost    (13),  -- estimated search cost for association so far
2036 currentPresentAssocCost  (14),  -- estimated present cost for this association so far
2037 currentConnectAssocCost    (15),  -- estimated connect time cost for association so far
2038 currentOtherAssocCost    (16)  -- estimated other cost (not included in 13-15) for association so far
2039                   }
2040 END
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054 ResourceReport-Format-Resource-2
2055 {Z39-50-resourceReport resource-2 (2)} DEFINITIONS ::=
2056 BEGIN
2057 IMPORTS InternationalString, StringOrNumeric, IntUnit FROM Z39-50-APDU-1995;
2058 --
2059 ResourceReport ::= SEQUENCE{
2060 estimates    [1]   IMPLICIT SEQUENCE OF Estimate OPTIONAL,
2061 message      [2]   IMPLICIT InternationalString OPTIONAL}
2062 --
2063 Estimate ::= SEQUENCE{
2064 type      [1]   StringOrNumeric,
2065               -- Numeric values of 1-16 are the same as used in Resource-1.
2066 value      [2]   IMPLICIT IntUnit
2067               -- When expressing currency:
2068               --    unitSystem (of Unit) is 'z3950'  (case insensitive)
2069               --    unitType is 'iso4217-1990'       (case insensitive)
2070               --    unit is currency code from ISO 4217-1990.
2071 }
2072 END
2073
2074
2075
2076
2077
2078 AccessControlFormat-prompt-1
2079 {Z39-50-accessControl prompt-1 (1)} DEFINITIONS ::=
2080 BEGIN
2081 IMPORTS InternationalString, DiagRec FROM Z39-50-APDU-1995;
2082 --
2083 PromptObject ::= CHOICE{
2084   challenge      [1] IMPLICIT Challenge,
2085    response        [2] IMPLICIT Response}
2086
2087   Challenge ::= SEQUENCE OF SEQUENCE {
2088     promptId      [1] PromptId,
2089                     -- Target supplies a number (for an enumerated prompt) or string (for a non
2090                     -- -enumerated prompt), for each prompt, and the origin returns it in response, for
2091                     -- this prompt, so target may correlate the prompt response with the prompt.
2092     defaultResponse  [2] IMPLICIT InternationalString OPTIONAL,
2093      promptInfo      [3] CHOICE{
2094                     character  [1] IMPLICIT InternationalString,
2095                     encrypted  [2] IMPLICIT Encryption} OPTIONAL,
2096                     -- Information corresponding to an enumerated prompt. For example if 'type', within
2097                     -- PromptId, is 'copyright', then promptInfo may contain a copyright statement.
2098     regExpr        [4] IMPLICIT InternationalString OPTIONAL,
2099                               -- A regular expression that promptResponse should match. See IEEE 1003.2
2100                     -- Volume 1, Section 2.8 "Regular Expression Notation." For example if promptId
2101                     -- is "Year of publication," regExpr might be "19[89][0-9]|20[0-9][0-9]".
2102     responseRequired  [5] IMPLICIT NULL OPTIONAL,
2103      allowedValues    [6] IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
2104                         -- e.g. promptId="Desired color"; allowed = 'red', 'blue','Green'.
2105     shouldSave      [7] IMPLICIT NULL OPTIONAL,
2106                         -- Target recommends that origin save the data that it prompts from the
2107                      -- user corresponding to this prompt, because it is likely to be requested again (so
2108                     -- origin might not have to prompt the user next time).
2109         dataType        [8] IMPLICIT INTEGER{
2110                              integer        (1),
2111                           date            (2),
2112                         float           (3),
2113                         alphaNumeric  (4),
2114                         url-urn       (5),
2115                         boolean       (6)} OPTIONAL,
2116                         -- Target telling origin type of data it wants. E.g., if "date" is specified,
2117                         -- presumably the origin will try to prompt something "date-like" from the user.
2118         diagnostic       [9] IMPLICIT EXTERNAL OPTIONAL
2119                           -- Intended for repeat requests when there is an error the origin
2120                         -- should report to the user from previous attempt.
2121                 }
2122
2123
2124   Response ::= SEQUENCE OF SEQUENCE {
2125       promptId    [1] PromptId,
2126                   -- Corresponds to a prompt in the challenge, or may be unprompted, for
2127                   -- example "newPassword." If unprompted, should be "enumerated."
2128                   -- If this responds to a non-enumerated prompt, then nonEnumeratedPrompt
2129                    -- should contain the prompt string from the challenge.
2130     promptResponse  [2] CHOICE{
2131                     string      [1] IMPLICIT InternationalString,
2132                     accept      [2] IMPLICIT BOOLEAN,
2133                     acknowledge  [3] IMPLICIT NULL,
2134                     diagnostic    [4] DiagRec,
2135                      encrypted    [5] IMPLICIT Encryption}}
2136
2137
2138  PromptId ::= CHOICE{
2139   enummeratedPrompt    [1] IMPLICIT SEQUENCE{
2140                       type            [1] IMPLICIT INTEGER{
2141                                       groupId    (0),
2142                                       userId     (1),
2143                                       password   (2),
2144                                       newPassword  (3),
2145                                       copyright    (4),
2146                             -- When type on Challenge is 'copyright', promptInfo has text of
2147                             -- copyright message to be displayed verbatim to the user. If
2148                             -- promptResponse indicates 'acceptance', this indicates the user has been
2149                             -- shown, and accepted, the terms of the copyright. This is not intended
2150                             -- to be legally binding, but provides a good-faith attempt on
2151                             -- the part of the target to inform the user of the copyright.
2152                                       sessionId      (5)},
2153                       suggestedString    [2] IMPLICIT InternationalString OPTIONAL},
2154    nonEnumeratedPrompt  [2] IMPLICIT InternationalString}
2155
2156
2157  Encryption ::= SEQUENCE{
2158   cryptType    [1] IMPLICIT OCTET STRING OPTIONAL,
2159   credential    [2] IMPLICIT OCTET STRING OPTIONAL,
2160                     --random number, SALT, or other factor
2161   data        [3] IMPLICIT OCTET STRING}
2162
2163 END
2164
2165
2166
2167
2168 AccessControlFormat-des-1
2169 {Z39-50-accessControlFormat  des-1 (2)} DEFINITIONS ::=
2170 BEGIN
2171     DES-RN-Object ::= CHOICE {
2172       challenge    [1]    IMPLICIT DRNType,
2173       response      [2]    IMPLICIT DRNType}
2174     DRNType ::= SEQUENCE{
2175           userId        [1]    IMPLICIT OCTET STRING OPTIONAL,
2176           salt          [2]    IMPLICIT OCTET STRING OPTIONAL,
2177           randomNumber  [3]    IMPLICIT OCTET STRING}
2178 END
2179
2180
2181 AccessControlFormat-krb-1
2182 {Z39-50-accessControlFormat  krb-1 (3)} DEFINITIONS ::=
2183 BEGIN
2184 IMPORTS InternationalString FROM Z39-50-APDU-1995;
2185
2186      KRBObject ::= CHOICE {
2187        challenge   [1]    IMPLICIT KRBRequest,
2188        response    [2]    IMPLICIT KRBResponse}
2189      KRBRequest ::= SEQUENCE{
2190            service         [1]   IMPLICIT InternationalString,
2191            instance        [2]   IMPLICIT InternationalString OPTIONAL,
2192            realm          [3]   IMPLICIT InternationalString OPTIONAL}
2193         -- target requests a ticket for the given service, instance, and realm
2194      KRBResponse ::= SEQUENCE{
2195            userid            [1]   IMPLICIT InternationalString OPTIONAL,
2196            ticket           [2]  IMPLICIT OCTET STRING}
2197         -- origin responds with a ticket for the requested service
2198 END
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208 ESFormat-PersistentResultSet
2209 {Z39-50-extendedService PersistentResultSet (1)} DEFINITIONS ::=
2210 BEGIN
2211 IMPORTS InternationalString FROM Z39-50-APDU-1995;
2212 PersistentResultSet ::= CHOICE{
2213     esRequest    [1] IMPLICIT SEQUENCE{
2214         toKeep    [1] IMPLICIT NULL,
2215         notToKeep  [2] OriginPartNotToKeep OPTIONAL},
2216     taskPackage  [2] IMPLICIT SEQUENCE{
2217         originPart  [1] IMPLICIT NULL,
2218         targetPart  [2] TargetPart OPTIONAL}}
2219 OriginPartNotToKeep ::= SEQUENCE{
2220   originSuppliedResultSet  [1] IMPLICIT InternationalString OPTIONAL,
2221           -- name of transient result set, supplied on request, mandatory unless function is 'delete'
2222   replaceOrAppend    [2] IMPLICIT INTEGER{  -- only if function is "modify"
2223           replace    (1),
2224           append    (2)} OPTIONAL}
2225 TargetPart ::= SEQUENCE{
2226   targetSuppliedResultSet  [1] IMPLICIT InternationalString OPTIONAL,
2227           -- Name of transient result set, supplied by target, representing the persistent result set to which
2228           -- package pertains. Meaningful only when package  is presented. (i.e. not on ES response).
2229   numberOfRecords  [2] IMPLICIT INTEGER OPTIONAL}
2230 END
2231
2232
2233 ESFormat-PersistentQuery
2234 {Z39-50-extendedService PersistentQuery (2)} DEFINITIONS ::=
2235 BEGIN
2236 IMPORTS Query, InternationalString, OtherInformation FROM Z39-50-APDU-1995;
2237 PersistentQuery ::= CHOICE{
2238     esRequest      [1] IMPLICIT SEQUENCE{
2239         toKeep    [1] OriginPartToKeep OPTIONAL,
2240         notToKeep  [2] OriginPartNotToKeep},
2241     taskPackage    [2] IMPLICIT SEQUENCE{
2242         originPart  [1] OriginPartToKeep OPTIONAL,
2243         targetPart  [2] TargetPart}}
2244 OriginPartToKeep ::= SEQUENCE{
2245   dbNames        [2] IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
2246   additionalSearchInfo  [3] OtherInformation OPTIONAL}
2247 OriginPartNotToKeep ::= CHOICE{
2248   package    [1] IMPLICIT InternationalString,
2249   query    [2] Query}
2250 TargetPart ::= Query
2251 END
2252
2253 ESFormat-PeriodicQuerySchedule
2254 {Z39-50-extendedService PeriodicQuerySchedule (3)} DEFINITIONS ::=
2255 BEGIN
2256 IMPORTS Query, InternationalString, IntUnit FROM Z39-50-APDU-1995
2257 ExportSpecification, Destination FROM ESFormat-ExportSpecification;
2258
2259 PeriodicQuerySchedule ::= CHOICE{
2260     esRequest    [1] IMPLICIT SEQUENCE{
2261               toKeep    [1] OriginPartToKeep,
2262               notToKeep  [2] OriginPartNotToKeep},
2263     taskPackage    [2] IMPLICIT SEQUENCE{
2264               originPart  [1] OriginPartToKeep,
2265               targetPart  [2] TargetPart}}
2266
2267 OriginPartToKeep ::=SEQUENCE{
2268   activeFlag          [1] IMPLICIT BOOLEAN,
2269   databaseNames        [2] IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
2270   resultSetDisposition      [3] IMPLICIT INTEGER{
2271                     replace    (1),
2272                     append    (2),
2273                     createNew  (3)  -- Only if origin and target have agreement about
2274                             -- naming convention for the resulting package,
2275                              -- and only if no result set is specified.
2276                 } OPTIONAL,   -- Mandatory on 'create' if result set is specified, in
2277                         -- which case it must be 'replace' or 'append.
2278   alertDestination        [4] Destination OPTIONAL,
2279   exportParameters      [5] CHOICE{
2280                     packageName  [1]   IMPLICIT InternationalString,
2281                     exportPackage  [2] ExportSpecification} OPTIONAL}
2282
2283 OriginPartNotToKeep ::= SEQUENCE{
2284   querySpec           [1] CHOICE{
2285                     actualQuery    [1] Query,
2286                     packageName  [2] IMPLICIT InternationalString} OPTIONAL,
2287                   -- mandatory for 'create'
2288   originSuggestedPeriod    [2] Period OPTIONAL,  -- mandatory for 'create'
2289   expiration          [3] IMPLICIT GeneralizedTime OPTIONAL,
2290   resultSetPackage        [4] IMPLICIT InternationalString OPTIONAL}
2291
2292 TargetPart ::= SEQUENCE{
2293   actualQuery        [1] Query,
2294   targetStatedPeriod    [2] Period,
2295                   -- Target supplies the period, which may be same as origin proposed.
2296   expiration        [3] IMPLICIT GeneralizedTime OPTIONAL,
2297                   -- Target supplies value for task package. It may be the same as origin
2298                   -- proposed or different from (and overrides) origin proposal, but if
2299                   -- omitted, there is no expiration.
2300   resultSetPackage      [4] IMPLICIT InternationalString OPTIONAL,
2301                   -- May be omitted only if exportParameters was supplied. Target
2302                   -- supplies same name as origin supplied, if origin did supply a name.
2303   lastQueryTime      [5] IMPLICIT GeneralizedTime,
2304   lastResultNumber    [6] IMPLICIT INTEGER,
2305   numberSinceModify    [7] IMPLICIT INTEGER OPTIONAL}
2306
2307
2308
2309
2310   Period ::= CHOICE{
2311                 unit             [1] IMPLICIT IntUnit,
2312                  businessDaily     [2] IMPLICIT NULL,
2313               continuous       [3] IMPLICIT NULL,
2314               other         [4] IMPLICIT InternationalString}
2315 END
2316
2317
2318 ESFormat-ItemOrder
2319 {Z39-50-extendedService ItemOrder (4)} DEFINITIONS ::=
2320 BEGIN
2321 IMPORTS InternationalString FROM Z39-50-APDU-1995;
2322 ItemOrder ::= CHOICE{
2323     esRequest  [1] IMPLICIT SEQUENCE{
2324               toKeep    [1] OriginPartToKeep OPTIONAL,
2325               notToKeep  [2] OriginPartNotToKeep},
2326     taskPackage  [2] IMPLICIT SEQUENCE{
2327               originPart  [1] OriginPartToKeep OPTIONAL,
2328               targetPart  [2] TargetPart}}
2329 OriginPartToKeep ::= SEQUENCE{
2330   supplDescription    [1] IMPLICIT EXTERNAL OPTIONAL,
2331   contact        [2] IMPLICIT SEQUENCE{
2332                        name  [1]   IMPLICIT InternationalString OPTIONAL,
2333                          phone  [2]   IMPLICIT InternationalString OPTIONAL,
2334                        email  [3]   IMPLICIT InternationalString OPTIONAL} OPTIONAL,
2335   addlBilling      [3] IMPLICIT SEQUENCE{
2336                 paymentMethod    [1]   CHOICE{
2337                                   billInvoice              [0] IMPLICIT NULL,
2338                                     prepay                [1] IMPLICIT NULL,
2339                                     depositAccount        [2] IMPLICIT NULL,
2340                                     creditCard          [3] IMPLICIT CreditCardInfo,
2341                     cardInfoPreviouslySupplied  [4] IMPLICIT NULL,
2342                     privateKnown        [5] IMPLICIT NULL,
2343                     privateNotKnown      [6] IMPLICIT EXTERNAL},
2344                 customerReference  [2] IMPLICIT InternationalString OPTIONAL,
2345                      customerPONumber  [3] IMPLICIT InternationalString OPTIONAL}
2346                                  OPTIONAL}
2347 CreditCardInfo   ::= SEQUENCE{
2348        nameOnCard    [1] IMPLICIT InternationalString,
2349       expirationDate    [2] IMPLICIT InternationalString,
2350     cardNumber      [3] IMPLICIT InternationalString}
2351
2352 OriginPartNotToKeep ::= SEQUENCE{ -- Corresponds to 'requestedItem' in service definition.
2353       --  Must supply at least one, and may supply both.
2354   resultSetItem    [1]   IMPLICIT SEQUENCE{
2355                 resultSetId    [1]   IMPLICIT InternationalString,
2356                     item      [2]   IMPLICIT INTEGER} OPTIONAL,
2357   itemRequest      [2] IMPLICIT EXTERNAL OPTIONAL
2358                 -- When itemRequest is an ILL-Request APDU,
2359                 -- use OID {iso standard 10161 abstract-syntax (2) ill-apdus (1)}
2360               }
2361
2362 TargetPart ::= SEQUENCE{
2363   itemRequest      [1]  IMPLICIT EXTERNAL OPTIONAL,
2364     -- When itemRequest is an ILL-Request APDU, use OID 1.0.10161.2.1 (as above)
2365   statusOrErrorReport  [2] IMPLICIT EXTERNAL OPTIONAL,
2366     -- When statusOrErrorReport is an ILL Status-Or-Error-Report APDU, use OID  1.0.10161.2.1 (as above)
2367   auxiliaryStatus    [3]  IMPLICIT INTEGER{
2368                 notReceived      (1),
2369                 loanQueue      (2),
2370                 forwarded      (3),
2371                 unfilledCopyright  (4),
2372                 filledCopyright    (5)} OPTIONAL}
2373 END
2374
2375
2376
2377
2378 ESFormat-Update0
2379 {Z39-50-extendedService Update (5)} DEFINITIONS ::=
2380 BEGIN
2381 IMPORTS DiagRec, InternationalString FROM Z39-50-APDU-1995;
2382 Update ::= CHOICE{
2383     esRequest  [1] IMPLICIT SEQUENCE{
2384               toKeep    [1] OriginPartToKeep,
2385               notToKeep  [2] OriginPartNotToKeep},
2386     taskPackage  [2] IMPLICIT SEQUENCE{
2387               originPart  [1] OriginPartToKeep,
2388               targetPart  [2] TargetPart}}
2389
2390
2391 OriginPartToKeep ::= SEQUENCE{
2392   action          [1] IMPLICIT INTEGER{
2393                    recordInsert    (1),
2394                    recordReplace  (2),
2395                   recordDelete  (3),
2396                   elementUpdate  (4)},
2397   databaseName      [2] IMPLICIT InternationalString,
2398   schema          [3] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
2399   elementSetName      [4] IMPLICIT InternationalString OPTIONAL}
2400
2401
2402 OriginPartNotToKeep ::= SuppliedRecords
2403
2404
2405 TargetPart ::= SEQUENCE{
2406   updateStatus    [1] IMPLICIT INTEGER{
2407                   success  (1),
2408                   partial  (2),
2409                   failure  (3)},
2410   globalDiagnostics  [2] IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
2411                 -- These are non-surrogate diagnostics relating to the task,
2412                 -- not to individual records.
2413   taskPackageRecords  [3] IMPLICIT SEQUENCE OF TaskPackageRecordStructure
2414                 -- There should be a TaskPackageRecordStructure for every record
2415                 -- supplied. The target should create such a structure for every
2416                       -- record immediately upon creating the task package to include
2417                 -- correlation information and status. The record itself would not
2418                 -- be included until processing for that record is complete.
2419             }
2420
2421 -- Auxiliary definitions for Update
2422 SuppliedRecords ::= SEQUENCE OF SEQUENCE{
2423   recordId    [1] CHOICE{
2424               number  [1] IMPLICIT INTEGER,
2425               string  [2] IMPLICIT InternationalString,
2426               opaque  [3]  IMPLICIT OCTET STRING} OPTIONAL,
2427   supplementalId  [2] CHOICE{
2428               timeStamp    [1] IMPLICIT GeneralizedTime,
2429               versionNumber  [2] IMPLICIT InternationalString,
2430               previousVersion  [3] IMPLICIT EXTERNAL} OPTIONAL,
2431   correlationInfo  [3] IMPLICIT CorrelationInfo OPTIONAL,
2432   record      [4] IMPLICIT EXTERNAL}
2433
2434 CorrelationInfo ::= SEQUENCE{
2435           -- origin may supply one or both for any record:
2436   note  [1] IMPLICIT InternationalString OPTIONAL,
2437   id    [2] IMPLICIT INTEGER OPTIONAL}
2438
2439 TaskPackageRecordStructure ::= SEQUENCE{
2440     recordOrSurDiag  [1] CHOICE {
2441                 record    [1] IMPLICIT EXTERNAL,
2442                         -- Choose 'record' if recordStatus is 'success', and
2443                         -- elementSetName was supplied.
2444                 diagnostic  [2] DiagRec
2445                         -- Choose 'diagnostic', if RecordStatus is failure.
2446                                 } OPTIONAL,
2447                 -- The parameter recordOrSurDiag will thus be omitted only if
2448                 -- 'elementSetName' was omitted and recordStatus is
2449                 -- 'success'; or if record status is 'queued' or in 'process'.
2450     correlationInfo    [2] IMPLICIT CorrelationInfo OPTIONAL,
2451                 -- This should be included if it was supplied by the origin.
2452     recordStatus      [3] IMPLICIT INTEGER{
2453                   success    (1),
2454                   queued    (2),
2455                   inProcess  (3),
2456                   failure    (4)}}
2457 END
2458
2459
2460 ESFormat-ExportSpecification
2461 {Z39-50-extendedService ExportSpecification (6)} DEFINITIONS ::=
2462 BEGIN
2463 EXPORTS ExportSpecification, Destination; IMPORTS CompSpec, InternationalString FROM Z39-50-APDU-1995;
2464 ExportSpecification ::= CHOICE{
2465     esRequest    [1] IMPLICIT SEQUENCE{
2466         toKeep    [1] OriginPartToKeep,
2467         notToKeep  [2] IMPLICIT NULL},
2468     taskPackage    [2] IMPLICIT SEQUENCE{
2469         originPart  [1] OriginPartToKeep,
2470         targetPart  [2] IMPLICIT NULL}}
2471 OriginPartToKeep ::= SEQUENCE{
2472   composition        [1] IMPLICIT CompSpec,
2473   exportDestination    [2] Destination}
2474
2475   Destination ::= CHOICE{
2476   phoneNumber    [1]    IMPLICIT InternationalString,
2477   faxNumber      [2]   IMPLICIT InternationalString,
2478   x400address      [3]   IMPLICIT InternationalString,
2479   emailAddress    [4]   IMPLICIT InternationalString,
2480   pagerNumber    [5]   IMPLICIT InternationalString,
2481   ftpAddress      [6]   IMPLICIT InternationalString,
2482   ftamAddress    [7]   IMPLICIT InternationalString,
2483   printerAddress    [8]   IMPLICIT InternationalString,
2484   other        [100]  IMPLICIT SEQUENCE{
2485                   vehicle      [1]  IMPLICIT InternationalString  OPTIONAL,
2486                   destination    [2] IMPLICIT InternationalString}}
2487 END
2488
2489
2490
2491
2492 ESFormat-ExportInvocation
2493 {Z39-50-extendedService ExportInvocation (7)} DEFINITIONS ::=
2494 BEGIN
2495 IMPORTS InternationalString, IntUnit FROM Z39-50-APDU-1995
2496 ExportSpecification FROM ESFormat-ExportSpecification;
2497 ExportInvocation ::= CHOICE{
2498     esRequest    [1] IMPLICIT SEQUENCE{
2499         toKeep    [1] OriginPartToKeep,
2500         notToKeep  [2] OriginPartNotToKeep},
2501     taskPackage    [2] IMPLICIT SEQUENCE{
2502         originPart  [1] OriginPartToKeep,
2503         targetPart  [2] TargetPart OPTIONAL}}
2504
2505 OriginPartToKeep ::= SEQUENCE{
2506   exportSpec    [1] CHOICE{
2507               packageName    [1] IMPLICIT InternationalString,
2508               packageSpec    [2] ExportSpecification},
2509   numberOfCopies  [2] IMPLICIT INTEGER}
2510
2511
2512
2513
2514
2515 OriginPartNotToKeep  ::= SEQUENCE{
2516   resultSetId      [1] IMPLICIT InternationalString,
2517   records        [2] CHOICE{
2518                 all    [1] IMPLICIT NULL,
2519                 ranges  [2]   IMPLICIT SEQUENCE OF SEQUENCE{
2520                         start  [1] IMPLICIT INTEGER,
2521                         count  [2] IMPLICIT INTEGER OPTIONAL
2522                           -- Count may be omitted only on last range, to indicate
2523                           -- "all remaining records beginning with 'start'."
2524                     }}}
2525
2526 TargetPart   ::= SEQUENCE{
2527     estimatedQuantity    [1] IMPLICIT IntUnit OPTIONAL,
2528     quantitySoFar      [2] IMPLICIT IntUnit OPTIONAL,
2529     estimatedCost      [3] IMPLICIT IntUnit OPTIONAL,
2530     costSoFar        [4] IMPLICIT IntUnit OPTIONAL}
2531 END
2532
2533
2534
2535 UserInfoFormat-searchResult-1
2536 {Z39-50-userInfoFormat searchResult-1 (1)} DEFINITIONS ::=
2537 BEGIN
2538 IMPORTS DatabaseName, Term, Query, IntUnit, InternationalString FROM Z39-50-APDU-1995;
2539 SearchInfoReport ::= SEQUENCE OF SEQUENCE{
2540   subqueryId      [1] IMPLICIT InternationalString OPTIONAL,
2541                            -- shorthand identifier of subquery
2542   fullQuery        [2] IMPLICIT BOOLEAN,     -- 'true' means this is the full query; 'false',
2543                           -- a sub-query
2544   subqueryExpression    [3] QueryExpression OPTIONAL,  -- A subquery of the query as
2545                           -- submitted. May be whole query;
2546                           -- if so, "fullQuery" should be 'true'.
2547   subqueryInterpretation  [4] QueryExpression OPTIONAL,  -- how target interpreted subquery
2548   subqueryRecommendation  [5] QueryExpression OPTIONAL,  -- target-recommended alternative
2549   subqueryCount      [6] IMPLICIT INTEGER OPTIONAL,  -- Number of records for this
2550                           -- subQuery, across all of the specified
2551                           -- databases. (If during search, via resource
2552                            -- control, number of records so far).
2553   subqueryWeight     [7] IMPLICIT IntUnit OPTIONAL,  -- relative weight of this subquery
2554   resultsByDB          [8] IMPLICIT ResultsByDB OPTIONAL}
2555
2556 ResultsByDB ::= SEQUENCE OF SEQUENCE{
2557   databases      [1] CHOICE{
2558             all     [1] IMPLICIT NULL,
2559                   -- applies across all of the databases in Search PDU
2560             list    [2]  IMPLICIT SEQUENCE OF DatabaseName
2561                   -- applies across all databases in this list
2562               },
2563   count        [2] IMPLICIT INTEGER OPTIONAL,
2564             -- Number of records for query component (and, as above, if during search,
2565              -- via resource control, number of records so far).
2566   resultSetName    [3] IMPLICIT InternationalString OPTIONAL
2567                         -- Target-assigned result set by which subQuery is available. Should not
2568              -- be provided unless processing for this query component is concluded (i.e.,
2569             -- when this report comes during search, via resource control, as opposed
2570             -- to after search, via additionalSearchInfo).
2571               }
2572
2573 QueryExpression ::=  CHOICE {
2574                 term   [1] IMPLICIT SEQUENCE{
2575               queryTerm  [1]  Term,
2576               termComment            [2] IMPLICIT InternationalString OPTIONAL},
2577            query  [2] Query}
2578 END
2579
2580
2581
2582 ElementSpecificationFormat-eSpec-1
2583 {Z39-50-elementSpec eSpec-1 (1)} DEFINITIONS ::=
2584 BEGIN
2585 IMPORTS Variant FROM RecordSyntax-generic
2586 StringOrNumeric, InternationalString FROM Z39-50-APDU-1995;
2587 --
2588 Espec-1 ::= SEQUENCE{
2589   elementSetNames    [1] IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
2590                   -- Origin may include one or more element set names, each
2591                   -- specifying a set of elements. Each of the elements is to be
2592                   -- treated as an elementRequest in the form of simpleElement,
2593                   -- where occurrence is 1.
2594   defaultVariantSetId    [2] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
2595                   -- If supplied, applies whenever variantRequest
2596                   -- does not include variantSetId.
2597   defaultVariantRequest  [3] IMPLICIT Variant OPTIONAL,
2598                   -- If supplied, then for each simple elementRequest that does not
2599                    -- include a variantRequest, the defaultVariantRequest applies.
2600                   -- (defaultVariantRequest does not apply to a compositeRequest.)
2601   defaultTagType      [4] IMPLICIT INTEGER OPTIONAL,
2602                   -- If supplied, applies whenever 'tagType' (within 'tag' within TagPath)
2603                   -- is omitted.
2604   elements        [5] IMPLICIT SEQUENCE OF ElementRequest OPTIONAL}
2605 --
2606
2607 ElementRequest::= CHOICE{
2608   simpleElement    [1]   IMPLICIT SimpleElement,
2609   compositeElement  [2] IMPLICIT SEQUENCE{
2610             elementList    [1] CHOICE{
2611                   primitives    [1]   IMPLICIT SEQUENCE OF InternationalString,
2612                               -- Origin may specify one or more element
2613                               -- set names, each identifying a set of elements,
2614                               -- and the composite element is the union.
2615                   specs      [2] IMPLICIT SEQUENCE OF SimpleElement},
2616
2617             deliveryTag    [2] IMPLICIT TagPath,
2618                           -- DeliveryTag tagPath for compositeElement may not
2619                           -- include wildThing or wildPath.
2620             variantRequest  [3] IMPLICIT Variant OPTIONAL}}
2621
2622 SimpleElement ::= SEQUENCE{
2623       path        [1] IMPLICIT TagPath,
2624       variantRequest  [2] IMPLICIT Variant OPTIONAL}
2625
2626
2627 TagPath ::= SEQUENCE OF CHOICE{
2628   specificTag  [1] IMPLICIT SEQUENCE{
2629             tagType  [1] IMPLICIT INTEGER OPTIONAL,
2630                       -- If omitted, then 'defaultTagType' (above) applies, if supplied, and
2631                       -- if not supplied, then default listed in schema applies.
2632             tagValue  [2] StringOrNumeric,
2633              occurrence  [3] Occurrences OPTIONAL
2634                       -- default is "first occurrence"
2635                   },
2636   wildThing  [2] Occurrences,
2637               -- Get Nth "thing" at this level, regardless of tag, for each N specified by
2638             -- "Occurrences" (which may be 'all' meaning match every element at this level).
2639             -- E.g., if "Occurrences" is 3, get third element regardless of its tag or the tag of
2640             -- the first two elements.
2641   wildPath  [3] IMPLICIT NULL
2642               -- Match any tag, at this level or below, that is on a path for which next tag in this
2643               -- TagPath sequence occurs. WildPath may not be last member of the TagPath
2644             -- sequence.
2645                       }
2646 --
2647
2648 Occurrences ::= CHOICE{
2649   all    [1] IMPLICIT NULL,
2650   last    [2] IMPLICIT NULL,
2651   values  [3] IMPLICIT SEQUENCE{
2652           start    [1] IMPLICIT INTEGER,
2653                   -- if 'start' alone is included, then single occurrence is requested
2654           howMany  [2] IMPLICIT INTEGER OPTIONAL
2655                   -- For example, if 'start' is 5 and 'howMany' is 6, then request is for
2656                   -- "occurrences 5 through 10."
2657                   }}
2658 END
2659