Z39-50-APDU-1995 -- OID for this definition, assigned in OID.3.1, is {Z39-50 2 1} 
DEFINITIONS ::=  
BEGIN   -- Z39.50 Maintenance Agency Official Text for ANSI/NISO Z39.50-1995 - July 1995
--
EXPORTS OtherInformation, Term, AttributeSetId, AttributeList, AttributeElement, ElementSetName, SortElement, DatabaseName,
CompSpec, Specification, Permissions, InternationalString, IntUnit, Unit, StringOrNumeric, Query, Records, ResultSetId,
DefaultDiagFormat, DiagRec, Segment;
--

PDU ::= CHOICE{
 initRequest        [20] IMPLICIT InitializeRequest,
 initResponse      [21] IMPLICIT InitializeResponse,
 searchRequest      [22] IMPLICIT SearchRequest,
 searchResponse      [23] IMPLICIT SearchResponse,
 presentRequest      [24] IMPLICIT PresentRequest,
 presentResponse      [25] IMPLICIT PresentResponse,
 deleteResultSetRequest    [26] IMPLICIT DeleteResultSetRequest,
 deleteResultSetResponse    [27] IMPLICIT DeleteResultSetResponse,
 accessControlRequest    [28] IMPLICIT AccessControlRequest,
 accessControlResponse    [29] IMPLICIT AccessControlResponse,
 resourceControlRequest         [30] IMPLICIT ResourceControlRequest,
 resourceControlResponse    [31] IMPLICIT ResourceControlResponse,
 triggerResourceControlRequest  [32] IMPLICIT TriggerResourceControlRequest,
 resourceReportRequest          [33] IMPLICIT ResourceReportRequest,
 resourceReportResponse    [34] IMPLICIT ResourceReportResponse,
 scanRequest         [35] IMPLICIT ScanRequest,
 scanResponse      [36] IMPLICIT ScanResponse,
              -- [37] through [42] reserved
 sortRequest        [43] IMPLICIT SortRequest,
 sortResponse      [44] IMPLICIT SortResponse,
 segmentRequest      [45] IMPLICIT Segment,
 extendedServicesRequest    [46] IMPLICIT ExtendedServicesRequest,
 extendedServicesResponse    [47] IMPLICIT ExtendedServicesResponse,
 close          [48] IMPLICIT Close,
 duplicateDetectionRequest      [49] IMPLICIT DuplicateDetectionRequest,
 duplicateDetectionResponse     [50] IMPLICIT DuplicateDetectionResponse}


-- Initialize APDUs
--
  InitializeRequest ::= SEQUENCE{
  referenceId        ReferenceId OPTIONAL,
  protocolVersion      ProtocolVersion,
  options        Options,
  preferredMessageSize  [5]  IMPLICIT INTEGER,
   exceptionalRecordSize  [6]  IMPLICIT INTEGER,
   idAuthentication    [7]    IdAuthentication OPTIONAL, -- see note below
  implementationId    [110]  IMPLICIT InternationalString OPTIONAL,
  implementationName  [111]  IMPLICIT InternationalString OPTIONAL,
   implementationVersion  [112]  IMPLICIT InternationalString OPTIONAL,   
  userInformationField  [11]  EXTERNAL OPTIONAL,
  otherInfo        OtherInformation OPTIONAL}
--Note:
-- For idAuthentication, the type ANY is retained for compatibility with earlier versions. 
-- For interoperability, the following is recommended:
IdAuthentication ::=
   CHOICE{
      open   VisibleString,
      idPass  SEQUENCE {
      groupId  [0]  IMPLICIT InternationalString OPTIONAL,
      userId   [1]  IMPLICIT InternationalString OPTIONAL,
      password  [2]  IMPLICIT InternationalString OPTIONAL },
      anonymous  NULL,
      other    EXTERNAL
   }
-- May use access control formats for 'other'.  See Appendix 7 ACC.
--
  InitializeResponse ::= SEQUENCE{
  referenceId        ReferenceId OPTIONAL,
   protocolVersion                ProtocolVersion,
  options              Options,
  preferredMessageSize  [5]  IMPLICIT INTEGER,
   exceptionalRecordSize  [6]  IMPLICIT INTEGER,
  result        [12]  IMPLICIT BOOLEAN,    -- reject = FALSE; Accept = TRUE
  implementationId    [110]  IMPLICIT InternationalString OPTIONAL,
  implementationName  [111]  IMPLICIT InternationalString OPTIONAL,
   implementationVersion  [112]  IMPLICIT InternationalString OPTIONAL,   
  userInformationField  [11]  EXTERNAL OPTIONAL,
  otherInfo        OtherInformation OPTIONAL}
-- Begin auxiliary definitions for Init PDUs
  ProtocolVersion  ::=  [3]   IMPLICIT BIT STRING{
    version-1      (0),       -- This bit should always be set, but does not
              -- correspond to any Z39.50 version.
    version-2      (1),              -- "Version 2 supported."
              -- This bit should always be set.
    version-3      (2)        -- "Version 3 supported."
-- Values higher than 'version-3' should be ignored. Both the Initialize request and Initialize Response APDUs
-- include a value string corresponding to the supported versions. The highest common version is selected
-- for use. If there are no versions in common, "Result" in the Init Response should indicate "reject."
-- Note: Versions 1 and 2 are identical. Systems supporting version 2 should indicate support for version
-- 1 as well, for interoperability with systems that indicate support for version 1 only (e.g. ISO 10163-1991
-- implementations).  
  }
  Options  ::= [4] IMPLICIT BIT STRING{ 
      search        (0), 
      present       (1), 
      delSet        (2),
       resourceReport    (3),
      triggerResourceCtrl    (4),
      resourceCtrl       (5), 
      accessCtrl       (6),
      scan         (7),
      sort        (8), 
      -- (not used) (9),
      extendedServices    (10),
      level-1Segmentation    (11),
      level-2Segmentation    (12),
      concurrentOperations  (13),
      namedResultSets    (14),
      encapsulation    (15),
      resultCount    (16),
      negotiationModel (17),
      duplicateDetection (18),
      queryType104 (19),
      pQESCorrection (20),
      stringSchema (21)
}
-- end auxiliary definitions for Init PDUs


--Search APDUs
  SearchRequest ::= SEQUENCE{
  referenceId          ReferenceId OPTIONAL,
      smallSetUpperBound    [13]  IMPLICIT INTEGER,
  largeSetLowerBound    [14]  IMPLICIT INTEGER,
  mediumSetPresentNumber    [15]  IMPLICIT INTEGER,
  replaceIndicator      [16]  IMPLICIT BOOLEAN,
  resultSetName      [17]  IMPLICIT InternationalString,
   databaseNames      [18]   IMPLICIT SEQUENCE OF DatabaseName,
   smallSetElementSetNames    [100]  ElementSetNames OPTIONAL,
    mediumSetElementSetNames  [101]  ElementSetNames OPTIONAL,
  preferredRecordSyntax    [104]  IMPLICIT OBJECT IDENTIFIER OPTIONAL,
  query          [21]  Query,
    -- Following two parameters may be used only if version 3 is in force.
   additionalSearchInfo    [203]  IMPLICIT OtherInformation OPTIONAL,
  otherInfo          OtherInformation OPTIONAL}


-- Query Definitions
  Query  ::=  CHOICE{
      type-0  [0]  ANY,  
        type-1    [1]  IMPLICIT RPNQuery,
        type-2      [2]  OCTET STRING,
        type-100  [100]  OCTET STRING,
        type-101  [101]  IMPLICIT RPNQuery,
       type-102  [102]  OCTET STRING,
       type-104  [104]  IMPLICIT EXTERNAL
}
--
-- Definitions for RPN query
     RPNQuery ::= SEQUENCE{
      attributeSet    AttributeSetId,
      rpn      RPNStructure}
--
  RPNStructure ::= CHOICE{
    op    [0] Operand, 
     rpnRpnOp  [1] IMPLICIT SEQUENCE{
          rpn1    RPNStructure,
                rpn2    RPNStructure,
                op    Operator }} 
  Operand ::= CHOICE{
    attrTerm  AttributesPlusTerm, 
    resultSet  ResultSetId, 
          -- If version 2 is in force: 
          --   - If query type is 1, one of the above two must be chosen; 
          --   - resultAttr (below) may be used only if query type is 101. 
    resultAttr  ResultSetPlusAttributes}

  AttributesPlusTerm ::= [102] IMPLICIT SEQUENCE{
         attributes  AttributeList, 
        term    Term}
  ResultSetPlusAttributes ::= [214] IMPLICIT SEQUENCE{
        resultSet  ResultSetId,
        attributes  AttributeList}
  AttributeList ::=    [44]  IMPLICIT SEQUENCE OF AttributeElement
--
  Term ::= CHOICE{
    general      [45]  IMPLICIT OCTET STRING,
              -- values below may be used only if version 3 is in force
    numeric      [215]  IMPLICIT INTEGER,
    characterString    [216]  IMPLICIT InternationalString,
    oid        [217]  IMPLICIT OBJECT IDENTIFIER,
    dateTime      [218]  IMPLICIT GeneralizedTime,
    external      [219]  IMPLICIT EXTERNAL,
    integerAndUnit    [220] IMPLICIT IntUnit,
    null        [221] IMPLICIT NULL}   

  Operator ::= [46] CHOICE{
         and    [0] IMPLICIT NULL,
            or    [1] IMPLICIT NULL,
                and-not  [2] IMPLICIT NULL,
              -- If version 2 is in force: 
              --  - For query type 1, one of the above three must be chosen;
              --  - prox (below) may be used only if query type is 101. 
        prox    [3] IMPLICIT ProximityOperator}
  AttributeElement  ::=  SEQUENCE{
    attributeSet    [1]    IMPLICIT AttributeSetId OPTIONAL,
                -- Must be omitted if version 2 is in force.
                -- If included, overrides value of attributeSet
                -- in RPNQuery above, but only for this attribute.
    attributeType  [120]  IMPLICIT INTEGER,
    attributeValue    CHOICE{
              numeric  [121]   IMPLICIT INTEGER,
                  -- If version 2 is in force, 
                  -- Must select 'numeric' for attributeValue.

      complex  [224] IMPLICIT SEQUENCE{ 
               list      [1] IMPLICIT SEQUENCE OF StringOrNumeric,
                    semanticAction  [2] IMPLICIT SEQUENCE OF INTEGER OPTIONAL}}}
                       

  ProximityOperator ::= SEQUENCE{
    exclusion      [1] IMPLICIT BOOLEAN OPTIONAL,
    distance      [2] IMPLICIT INTEGER,
    ordered      [3] IMPLICIT BOOLEAN,
    relationType      [4] IMPLICIT INTEGER{
              lessThan      (1),
              lessThanOrEqual    (2),
              equal        (3),
              greaterThanOrEqual    (4),
              greaterThan      (5),
              notEqual      (6)},
    proximityUnitCode    [5] CHOICE{
              known  [1] IMPLICIT KnownProximityUnit,
              private  [2] IMPLICIT INTEGER}}
--
    KnownProximityUnit ::= INTEGER{
          character  (1),
          word     (2),
          sentence   (3),
          paragraph   (4),
          section   (5),
          chapter   (6),
          document   (7),
          element  (8),
          subelement  (9),
          elementType  (10),
           byte    (11) -- Version 3 only
          }
-- End definitions for RPN Query


SearchResponse ::= SEQUENCE{
  referenceId        ReferenceId OPTIONAL,
  resultCount       [23]  IMPLICIT INTEGER,
  numberOfRecordsReturned  [24]  IMPLICIT INTEGER,
  nextResultSetPosition  [25]  IMPLICIT INTEGER,
  searchStatus      [22]  IMPLICIT BOOLEAN,
  resultSetStatus    [26]  IMPLICIT INTEGER{
              subset    (1),
                 interim  (2), 
               none    (3),
	       estimate(4)
	       } OPTIONAL,
  presentStatus        PresentStatus  OPTIONAL,
    records        Records OPTIONAL,
    -- Following two parameters may be used only if version 3 is in force.
  additionalSearchInfo  [203]  IMPLICIT OtherInformation OPTIONAL,
  otherInfo        OtherInformation OPTIONAL}
--Retrieval APDUs 
  PresentRequest ::= SEQUENCE{
  referenceId          ReferenceId OPTIONAL,
      resultSetId          ResultSetId,
  resultSetStartPoint      [30]  IMPLICIT INTEGER,
  numberOfRecordsRequested  [29]  IMPLICIT INTEGER,
  additionalRanges      [212]  IMPLICIT SEQUENCE OF Range OPTIONAL,
      -- additionalRanges may be included only if version 3 is in force.
  recordComposition      CHOICE{
                simple  [19]         ElementSetNames,
                -- must choose 'simple' if version 2 is in force
                complex  [209]               IMPLICIT CompSpec} OPTIONAL,
  preferredRecordSyntax    [104]  IMPLICIT OBJECT IDENTIFIER OPTIONAL,
  maxSegmentCount      [204]  IMPLICIT INTEGER OPTIONAL, -- level 1 or 2
  maxRecordSize      [206]  IMPLICIT INTEGER OPTIONAL, -- level 2 only
  maxSegmentSize      [207]  IMPLICIT INTEGER OPTIONAL, -- level 2 only
  otherInfo          OtherInformation OPTIONAL}
--
  Segment ::= SEQUENCE{
      -- Segment PDU may only be used when version 3 is in force, 
      -- and only when segmentation is in effect.
   referenceId          ReferenceId OPTIONAL,
     numberOfRecordsReturned    [24]  IMPLICIT INTEGER,
  segmentRecords      [0]  IMPLICIT SEQUENCE OF NamePlusRecord,
  otherInfo          OtherInformation OPTIONAL}
--
  PresentResponse ::= SEQUENCE{
  referenceId          ReferenceId OPTIONAL,
  numberOfRecordsReturned    [24]  IMPLICIT INTEGER,
   nextResultSetPosition    [25]  IMPLICIT INTEGER,
    presentStatus          PresentStatus,
  records          Records OPTIONAL,
  otherInfo          OtherInformation OPTIONAL} 
-- begin auxiliary definitions for Search and Present APDUs

-- begin definition of records
  Records ::= CHOICE{
  responseRecords      [28]  IMPLICIT SEQUENCE OF NamePlusRecord,
  nonSurrogateDiagnostic     [130]  IMPLICIT DefaultDiagFormat,
  multipleNonSurDiagnostics   [205]  IMPLICIT SEQUENCE OF DiagRec} 
--
  NamePlusRecord  ::=  SEQUENCE{
  name    [0] IMPLICIT DatabaseName OPTIONAL,
  record  [1] CHOICE{
        retrievalRecord        [1] EXTERNAL,
        surrogateDiagnostic    [2] DiagRec, 
          -- Must select one of the above two, retrievalRecord or
          -- surrogateDiagnostic, unless 'level 2 segmentation' is in effect.
        startingFragment    [3] FragmentSyntax,
        intermediateFragment  [4] FragmentSyntax,
        finalFragment    [5] FragmentSyntax}}
  FragmentSyntax ::= CHOICE{
    externallyTagged    EXTERNAL,
    notExternallyTagged  OCTET STRING}

  DiagRec ::= CHOICE{
      defaultFormat    DefaultDiagFormat,
                -- Must choose defaultFormat if version 2 is in effect.
      externallyDefined    EXTERNAL}

  DefaultDiagFormat::= SEQUENCE{ 
  diagnosticSetId  OBJECT IDENTIFIER,
  condition    INTEGER,
  addinfo      CHOICE{
           v2Addinfo  VisibleString,  -- version 2
           v3Addinfo  InternationalString  -- version 3
            }}
  -- end definition of records
  Range  ::= SEQUENCE{
    startingPosition    [1] IMPLICIT INTEGER,
    numberOfRecords    [2] IMPLICIT INTEGER} 
--
  ElementSetNames ::= CHOICE {
    genericElementSetName  [0] IMPLICIT InternationalString,
    databaseSpecific    [1] IMPLICIT SEQUENCE OF SEQUENCE{
              dbName  DatabaseName,
              esn    ElementSetName}}

  PresentStatus   ::=    [27]  IMPLICIT INTEGER{
                            success  (0),
                             partial-1   (1),
                              partial-2   (2),
              partial-3   (3),
                                      partial-4   (4),
                               failure    (5)}

-- begin definition of composition specification
  CompSpec ::= SEQUENCE{
  selectAlternativeSyntax  [1] IMPLICIT BOOLEAN,
            -- See comment for recordSyntax, below.
  generic             [2] IMPLICIT Specification OPTIONAL,
  dbSpecific      [3] IMPLICIT SEQUENCE OF SEQUENCE{
                db  [1] DatabaseName,
                spec  [2] IMPLICIT Specification} OPTIONAL,
    -- At least one of generic and dbSpecific must occur, and both may occur. If both, then for
     -- any record not in the list of databases within dbSpecific, generic applies.
   recordSyntax               [4] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL
               -- For each record, the target selects the first record syntax
               -- in this list that it can support.  If the list is exhausted, the
               -- target may select an alternative syntax if
               -- selectAlternativeSyntax is 'true'.
        }
  Specification ::= SEQUENCE{
  schema CHOICE {
              oid [1]   IMPLICIT OBJECT IDENTIFIER,
              uri [300] IMPLICIT InternationalString
  } OPTIONAL,
  elementSpec    [2] CHOICE{
              elementSetName   [1] IMPLICIT InternationalString,
          externalEspec  [2] IMPLICIT EXTERNAL} OPTIONAL}
-- end definition of composition specification
-- end auxiliary definitions for search and response APDUs

-- Delete APDUs
  DeleteResultSetRequest ::= SEQUENCE{
  referenceId          ReferenceId OPTIONAL,
      deleteFunction      [32]  IMPLICIT INTEGER{
                    list   (0),
                    all   (1)},
   resultSetList          SEQUENCE OF ResultSetId OPTIONAL,
  otherInfo          OtherInformation OPTIONAL} 
--
  DeleteResultSetResponse ::= SEQUENCE{
  referenceId          ReferenceId OPTIONAL,
    deleteOperationStatus    [0]  IMPLICIT DeleteSetStatus,
  deleteListStatuses      [1]  IMPLICIT ListStatuses OPTIONAL,
  numberNotDeleted       [34]  IMPLICIT INTEGER OPTIONAL,
     bulkStatuses        [35]   IMPLICIT ListStatuses OPTIONAL,
   deleteMessage      [36]  IMPLICIT InternationalString OPTIONAL,
  otherInfo          OtherInformation OPTIONAL}
  ListStatuses ::= SEQUENCE OF SEQUENCE{ 
        id  ResultSetId, 
        status  DeleteSetStatus}

  DeleteSetStatus ::= [33] IMPLICIT INTEGER{
                  success          (0),
                   resultSetDidNotExist      (1),
                    previouslyDeletedByTarget      (2),
                     systemProblemAtTarget      (3),
                   accessNotAllowed        (4),
      resourceControlAtOrigin      (5),
                   resourceControlAtTarget      (6),
                    bulkDeleteNotSupported      (7),
                   notAllRsltSetsDeletedOnBulkDlte    (8),
      notAllRequestedResultSetsDeleted    (9),
      resultSetInUse        (10)}
--

--Access- and Resource-control APDUs
--
  AccessControlRequest ::= SEQUENCE{
  referenceId        ReferenceId OPTIONAL,
  securityChallenge      CHOICE{
              simpleForm      [37] IMPLICIT OCTET STRING,
               externallyDefined    [0]  EXTERNAL},
  otherInfo        OtherInformation OPTIONAL}

  AccessControlResponse ::= SEQUENCE{
  referenceId        ReferenceId OPTIONAL,
  securityChallengeResponse  CHOICE{
              simpleForm      [38]   IMPLICIT OCTET STRING,
               externallyDefined    [0]  EXTERNAL} OPTIONAL,
              -- Optional only in version 3; mandatory in version 2. If
              -- omitted (in version 3) then diagnostic must occur.
  diagnostic    [223]    DiagRec OPTIONAL, -- Version 3 only.
  otherInfo        OtherInformation OPTIONAL}



  ResourceControlRequest ::= SEQUENCE{
  referenceId          ReferenceId OPTIONAL,
  suspendedFlag      [39]  IMPLICIT BOOLEAN OPTIONAL,
  resourceReport      [40]  ResourceReport OPTIONAL,
  partialResultsAvailable    [41]  IMPLICIT INTEGER{
                subset    (1),
                interim  (2),
                none    (3)} OPTIONAL,
  responseRequired      [42]   IMPLICIT BOOLEAN, 
  triggeredRequestFlag    [43]   IMPLICIT BOOLEAN OPTIONAL,
  otherInfo          OtherInformation OPTIONAL}


  ResourceControlResponse ::= SEQUENCE{
     referenceId          ReferenceId OPTIONAL,
    continueFlag       [44]   IMPLICIT BOOLEAN, 
  resultSetWanted      [45]  IMPLICIT BOOLEAN OPTIONAL,
  otherInfo          OtherInformation OPTIONAL}



  TriggerResourceControlRequest ::= SEQUENCE{
     referenceId          ReferenceId OPTIONAL,
  requestedAction      [46]  IMPLICIT INTEGER{
                resourceReport  (1),
                resourceControl  (2),
                cancel      (3)}, 
  prefResourceReportFormat    [47]   IMPLICIT ResourceReportId OPTIONAL,
  resultSetWanted      [48]   IMPLICIT BOOLEAN OPTIONAL,
  otherInfo          OtherInformation OPTIONAL}



  ResourceReportRequest ::= SEQUENCE{
     referenceId          ReferenceId OPTIONAL,
  opId          [210]  IMPLICIT ReferenceId OPTIONAL,
  prefResourceReportFormat    [49]   IMPLICIT ResourceReportId OPTIONAL,
  otherInfo          OtherInformation OPTIONAL}
--
  ResourceReportResponse ::= SEQUENCE{
     referenceId          ReferenceId OPTIONAL,
  resourceReportStatus    [50]   IMPLICIT INTEGER{
                success    (0),
                partial    (1),
                failure-1    (2),
                failure-2    (3),
                failure-3    (4),
                failure-4    (5),
                failure-5    (6),
                failure-6    (7)},
  resourceReport               [51]   ResourceReport OPTIONAL,
  otherInfo          OtherInformation OPTIONAL}
--
   ResourceReport     ::=   EXTERNAL
  ResourceReportId    ::=    OBJECT IDENTIFIER

--Scan APDUs
  ScanRequest ::= SEQUENCE{
  referenceId              ReferenceId OPTIONAL,
    databaseNames        [3]  IMPLICIT SEQUENCE OF DatabaseName,
    attributeSet            AttributeSetId OPTIONAL,
    termListAndStartPoint        AttributesPlusTerm,
    stepSize           [5]   IMPLICIT INTEGER OPTIONAL,
    numberOfTermsRequested         [6]   IMPLICIT INTEGER,
    preferredPositionInResponse      [7]   IMPLICIT INTEGER OPTIONAL,
    otherInfo            OtherInformation OPTIONAL}

  ScanResponse ::= SEQUENCE{
   referenceId              ReferenceId OPTIONAL,
   stepSize           [3]  IMPLICIT INTEGER OPTIONAL,
   scanStatus           [4]  IMPLICIT INTEGER {
                                success   (0),
                                partial-1   (1),
                                partial-2   (2),
                                partial-3   (3),
                                partial-4   (4),
                                partial-5   (5),
                                failure  (6) },
   numberOfEntriesReturned       [5]  IMPLICIT INTEGER,
   positionOfTerm         [6]  IMPLICIT INTEGER OPTIONAL,
   entries           [7]  IMPLICIT ListEntries  OPTIONAL,  
   attributeSet          [8]  IMPLICIT AttributeSetId OPTIONAL,
   otherInfo            OtherInformation OPTIONAL}

-- begin auxiliary definitions for Scan
  ListEntries ::= SEQUENCE{
  entries        [1]   IMPLICIT SEQUENCE OF Entry OPTIONAL,
    nonsurrogateDiagnostics    [2]  IMPLICIT SEQUENCE OF DiagRec OPTIONAL
    -- At least one of entries and nonsurrogateDiagnostics must occur
          }

  Entry  ::= CHOICE {
     termInfo               [1]   IMPLICIT TermInfo,
     surrogateDiagnostic    [2]   DiagRec}
--
  TermInfo ::= SEQUENCE {
   term                    Term,
     displayTerm      [0]   IMPLICIT InternationalString OPTIONAL,
                                     -- Presence of displayTerm means that term is not considered by
              -- the target to be suitable for display, and displayTerm should
              -- instead be displayed. 'term' is the actual term in the term list;
               -- 'displayTerm' is for display purposes only, and is not an actual
              -- term in the term list.
  suggestedAttributes            AttributeList OPTIONAL,
     alternativeTerm    [4]  IMPLICIT SEQUENCE OF AttributesPlusTerm OPTIONAL, 
     globalOccurrences    [2]  IMPLICIT INTEGER OPTIONAL,
     byAttributes      [3]  IMPLICIT OccurrenceByAttributes OPTIONAL,
     otherTermInfo      OtherInformation OPTIONAL} 

  OccurrenceByAttributes ::= SEQUENCE OF SEQUENCE{
     attributes    [1]  AttributeList, 
     occurrences       CHOICE{
               global    [2] INTEGER,
            byDatabase  [3] IMPLICIT SEQUENCE OF SEQUENCE{ 
              db      DatabaseName,
              num     [1]  IMPLICIT INTEGER OPTIONAL,
              otherDbInfo    OtherInformation OPTIONAL}} OPTIONAL,
     otherOccurInfo    OtherInformation OPTIONAL} 
-- end auxiliary definitions for Scan

-- Sort APDUs
SortRequest  ::= SEQUENCE{
  referenceId              ReferenceId OPTIONAL,
  inputResultSetNames  [3]  IMPLICIT SEQUENCE OF InternationalString,
  sortedResultSetName  [4]    IMPLICIT InternationalString,
  sortSequence     [5]  IMPLICIT SEQUENCE OF SortKeySpec,
              -- order of occurrence is from major to minor
  otherInfo        OtherInformation OPTIONAL}

SortResponse  ::= SEQUENCE{
  referenceId          ReferenceId OPTIONAL,
  sortStatus         [3]  IMPLICIT INTEGER{
                            success  (0), 
              partial-1  (1),
              failure  (2)},
  resultSetStatus    [4]  IMPLICIT INTEGER{
              empty    (1), 
                  interim  (2), 
                  unchanged  (3),
              none    (4)} OPTIONAL,
  diagnostics        [5]             IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
  resultCount        [6]             IMPLICIT INTEGER OPTIONAL,
  otherInfo        OtherInformation OPTIONAL}

-- begin auxiliary definitions for Sort
  SortKeySpec ::= SEQUENCE{
    sortElement      SortElement, 
       sortRelation    [1]  IMPLICIT INTEGER{
                                ascending      (0),
              descending      (1),
              ascendingByFrequency    (3),
              descendingByfrequency  (4)},
      caseSensitivity    [2]   IMPLICIT INTEGER{
                                 caseSensitive      (0), 
              caseInsensitive    (1)},
      missingValueAction    [3]   CHOICE{
                                     abort    [1] IMPLICIT NULL,
                                     null      [2] IMPLICIT NULL,
                    --supply a null value for missing value
          missingValueData  [3] IMPLICIT OCTET STRING} OPTIONAL}

  SortElement ::=   CHOICE{
    generic        [1] SortKey,
       datbaseSpecific    [2] IMPLICIT SEQUENCE OF SEQUENCE{
                       databaseName  DatabaseName,
                       dbSort    SortKey}} 

  SortKey ::= CHOICE{
    sortfield       [0]  IMPLICIT InternationalString,
                  -- An element, element-group-tag, or alias supported by the target
               -- and denoting a set of elements associated with each record.
     elementSpec    [1]  IMPLICIT Specification,
        sortAttributes    [2]  IMPLICIT SEQUENCE{
              id  AttributeSetId,
              list  AttributeList}}
-- end auxiliary definitions for sort



-- Extended Service APDUs
  ExtendedServicesRequest  ::= SEQUENCE{
  referenceId              ReferenceId OPTIONAL,
  function      [3]  IMPLICIT INTEGER {
              create    (1),
              delete    (2),
              modify  (3)},
  packageType      [4]  IMPLICIT OBJECT IDENTIFIER,
  packageName    [5]  IMPLICIT InternationalString OPTIONAL,
              -- PackageName mandatory for 'modify' or 'delete'; optional for
              -- 'create'. Following four parameters mandatory for 'create'; should
              -- be included on 'modify' if being modified; not needed on 'delete'.
  userId        [6]   IMPLICIT InternationalString OPTIONAL,
  retentionTime    [7]   IMPLICIT IntUnit OPTIONAL,
  permissions      [8]   IMPLICIT Permissions OPTIONAL,
  description      [9]   IMPLICIT InternationalString OPTIONAL,

-- (ExtendedServiceRequest APDU continued)
  taskSpecificParameters  [10]  IMPLICIT EXTERNAL OPTIONAL, 
              -- Mandatory for 'create'; included on 'modify' if specific
              -- parameters being modified; not necessary on 'delete'. For the
              -- 'EXTERNAL,' use OID of specific ES definition and select
              --  CHOICE [1]: 'esRequest'.
  waitAction      [11]  IMPLICIT INTEGER{
              wait      (1),
              waitIfPossible  (2),
              dontWait    (3),
              dontReturnPackage  (4)},
  elements          ElementSetName OPTIONAL,
  otherInfo          OtherInformation OPTIONAL}
--

ExtendedServicesResponse ::= SEQUENCE{
  referenceId                ReferenceId OPTIONAL,
  operationStatus    [3]    IMPLICIT INTEGER{
                done      (1),
                accepted    (2),  
                failure    (3)},
  diagnostics      [4]    IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
  taskPackage      [5]    IMPLICIT EXTERNAL OPTIONAL,
                -- Use OID: {Z39-50-recordSyntax (106)} and corresponding
                -- syntax. For the EXTERNAL, 'taskSpecific,' within that
                -- definition, use OID of the specific es, and choose [2],
                -- 'taskPackage'.
  otherInfo          OtherInformation OPTIONAL}

 Permissions ::= SEQUENCE OF SEQUENCE{
  userId      [1] IMPLICIT InternationalString OPTIONAL,
  allowableFunctions  [2] IMPLICIT SEQUENCE OF INTEGER{
              delete      (1),
              modifyContents  (2),
              modifyPermissions  (3),
              present    (4),
                 invoke    (5)}} 

Close ::= SEQUENCE{
  referenceId          ReferenceId OPTIONAL,  -- See 3.2.11.1.5.
  closeReason          CloseReason,
  diagnosticInformation    [3]  IMPLICIT InternationalString OPTIONAL,
  resourceReportFormat    [4]  IMPLICIT ResourceReportId OPTIONAL, 
                -- For use by origin only, and only on Close request;
                -- origin requests target to include report in response.
   resourceReport      [5]  ResourceReport OPTIONAL,
                -- For use by target only, unilaterally on Close request;
                -- on Close response may be unilateral or in response
                -- to origin request.
  otherInfo          OtherInformation OPTIONAL}

  CloseReason ::=  [211]  IMPLICIT INTEGER{
            finished      (0),
            shutdown      (1),
            systemProblem    (2),
            costLimit      (3),
            resources      (4),
            securityViolation    (5),
            protocolError    (6),
            lackOfActivity    (7),
            peerAbort      (8),
            unspecified      (9)}

--Duplicate detection APDUs
DuplicateDetectionRequest ::= SEQUENCE {
  referenceId                      ReferenceId  OPTIONAL,
  inputResultSetIds            [3] IMPLICIT SEQUENCE OF InternationalString,
  outputResultSetName          [4] IMPLICIT InternationalString,
  applicablePortionOfRecord    [5] IMPLICIT EXTERNAL OPTIONAL,
  duplicateDetectionCriteria   [6] IMPLICIT SEQUENCE OF
                                   DuplicateDetectionCriterion OPTIONAL,
  clustering                   [7] IMPLICIT BOOLEAN OPTIONAL,
                                        -- 'true' means "clustered".
                                        -- This parameter may be omitted
                                        -- only if retentionCriteria CHOICE is
                                        -- 'numberOfEntries' and its value is 1.
  retentionCriteria            [8] IMPLICIT SEQUENCE OF
                                            RetentionCriterion,
  sortCriteria                 [9] IMPLICIT SEQUENCE OF
                                            SortCriterion OPTIONAL,
  otherInfo                        OtherInformation OPTIONAL}

DuplicateDetectionCriterion ::= CHOICE{
                           levelOfMatch         [1] IMPLICIT INTEGER,
                                -- a percentage; 1-100.
                           caseSensitive        [2] IMPLICIT NULL,
                           punctuationSensitive [3] IMPLICIT NULL,
                           regularExpression    [4] IMPLICIT EXTERNAL,
                           rsDuplicates         [5] IMPLICIT NULL
                 -- values 6-100 reserved for future assignment.
                                                       }

RetentionCriterion ::= CHOICE{
                          numberOfEntries       [1] IMPLICIT INTEGER, 
                                                        --  greater than 0
                          percentOfEntries      [2] IMPLICIT INTEGER,
                                                        -- 1-100,
                          duplicatesOnly        [3] IMPLICIT NULL,
                                                 -- should not be chosen 
                                                 -- if clustering is 'true'
                          discardRsDuplicates   [4] IMPLICIT NULL
                 -- values 5-100 reserved for future assignment.
                                                       }

SortCriterion ::= CHOICE{
                         mostComprehensive      [1] IMPLICIT NULL,
                         leastConmprehensive    [2] IMPLICIT NULL,
                         mostRecent             [3] IMPLICIT NULL,
                         oldest                 [4] IMPLICIT NULL,
                         leastCost              [5] IMPLICIT NULL,
                         preferredDatabases     [6] IMPLICIT
                                     SEQUENCE OF InternationalString
                 -- values 7-100 reserved for future assignment.
}

DuplicateDetectionResponse ::= SEQUENCE {
  referenceId                          ReferenceId  OPTIONAL,
  status                       [3]     IMPLICIT INTEGER{
                                         success               (0),
                                         failure               (1)},
  resultSetCount               [4]     IMPLICIT INTEGER OPTIONAL,
  diagnostics                  [5]     IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
  otherInfo                           OtherInformation OPTIONAL}

-- Global auxiliary definitions
  ReferenceId       ::=      [2]  IMPLICIT OCTET STRING
  ResultSetId        ::=      [31]    IMPLICIT InternationalString
  ElementSetName     ::=     [103]   IMPLICIT InternationalString
  DatabaseName     ::=    [105]   IMPLICIT InternationalString
  AttributeSetId     ::=       OBJECT IDENTIFIER


-- OtherInformation
  OtherInformation   ::= [201] IMPLICIT SEQUENCE OF SEQUENCE{
    category            [1]   IMPLICIT InfoCategory OPTIONAL, 
    information        CHOICE{
      characterInfo        [2]  IMPLICIT InternationalString,
      binaryInfo        [3]  IMPLICIT OCTET STRING,
      externallyDefinedInfo    [4]  IMPLICIT EXTERNAL,
      oid          [5]  IMPLICIT OBJECT IDENTIFIER}}
--
  InfoCategory ::= SEQUENCE{
      categoryTypeId  [1]   IMPLICIT OBJECT IDENTIFIER OPTIONAL,
      categoryValue  [2]   IMPLICIT INTEGER}


-- Units
  -- IntUnit is used when value and unit are supplied together. Unit, alone, is used when just
  -- specifying a unit (without a value).  For example, IntUnit is used in Term, in an RPNQuery, or
  -- it can be the datatype of an element within a retrieval record. Unit (alone) would be used in an
  -- element request, when requesting data be returned according to a particular unit.

  IntUnit ::= SEQUENCE{
    value    [1] IMPLICIT INTEGER,
    unitUsed  [2] IMPLICIT Unit}
--
  Unit ::= SEQUENCE{
    unitSystem    [1] InternationalString OPTIONAL,    -- e.g. 'SI'
    unitType    [2] StringOrNumeric OPTIONAL,    -- e.g. 'mass'
    unit      [3] StringOrNumeric OPTIONAL,    -- e.g. 'kilograms'
    scaleFactor    [4] IMPLICIT INTEGER OPTIONAL    -- e.g. 9 means 10**9
        }

--CharacterString
  InternationalString ::= GeneralString
    -- When version 2 is in force, this collapses to VisibleString. That is, only characters in the
    -- visibleString repertoire may be used. (Datatype compatibility with version 2 is not affected,
     -- because references are IMPLICIT.)  When version 3 is in force, the semantics of the
    -- GeneralString content may be altered by negotiation during initialization. If no such
    -- negotiation is in effect, then GeneralString semantics are in force.

StringOrNumeric ::= CHOICE{
  string    [1] IMPLICIT InternationalString,
  numeric  [2] IMPLICIT INTEGER}

END -- IR DEFINITIONS



DiagnosticFormatDiag1 
{Z39-50-diagnosticFormat diag-1 (2)} DEFINITIONS ::=
BEGIN
IMPORTS Term, Specification, AttributeList, SortElement, DatabaseName, 
DefaultDiagFormat, InternationalString FROM Z39-50-APDU-1995;


DiagnosticFormat ::=  SEQUENCE OF SEQUENCE{ 
  diagnostic  [1] CHOICE{
              defaultDiagRec    [1]  IMPLICIT DefaultDiagFormat,
              explicitDiagnostic    [2]  DiagFormat} OPTIONAL, 
  message  [2] IMPLICIT InternationalString OPTIONAL} 


DiagFormat ::= CHOICE{

tooMany  [1000]   IMPLICIT SEQUENCE{
                tooManyWhat   [1]  IMPLICIT INTEGER{
                                  argumentWords        (1), 
                                  truncatedWords        (2), 
                                  booleanOperators      (3),
                                  incompleteSubfields    (4), 
                                  characters          (5),
                                  recordsRetrieved      (6), 
                                  dataBasesSpecified      (7),
                                  resultSetsCreated      (8), 
                                  indexTermsProcessed    (9)},
                max        [2]  IMPLICIT INTEGER OPTIONAL},







badSpec    [1001]  IMPLICIT SEQUENCE{  -- element set name or specification
                spec        [1] IMPLICIT Specification, -- esn or element spec not supported
                db        [2] IMPLICIT DatabaseName OPTIONAL,
                            -- if db specified, above spec not supported for db; otherwise,
                            -- spec not supported period.
                goodOnes    [3] IMPLICIT SEQUENCE OF Specification OPTIONAL  
                            -- target supplies ones that are supported
                            },


dbUnavail  [1002]  IMPLICIT SEQUENCE{ -- database unavailable
                db  [1] IMPLICIT DatabaseName,
                why  [2] IMPLICIT SEQUENCE{
                        reasonCode  [1] IMPLICIT INTEGER{
                                      doesNotExist    (0),
                                      existsButUnavail  (1),
                                      locked      (2),
                                      accessDenied    (3)} OPTIONAL,
                        message    [2] IMPLICIT InternationalString OPTIONAL}},


unSupOp  [1003]  IMPLICIT INTEGER{  -- unsupported operator
                and     (0),
                or      (1),
                and-not  (2),
                prox    (3)},


attribute    [1004]  IMPLICIT SEQUENCE{
                    -- Applies for unsupported attribute set, attribute type, 
                    -- attribute value, or term (for a given attribute type or value).

                id      [1]  IMPLICIT OBJECT IDENTIFIER,
                   -- if only "id" occurs, then attribute set is not supported
                type    [2]  IMPLICIT INTEGER OPTIONAL,
                   -- must occur if value occurs.
                value    [3]   IMPLICIT INTEGER OPTIONAL,
                    -- if omitted, and Type occurs, then Type is what is unsupported
                term    [4]  Term OPTIONAL
                    -- If occurs, term is illegal or not supported, for attribute value,
                    -- if value occurs; otherwise, for type.
                                },


attCombo  [1005]  IMPLICIT SEQUENCE{ -- attribute combination not supported
              unsupportedCombination  [1] IMPLICIT AttributeList, 
              recommendedAlternatives  [2] IMPLICIT SEQUENCE OF AttributeList OPTIONAL}, 




term      [1006]  IMPLICIT SEQUENCE{
                problem    [1] IMPLICIT INTEGER{
                            codedValue  (1),
                            unparsable  (2),
                            tooShort    (3),
                            type      (4)} OPTIONAL,
                term      [2] Term},


proximity  [1007] CHOICE{        -- proximity diagnostics:
               resultSets  [1]    IMPLICIT NULL,         -- proximity between sets not supported
              badSet    [2]    IMPLICIT InternationalString,  -- bad result set specified
                 relation    [3]   IMPLICIT INTEGER,      -- 1 to 6 ; relation not supported
              unit      [4]  IMPLICIT INTEGER,      -- unsupported unit code
              distance    [5]  IMPLICIT INTEGER,      -- unsupported distance
              attributes  [6]  AttributeList,             --  proximity not supported with specified
                                                   -- attribute combination
              ordered    [7]  IMPLICIT NULL,        -- ordered flag not supported
              exclusion  [8]  IMPLICIT NULL          -- exclusion flag not supported
                    },





scan     [1008] CHOICE{      -- scan diagnostics:
              nonZeroStepSize  [0] IMPLICIT NULL,  -- only zero step size supported
              specifiedStepSize  [1] IMPLICIT NULL,  -- specified step size not supported
              termList1      [3] IMPLICIT NULL,  -- term list not supported (no alternative supplied)
              termList2      [4] IMPLICIT SEQUENCE OF AttributeList,
                                          -- term list not supported (alternatives supplied)
              posInResponse    [5] IMPLICIT INTEGER{  --value of positionInResponse not supported
                              mustBeOne        (1),
                              mustBePositive    (2),
                              mustBeNonNegative  (3),
                              other            (4)},
              resources      [6] IMPLICIT NULL,   -- resources exhausted looking for satisfying terms
              endOfList      [7] IMPLICIT NULL  -- beginning or end of term list
                },


sort       [1009] CHOICE{
              sequence    [0]  IMPLICIT NULL,        -- cannot sort according to sequence
              noRsName    [1]  IMPLICIT NULL,        -- no result set name supplied
              tooMany    [2]  IMPLICIT INTEGER,      --  Too many input result sets,
                                                --  maximum supplied.
              incompatible  [3]  IMPLICIT NULL,        -- records with different formats
                                                 -- not compatible for sorting
              generic      [4]  IMPLICIT NULL,        -- generic sort not supported 
                                                -- (db specific only)
              dbSpecific    [5]  IMPLICIT NULL,        -- db specific sort not supported
              sortElement    [6]  SortElement,
              key        [7]  IMPLICIT INTEGER{
                              tooMany  (1),    -- too many sort keys
                              duplicate  (2)},    -- duplicate sort keys
              action      [8]  IMPLICIT NULL,  -- unsupported missing data action
              illegal      [9]  IMPLICIT INTEGER{
                              relation  (1),  -- illegal sort relation
                              case    (2),  -- illegal case value
                              action  (3),   -- illegal missing data action
                              sort    (4)},  -- illegal sort
            inputTooLarge    [10]  IMPLICIT SEQUENCE OF InternationalString,
                                      --   one or more of the input result sets too large to sort
          aggregateTooLarge  [11]  IMPLICIT NULL  --  aggregate result set too large
                          },

segmentation  [1010]  CHOICE{
                segmentCount  [0]    IMPLICIT NULL,
                                  -- Cannot guarantee record will fit within max segments. Target
                                  -- suggests that origin try again to retrieve record, without
                                  -- including max-segment-count.
                segmentSize  [1]    IMPLICIT INTEGER
                                -- record cannot be segmented into fragments such that the largest
                                -- will fit within max segment size specified. Target supplies (in
                                -- bytes) the smallest acceptable value of Max-segment-size to
                                -- retrieve the record.
                          },


extServices  [1011] CHOICE{
                req        [1] IMPLICIT INTEGER{   -- bad request
                            nameInUse    (1),  -- package name already in use
                            noSuchName  (2),  -- no such package, on modify/delete
                            quota        (3),  -- quota exceeded
                            type        (4)},  -- extended service type not supported
                permission  [2] IMPLICIT INTEGER{ -- permission denied on ES, because: 
                            id         (1),    --   id not authorized, or
                            modifyDelete  (2)},    -- cannot modify or delete
                immediate  [3] IMPLICIT INTEGER{ -- immediate execution:
                            failed      (1),    -- failed, 
                            service      (2),    -- not supported for this service, or
                            parameters    (3)    -- for these parameters.
                                }},


accessCtrl    [1012] CHOICE{
                noUser    [1] IMPLICIT NULL,    -- no user to display challenge to
                refused    [2] IMPLICIT NULL,    -- access control information refused by user
                simple    [3] IMPLICIT NULL,    -- only simple form supported (target used
                                          -- externally defined)
                oid      [4] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER,
                                          -- oid not supported (origin supplies alternative
                                          -- suggested oids)
                alternative  [5] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER,
                                          -- origin insists that target use an alternative
                                          -- challenge for this data (e.g. stronger                                     
   
                                          -- authentication or stronger Access control). The                            
              -- origin supplies suggested alternative oids.
                pwdInv    [6] IMPLICIT NULL,    -- password invalid
                pwdExp    [7] IMPLICIT NULL      -- password expired
                    },


recordSyntax  [1013] IMPLICIT SEQUENCE{ -- record cannot be transferred in requested syntax
              unsupportedSyntax    [1] IMPLICIT OBJECT IDENTIFIER, 
              suggestedAlternatives  [2] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL}
}

END





RecordSyntax-explain 
{Z39-50-recordSyntax explain (100)} DEFINITIONS ::=

BEGIN 
IMPORTS AttributeSetId, Term, OtherInformation, DatabaseName, ElementSetName, IntUnit, Unit,
 StringOrNumeric, Specification, InternationalString, AttributeList, AttributeElement FROM Z39-50-APDU-1995;
EXPORTS LanguageCode;

Explain-Record ::= CHOICE{
  -- Each of these may be used as search term  when Use attribute is 'explain-category'.
  targetInfo         [0]    IMPLICIT TargetInfo,
  databaseInfo      [1]    IMPLICIT DatabaseInfo,
  schemaInfo        [2]    IMPLICIT SchemaInfo,
  tagSetInfo         [3]    IMPLICIT TagSetInfo,
  recordSyntaxInfo    [4]    IMPLICIT RecordSyntaxInfo,
  attributeSetInfo    [5]    IMPLICIT AttributeSetInfo,
  termListInfo      [6]    IMPLICIT TermListInfo,
  extendedServicesInfo  [7]    IMPLICIT ExtendedServicesInfo,
  attributeDetails      [8]    IMPLICIT AttributeDetails,
  termListDetails    [9]    IMPLICIT TermListDetails,
  elementSetDetails    [10]  IMPLICIT ElementSetDetails,
  retrievalRecordDetails  [11]   IMPLICIT RetrievalRecordDetails,
  sortDetails             [12]   IMPLICIT SortDetails,
  processing           [13]  IMPLICIT ProcessingInformation,
  variants          [14]  IMPLICIT VariantSetInfo,
  units          [15]    IMPLICIT UnitInfo,
  categoryList            [100]  IMPLICIT CategoryList}

-- Element set name 'B' (brief)  retrieves:
--  -  'commonInfo' (except for otherInfo within commonInfo)
--  -  key elements
--  -  other elements designated as 'non-key brief elements'
-- Esn 'description' retrieves brief elements as well as 'description', and specific additional descriptive
-- elements if designated.  
-- Element set name 'F' (full) retrieves all of the above, as well as those designated as "non-brief elements". Some
-- elements designated as OPTIONAL may be mandatory in full records, and are so identified. (Note that all elements
-- that are not part of the brief element set must be designated as OPTIONAL in the ASN.1, otherwise it would be
-- illegal to omit them.)
-- Other esns are defined (below) as needed.

-- - - - - - - - - - - - -   Info Records
  -- Info records are mainly for software consumption
  -- They describe individual entities within the target system:
  --   The target itself
  --   Individual databases
  --   Schemas
  --   Tag sets
  --   Record syntaxes
  --   Attribute sets
  --   Term lists
  --   Extended services
 --     The information about each Schema, Tag Set, Record Syntax and Attribute Set should
  -- match the universal definitions of these items. The only exception is that a target may omit any
  -- items it doesn't support, for example the description of the bib-1 attribute set may omit attributes
  -- that the target does not support under any circumstances.
  --      Databases that may be searched together can be listed in the dbCominations element of the TargetInfo record.  
TargetInfo ::= SEQUENCE {
  commonInfo      [0]    IMPLICIT CommonInfo OPTIONAL,
    -- Key elements follow:
  name          [1]    IMPLICIT InternationalString,
    -- Non-key brief elements follow:
  recent-news      [2]    IMPLICIT HumanString OPTIONAL,
  icon          [3]    IMPLICIT IconObject OPTIONAL,
  namedResultSets    [4]    IMPLICIT BOOLEAN,
  multipleDBsearch    [5]    IMPLICIT BOOLEAN,
  maxResultSets      [6]    IMPLICIT INTEGER OPTIONAL,
  maxResultSize      [7]    IMPLICIT INTEGER OPTIONAL,
  maxTerms        [8]    IMPLICIT INTEGER OPTIONAL,
  timeoutInterval      [9]    IMPLICIT IntUnit OPTIONAL,
  welcomeMessage    [10]  IMPLICIT HumanString OPTIONAL,
    -- non-brief elements follow:
  -- 'description' esn retrieves the following two (as well as brief):
  contactInfo      [11]  IMPLICIT ContactInfo OPTIONAL,
  description      [12]  IMPLICIT HumanString OPTIONAL,
  nicknames        [13]  IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
  usage-restrictions    [14]  IMPLICIT HumanString OPTIONAL,
  paymentAddr      [15]  IMPLICIT HumanString OPTIONAL,
  hours          [16]  IMPLICIT HumanString OPTIONAL,
  dbCombinations    [17]  IMPLICIT SEQUENCE OF DatabaseList OPTIONAL,
  addresses        [18]  IMPLICIT SEQUENCE OF NetworkAddress OPTIONAL,
  languages        [101]  IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
                  -- Languages supported for message strings.  Each is a three-character
                  -- language code from Z39.53-1994.
-- characterSets      [102]  this tag reserved for "character sets supported for name and message strings".
  -- commonAccessInfo elements list objects the target supports. All objects listed in
  -- AccessInfo for any individual database should also be listed here.
  commonAccessInfo  [19]  IMPLICIT AccessInfo OPTIONAL}


DatabaseInfo ::= SEQUENCE {
      -- A target may provide "virtual databases" that are combinations of individual database. These
      -- databases are indicated by the presence of subDbs in the combination database's DatabaseDescription.
  commonInfo        [0]    IMPLICIT CommonInfo OPTIONAL,
    -- Key elements follow:
  name            [1]    IMPLICIT DatabaseName,
    -- Non-key brief elements follow:
  explainDatabase      [2]             IMPLICIT NULL OPTIONAL,
                       -- If present, this database is the Explain database, or an Explain database
                    -- for a different server, possibly on a different host. The means by which
                    -- that server may be accessed is not addressed by this standard. One
                    -- suggested possibility is an implementor agreement whereby the
                    -- database name is a url which may be used to connect to the server.
  nicknames          [3]    IMPLICIT SEQUENCE OF DatabaseName OPTIONAL,
  icon            [4]    IMPLICIT IconObject OPTIONAL,
  user-fee          [5]    IMPLICIT BOOLEAN,
  available          [6]    IMPLICIT BOOLEAN,
  titleString          [7]    IMPLICIT HumanString OPTIONAL,
    -- Non-brief elements follow:
  keywords          [8]    IMPLICIT SEQUENCE OF HumanString OPTIONAL,
  description        [9]    IMPLICIT HumanString OPTIONAL,
  associatedDbs        [10]  IMPLICIT DatabaseList OPTIONAL,
                    -- databases that may be searched in combination with this one 

  subDbs          [11]  IMPLICIT DatabaseList OPTIONAL,
                        -- When present, this database is a composite representing the combined
                     -- databases 'subDbs'. The individual subDbs are also available.
  disclaimers        [12]  IMPLICIT HumanString OPTIONAL,
  news            [13]  IMPLICIT HumanString OPTIONAL,
  recordCount           [14]    CHOICE {
                                   actualNumber  [0] IMPLICIT INTEGER,
                                    approxNumber  [1] IMPLICIT INTEGER} OPTIONAL,
  defaultOrder        [15]  IMPLICIT HumanString OPTIONAL,
  avRecordSize        [16]  IMPLICIT INTEGER OPTIONAL,
  maxRecordSize      [17]  IMPLICIT INTEGER OPTIONAL,
  hours            [18]  IMPLICIT HumanString OPTIONAL,
  bestTime          [19]  IMPLICIT HumanString OPTIONAL,
  lastUpdate          [20]  IMPLICIT GeneralizedTime OPTIONAL,
  updateInterval        [21]  IMPLICIT IntUnit OPTIONAL,
  coverage          [22]  IMPLICIT HumanString OPTIONAL,
  proprietary        [23]  IMPLICIT BOOLEAN OPTIONAL, -- mandatory in full record
  copyrightText        [24]  IMPLICIT HumanString OPTIONAL,
  copyrightNotice      [25]  IMPLICIT HumanString OPTIONAL,
  producerContactInfo    [26]  IMPLICIT ContactInfo OPTIONAL,
  supplierContactInfo      [27]  IMPLICIT ContactInfo OPTIONAL,
  submissionContactInfo    [28]  IMPLICIT ContactInfo OPTIONAL,
    -- accessInfo lists items connected with the database. All listed items should be in the target's AccessInfo.
  accessInfo                [29]  IMPLICIT AccessInfo OPTIONAL}


SchemaInfo ::= SEQUENCE {
  commonInfo    [0]  IMPLICIT CommonInfo OPTIONAL,
    -- Key elements follow:
  schema      [1]  IMPLICIT OBJECT IDENTIFIER,
    -- Non-key brief elements follow:
  name        [2]  IMPLICIT InternationalString,
    -- Non-brief elements follow:
  description    [3]  IMPLICIT HumanString OPTIONAL,
  tagTypeMapping  [4]  IMPLICIT SEQUENCE OF SEQUENCE {
              tagType    [0] IMPLICIT INTEGER,
              tagSet       [1] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
                -- If tagSet is omitted, then this tagType is for a tagSet locally defined
                -- within the schema that cannot be referenced by another schema.
              defaultTagType  [2] IMPLICIT NULL OPTIONAL
                        } OPTIONAL,
  recordStructure  [5]  IMPLICIT SEQUENCE OF ElementInfo OPTIONAL}


  --  ElementInfo referenced in SchemaInfo and RecordSyntaxInfo
    ElementInfo ::= SEQUENCE {
      elementName  [1] IMPLICIT InternationalString,
      elementTagPath  [2] IMPLICIT Path,
      dataType      [3] ElementDataType OPTIONAL, -- If omitted, not specified. 
       required         [4] IMPLICIT BOOLEAN,
      repeatable     [5] IMPLICIT BOOLEAN,
       description    [6] IMPLICIT HumanString OPTIONAL}


  -- Path is referenced by ElementInfo as well as PerElementDetails
             Path ::= SEQUENCE OF SEQUENCE{
              tagType  [1] IMPLICIT INTEGER,
              tagValue     [2] StringOrNumeric}
      ElementDataType ::= CHOICE{
            primitive  [0] IMPLICIT PrimitiveDataType,
           structured  [1] IMPLICIT SEQUENCE OF ElementInfo}
      PrimitiveDataType ::= INTEGER{
            octetString        (0),
            numeric           (1),
            date            (2),
            external        (3),
            string          (4),
            trueOrFalse       (5),
            oid         (6),
            intUnit        (7),
        empty        (8),
            noneOfTheAbove  (100) -- see 'description'
            }


TagSetInfo ::= SEQUENCE {
  commonInfo  [0]  IMPLICIT CommonInfo OPTIONAL,
    -- Key elements follow:
  tagSet      [1]  IMPLICIT OBJECT IDENTIFIER,
    -- non-key brief elements follow:
  name      [2]  IMPLICIT InternationalString,
    -- non-brief elements follow:
  description  [3]  IMPLICIT HumanString OPTIONAL,
  elements    [4]  IMPLICIT SEQUENCE OF SEQUENCE {
              elementname  [1]  IMPLICIT InternationalString,
               nicknames    [2]  IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
              elementTag     [3]  StringOrNumeric, 
              description    [4]  IMPLICIT HumanString OPTIONAL, 
            dataType       [5]  PrimitiveDataType OPTIONAL,
              -- If the data type is expected to be structured, that is described in the schema info,
              -- and datatype is omitted here.
             otherTagInfo       OtherInformation OPTIONAL} OPTIONAL}

RecordSyntaxInfo ::= SEQUENCE {
  commonInfo    [0]  IMPLICIT CommonInfo OPTIONAL,
    -- Key elements follow:
  recordSyntax    [1]  IMPLICIT OBJECT IDENTIFIER,
    -- Non-key brief elements follow:
  name        [2]  IMPLICIT InternationalString,
    -- non-brief elements follow:
  transferSyntaxes  [3]  IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
  description    [4]  IMPLICIT HumanString OPTIONAL,
  asn1Module    [5]  IMPLICIT InternationalString OPTIONAL,
  abstractStructure  [6]  IMPLICIT SEQUENCE OF ElementInfo OPTIONAL
               -- Omitting abstractStructure only means target isn't using
                 -- Explain to describe the structure, not that there is no structure.
              }

AttributeSetInfo ::= SEQUENCE {
  commonInfo  [0]  IMPLICIT CommonInfo OPTIONAL,
    -- Key elements follow:
  attributeSet  [1]  IMPLICIT AttributeSetId,
    -- non-key brief elements follow:
  name      [2]  IMPLICIT InternationalString,
    -- non-brief elements follow:
  attributes    [3]  IMPLICIT SEQUENCE OF AttributeType OPTIONAL,
            -- mandatory in full record
  description   [4] IMPLICIT HumanString OPTIONAL}
-- AttributeType referenced in AttributeSetInfo
  AttributeType ::= SEQUENCE {
      name             [0] IMPLICIT InternationalString OPTIONAL,
      description      [1] IMPLICIT HumanString OPTIONAL,
       attributeType    [2] IMPLICIT INTEGER,
      attributeValues  [3] IMPLICIT SEQUENCE OF AttributeDescription}
    AttributeDescription ::= SEQUENCE {
        name                 [0] IMPLICIT InternationalString OPTIONAL,
        description          [1] IMPLICIT HumanString OPTIONAL,
        attributeValue       [2] StringOrNumeric,
        equivalentAttributes  [3]  IMPLICIT SEQUENCE OF StringOrNumeric OPTIONAL
                  -- each is an occurrence of 'attributeValue' from AttributeDescription for a
                  -- different attribute. Equivalences listed here should be derived from the 
                  -- attribute set definition, not from a particular server's behavior.  
                    }


TermListInfo ::= SEQUENCE{
  commonInfo    [0]  IMPLICIT CommonInfo OPTIONAL,
    -- Key elements follow:
  databaseName  [1]  IMPLICIT DatabaseName,
    -- Non-key brief elements follow:
  termLists      [2] IMPLICIT SEQUENCE OF SEQUENCE{
            name    [1] IMPLICIT InternationalString,
            title    [2] IMPLICIT HumanString OPTIONAL,
                                            -- Title is for users to see and can differ by language. Name, on the
                      -- other hand is typically a short string not necessarily meant to be
                       -- human-readable, and not variable by language.
            searchCost   [3]   IMPLICIT INTEGER {
                  optimized  (0),    -- The attribute (or combination) associated
                            -- with this   list will do fast searches. 
                      normal      (1),    -- The attribute (combination) will work as
                            -- expected. So there's probably an index for the
                            -- attribute (combination) or some similar
                             -- mechanism.
                      expensive   (2),    -- Can use the attribute (combination), but it
                            -- might not provide satisfactory results.
                            -- Probably there is no index, or post-
                            -- processing of records is required.
                      filter      (3)    -- can't search with this attribute (combination) alone.
                         } OPTIONAL,
              scanable  [4]  IMPLICIT BOOLEAN, -- 'true' means this list can be scanned.
               broader    [5] IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
               narrower  [6] IMPLICIT SEQUENCE OF InternationalString OPTIONAL
                       -- broader and narrower list alternative term lists related to this one.
                       -- The term lists so listed should also be in this termLists structure.
                          }
  -- no non-brief elements
            }


ExtendedServicesInfo ::= SEQUENCE {
  commonInfo          [0]  IMPLICIT CommonInfo OPTIONAL,
    -- Key elements follow:
  type          [1]  IMPLICIT OBJECT IDENTIFIER,
    -- Non-key brief elements follow:
  name                [2]  IMPLICIT InternationalString OPTIONAL,
                -- should be supplied if privateType is 'true'
  privateType      [3]  IMPLICIT BOOLEAN,
  restrictionsApply    [5]  IMPLICIT BOOLEAN,  -- if 'true' see 'description'
  feeApply              [6]  IMPLICIT BOOLEAN,  -- if 'true' see 'description'
  available             [7]  IMPLICIT BOOLEAN,
  retentionSupported    [8]  IMPLICIT BOOLEAN,
  waitAction      [9]  IMPLICIT INTEGER{
                waitSupported    (1),
                waitAlways      (2),
                waitNotSupported  (3),
                depends      (4),
                notSaying      (5)},
  -- non-brief elements follow:
    -- To get brief plus 'description' use esn 'description'
  description           [10]  IMPLICIT HumanString OPTIONAL,
      -- to get above elements and 'specificExplain' use esn 'specificExplain'
  specificExplain    [11]  IMPLICIT EXTERNAL OPTIONAL,
                  -- Use oid of specific ES, and select choice [3] 'explain'. Format
                  -- to be developed in conjunction with the specific ES definition.
    -- to get all elements except 'specificExplain', use esn 'asn'
  esASN          [12]  IMPLICIT InternationalString OPTIONAL -- the ASN.1 for this ES
                }

-- - - - - - - - - - - - - Detail records
 -- The detail records describe relationships among entities supported by the target. RetrievalRecordDetails describes
 -- the way that schema elements are mapped into record elements. This mapping may be different for each
 -- combination of database, schema, record syntax. The per-element details describe the default mapping.
 -- Origin-request re-tagging can change that mapping. When multiple databases are listed in a databaseNames
 -- element, the record applies equally to all of the listed databases.  This is unrelated to searching the databases
 -- together. AttributeDetails describes how databases can be searched. Each supported attribute is listed, and the
 -- allowable combinations can be described.


AttributeDetails ::= SEQUENCE {
  commonInfo        [0]  IMPLICIT CommonInfo OPTIONAL,
    -- Key elements follow:
  databaseName        [1]  IMPLICIT DatabaseName,
    -- Non-brief elements follow:
  attributesBySet        [2]  IMPLICIT SEQUENCE OF AttributeSetDetails OPTIONAL, 
                  -- mandatory in full record
  attributeCombinations    [3]  IMPLICIT AttributeCombinations OPTIONAL}




-- AttributeSetDetails referenced by AttributeDetails
  AttributeSetDetails ::= SEQUENCE {
        attributeSet      [0] IMPLICIT AttributeSetId,
          attributesByType  [1] IMPLICIT SEQUENCE OF AttributeTypeDetails }
    AttributeTypeDetails ::= SEQUENCE {
         attributeType     [0] IMPLICIT INTEGER,
          defaultIfOmitted    [1] IMPLICIT OmittedAttributeInterpretation OPTIONAL,
          attributeValues    [2] IMPLICIT SEQUENCE OF AttributeValue OPTIONAL }
                          -- If no attributeValues are supplied, all values of this type are fully
                    -- supported, and the descriptions in AttributeSetInfo are adequate.

    OmittedAttributeInterpretation ::= SEQUENCE {
        defaultValue           [0] StringOrNumeric OPTIONAL,
                                -- A default value is listed if that's how the server works
        defaultDescription  [1] IMPLICIT HumanString OPTIONAL }
                          -- The human-readable description should generally be provided.
                    -- It is legal for both default elements to be missing, which
                    -- means that the target will allow the attribute type to be
                    -- omitted, but isn't saying what it will do.

    AttributeValue ::= SEQUENCE {
        value              [0]  StringOrNumeric,
        description        [1]  IMPLICIT HumanString OPTIONAL,
        subAttributes     [2]  IMPLICIT SEQUENCE OF StringOrNumeric OPTIONAL,
        superAttributes    [3]  IMPLICIT SEQUENCE OF StringOrNumeric OPTIONAL,
        partialSupport    [4]  IMPLICIT NULL OPTIONAL }
        -- partialSupport indicates that an attributeValue is accepted, but may not be processed in the
        -- "expected" way. One important reason for this is composite databases: in this case partialSupport
        -- may indicate that only some of the subDbs support the attribute, and others ignore it.



TermListDetails ::= SEQUENCE{  -- one for each termList in TermListInfo
  commonInfo    [0]  IMPLICIT CommonInfo OPTIONAL,
    -- Key elements follow:
  termListName    [1]  IMPLICIT InternationalString,
    -- Non-key elements (all non-brief) follow:
  description    [2]  IMPLICIT HumanString OPTIONAL,
  attributes      [3]  IMPLICIT AttributeCombinations OPTIONAL,
                          -- Pattern for attributes that hit this list. Mandatory in full record
  scanInfo      [4]  IMPLICIT SEQUENCE {
                maxStepSize         [0] IMPLICIT INTEGER OPTIONAL,
                collatingSequence  [1] IMPLICIT HumanString OPTIONAL,
                increasing            [2] IMPLICIT BOOLEAN OPTIONAL} OPTIONAL,
            -- Occurs only if list is scanable. If list is scanable and if scanInfo is omitted, 
            -- target doesn't consider these important.
  estNumberTerms  [5]  IMPLICIT INTEGER OPTIONAL,
  sampleTerms    [6]  IMPLICIT SEQUENCE OF Term OPTIONAL}



ElementSetDetails ::= SEQUENCE {
  -- ElementSetDetails describes the way that database records are mapped to record elements. This
  -- mapping may be different for each combination of database name and element set. The database record
   -- description is a schema, which may be private to the target. The schema's abstract record structure
  -- and tag sets provide the vocabulary for discussing record content; their presence in the Explain
  -- database does not imply support for complex retrieval specification.
  commonInfo      [0]  IMPLICIT CommonInfo OPTIONAL,
    -- Key elements follow:
  databaseName      [1]  IMPLICIT DatabaseName,
  elementSetName    [2]  IMPLICIT ElementSetName,
  recordSyntax      [3]  IMPLICIT OBJECT IDENTIFIER,
    -- Non-key Brief elements follow:
  schema        [4]  IMPLICIT OBJECT IDENTIFIER,
    -- Non-brief elements follow:
  description      [5]  IMPLICIT HumanString OPTIONAL,
  detailsPerElement    [6]  IMPLICIT SEQUENCE OF PerElementDetails OPTIONAL -- mandatory in full record
              }


RetrievalRecordDetails ::= SEQUENCE {
  commonInfo      [0]  IMPLICIT CommonInfo OPTIONAL,
    -- Key elements follow:
  databaseName      [1]  IMPLICIT DatabaseName,
  schema        [2]  IMPLICIT OBJECT IDENTIFIER,
  recordSyntax      [3]  IMPLICIT OBJECT IDENTIFIER,
    -- Non-brief elements follow:
  description      [4]  IMPLICIT HumanString OPTIONAL,
  detailsPerElement    [5]  IMPLICIT SEQUENCE OF PerElementDetails OPTIONAL
                -- mandatory in full record
            }

-- PerElementDetails is referenced in RetrievalRecordDetails and ElementSetDetails.
  PerElementDetails ::= SEQUENCE {
      name      [0]    IMPLICIT InternationalString OPTIONAL,
                   -- If the name is omitted, the record syntax's name for this element
                  -- is appropriate.
      recordTag    [1]    IMPLICIT RecordTag OPTIONAL,
                   -- The record tag may be omitted if tags are inappropriate for the record
                  -- syntax, or if the origin can be expected to know it for some other reason.
      schemaTags    [2]    IMPLICIT SEQUENCE OF Path OPTIONAL,
                      -- The information from the listed schema elements is combined
                  -- in some way to produce the data sent in the listed record tag. The
                  -- 'contents' element below may describe the logic used.
      maxSize    [3]    IMPLICIT INTEGER OPTIONAL,
      minSize    [4]    IMPLICIT INTEGER OPTIONAL,
      avgSize      [5]    IMPLICIT INTEGER OPTIONAL,
      fixedSize    [6]    IMPLICIT INTEGER OPTIONAL,
      repeatable    [8]    IMPLICIT BOOLEAN,
      required    [9]    IMPLICIT BOOLEAN, 
                  -- 'required' really means that target will always supply the element.
      description    [12]  IMPLICIT HumanString OPTIONAL,
      contents    [13]  IMPLICIT HumanString OPTIONAL,
      billingInfo    [14]  IMPLICIT HumanString OPTIONAL,
      restrictions    [15]  IMPLICIT HumanString OPTIONAL,
      alternateNames  [16]  IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
      genericNames  [17]  IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
      searchAccess  [18]  IMPLICIT AttributeCombinations OPTIONAL }
      -- RecordTag referenced in PerElementDetails above
        RecordTag ::= SEQUENCE {
              qualifier  [0] StringOrNumeric OPTIONAL,
                    -- E.g. tag set for GRS-1
              tagValue  [1] StringOrNumeric}

SortDetails ::= SEQUENCE {
  commonInfo    [0]  IMPLICIT CommonInfo OPTIONAL,
  -- Key elements follow:
  databaseName    [1]  IMPLICIT DatabaseName,
    -- No non-key brief elements
    -- Non-brief elements follow:
  sortKeys      [2]  IMPLICIT SEQUENCE OF SortKeyDetails OPTIONAL
              -- mandatory in full record
          }
  SortKeyDetails ::= SEQUENCE {
      description        [0]  IMPLICIT HumanString OPTIONAL,
      elementSpecifications  [1]  IMPLICIT SEQUENCE OF Specification OPTIONAL,
                      -- each specification is a way of specifying this same sort key
      attributeSpecifications  [2]  IMPLICIT AttributeCombinations OPTIONAL,
                      -- each combination is a way of specifying this same sort key
      sortType                   [3]  CHOICE {
                    character    [0]  IMPLICIT NULL,
                    numeric    [1]  IMPLICIT NULL,
                    structured    [2]  IMPLICIT HumanString} OPTIONAL,
      caseSensitivity      [4]  IMPLICIT INTEGER {
                      always    (0),  -- always case-sensitive
                    never    (1),            -- never case-sensitive
                    default-yes  (2),               -- case-sensitivity is as specified on request, and if not
                            -- specified, case-sensitive.
                    default-no  (3)} -- case-sensitivity is as specified on request, and if not
                            -- specified, not case-sensitive.
                          OPTIONAL}

ProcessingInformation ::= SEQUENCE{
  commonInfo      [0]  IMPLICIT CommonInfo OPTIONAL,
    -- Key elements follow:
  databaseName      [1]  IMPLICIT DatabaseName,
  processingContext    [2]  IMPLICIT INTEGER {
                  access        (0),   -- e.g. choosing databases
                  search        (1),   -- e.g. "search strategies" or search forms 
                  retrieval      (2),   -- e.g. recommended element combinations 
                  record-presentation  (3),    -- display of retrieved records
                  record-handling    (4)    -- handling (e.g. saving) of retrieved records
        },
  name          [3]  IMPLICIT InternationalString,
  oid          [4]  IMPLICIT OBJECT IDENTIFIER,
    -- No non-key brief elements
    -- Non-brief elements follow:
  description      [5]  IMPLICIT HumanString OPTIONAL,
                -- use element set name 'description' to retrieve all except instructions.
  instructions      [6]  IMPLICIT EXTERNAL OPTIONAL -- mandatory in full record
              }


VariantSetInfo ::= SEQUENCE {
    -- A record in this category describes a variant set definition, i.e., classes, types, and values, for a specific
    -- variant set definition supported by the target. Support by the target of a particular variant set definition
    -- does not imply that the definition is supported for any specific database or element. 
  commonInfo    [0] IMPLICIT CommonInfo OPTIONAL,
  -- Key elements follow:
  variantSet    [1] IMPLICIT OBJECT IDENTIFIER,
  -- Non-key brief elements follow:
  name      [2] IMPLICIT InternationalString,
  -- Non-brief elements follow:
  variants    [3] IMPLICIT SEQUENCE OF VariantClass OPTIONAL
                   -- mandatory in full record
           }

  -- Subsidiary structures for VariantSetInfo
    VariantClass ::= SEQUENCE {
          name        [0] IMPLICIT InternationalString OPTIONAL,
          description    [1] IMPLICIT HumanString OPTIONAL,
          variantClass    [2] IMPLICIT INTEGER,
          variantTypes  [3] IMPLICIT SEQUENCE OF VariantType}
    VariantType ::= SEQUENCE {
          name            [0] IMPLICIT InternationalString OPTIONAL,
          description     [1] IMPLICIT HumanString OPTIONAL,
          variantType    [2] IMPLICIT INTEGER,
          variantValue  [3] IMPLICIT VariantValue OPTIONAL}
    VariantValue ::= SEQUENCE {
          dataType     [0] PrimitiveDataType,
          values        [1] ValueSet OPTIONAL }
    ValueSet ::= CHOICE {
          range       [0] IMPLICIT ValueRange,
          enumerated  [1] IMPLICIT SEQUENCE OF ValueDescription }
    ValueRange ::= SEQUENCE {
            -- At last one the following must be supplied, both may be supplied.
          lower      [0] ValueDescription OPTIONAL,
          upper     [1] ValueDescription OPTIONAL }
    ValueDescription ::= CHOICE{
      integer             INTEGER,
          string              InternationalString,
          octets              OCTET STRING,
          oid                 OBJECT IDENTIFIER,
          unit               [1]  IMPLICIT Unit,
          valueAndUnit   [2]  IMPLICIT IntUnit 
            -- oid and unit can't be used in a ValueRange
            }



UnitInfo ::= SEQUENCE {
  commonInfo  [0] IMPLICIT CommonInfo OPTIONAL,
  -- Key elements follow:
  unitSystem   [1] IMPLICIT InternationalString,
   -- No non-key brief elements
   -- Non-brief elements follow:
  description   [2] IMPLICIT HumanString OPTIONAL,
  units      [3] IMPLICIT SEQUENCE OF UnitType OPTIONAL
                         -- mandatory in full record
           }

  -- Subsidiary structures for UnitInfo
    UnitType ::= SEQUENCE {
      name    [0] IMPLICIT InternationalString OPTIONAL,
      description  [1] IMPLICIT HumanString OPTIONAL,
      unitType  [2] StringOrNumeric,
      units     [3] IMPLICIT SEQUENCE OF Units}

    Units ::= SEQUENCE {
      name     [0] IMPLICIT InternationalString OPTIONAL,
      description  [1] IMPLICIT HumanString OPTIONAL,
      unit      [2] StringOrNumeric}

CategoryList ::= SEQUENCE {
  commonInfo      [0] IMPLICIT CommonInfo OPTIONAL,
    -- Only one record expected per Explain database. All elements appear in brief presentation.
  categories      [1] IMPLICIT SEQUENCE OF CategoryInfo }
    CategoryInfo ::= SEQUENCE {
           category          [1] IMPLICIT InternationalString,
            originalCategory    [2] IMPLICIT InternationalString OPTIONAL,
          description         [3] IMPLICIT HumanString OPTIONAL,
         asn1Module      [4] IMPLICIT InternationalString OPTIONAL}


-- - - - - - - - - - - - - - Subsidiary definitions

CommonInfo ::= SEQUENCE {
  dateAdded         [0] IMPLICIT GeneralizedTime OPTIONAL,
  dateChanged       [1] IMPLICIT GeneralizedTime OPTIONAL,
  expiry                [2] IMPLICIT GeneralizedTime OPTIONAL,
  humanString-Language  [3] IMPLICIT LanguageCode OPTIONAL,
  -- following not to occur for brief:
  otherInfo          OtherInformation OPTIONAL}


HumanString ::= SEQUENCE OF SEQUENCE {
          language  [0] IMPLICIT LanguageCode OPTIONAL,
        text        [1] IMPLICIT InternationalString}

IconObject ::= SEQUENCE OF SEQUENCE{
      -- Note that the "SEQUENCE OF" is to allow alternative representations of the same Icon; it is not
      -- intended to allow multiple icons.
  bodyType [1] CHOICE{
           ianaType  [1] IMPLICIT InternationalString,
          z3950type  [2] IMPLICIT InternationalString,
           otherType  [3] IMPLICIT InternationalString},
  content  [2] IMPLICIT OCTET STRING}


LanguageCode ::= InternationalString  -- from ANSI/NISO Z39.53-1994 

ContactInfo ::= SEQUENCE {
  name           [0] IMPLICIT InternationalString OPTIONAL,
  description  [1] IMPLICIT HumanString OPTIONAL,
  address        [2] IMPLICIT HumanString OPTIONAL,
  email         [3] IMPLICIT InternationalString OPTIONAL,
  phone         [4] IMPLICIT InternationalString OPTIONAL}

NetworkAddress ::= CHOICE {
  internetAddress      [0] IMPLICIT SEQUENCE {
                  hostAddress    [0]  IMPLICIT InternationalString,
                  port       [1]  IMPLICIT INTEGER},
  osiPresentationAddress    [1] IMPLICIT SEQUENCE { 
                    pSel         [0] IMPLICIT InternationalString,  
                    sSel         [1] IMPLICIT InternationalString OPTIONAL,  
                    tSel        [2] IMPLICIT InternationalString OPTIONAL,  
                    nSap      [3] IMPLICIT InternationalString},
  other            [2] IMPLICIT SEQUENCE {  
                      type        [0] IMPLICIT InternationalString,
                address    [1] IMPLICIT InternationalString}}

AccessInfo ::= SEQUENCE {
    -- AccessInfo contains the fundamental information about what facilities are required to use this target
    -- or server. For example, if an origin can handle none of the record syntaxes a database can provide, 
    -- it might choose not to access the database.
  queryTypesSupported  [0]    IMPLICIT SEQUENCE OF QueryTypeDetails OPTIONAL,
  diagnosticsSets        [1]    IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
  attributeSetIds          [2]    IMPLICIT SEQUENCE OF AttributeSetId OPTIONAL,
  schemas                [3]    IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
  recordSyntaxes         [4]    IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
  resourceChallenges    [5]    IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
  restrictedAccess       [6]    IMPLICIT AccessRestrictions OPTIONAL,
  costInfo                 [8]    IMPLICIT Costs OPTIONAL,
  variantSets       [9]    IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL,
  elementSetNames    [10]  IMPLICIT SEQUENCE OF ElementSetName OPTIONAL,
  unitSystems      [11]  IMPLICIT SEQUENCE OF InternationalString}

-- begin auxiliary definitions for AccessInfo
-- Begin Query Details
QueryTypeDetails ::= CHOICE {
  private       [0]    IMPLICIT PrivateCapabilities,
  rpn            [1]    IMPLICIT RpnCapabilities,
  iso8777          [2]    IMPLICIT Iso8777Capabilities,
  z39-58      [100]  IMPLICIT HumanString,
  erpn        [101]  IMPLICIT RpnCapabilities,
  rankedList      [102]  IMPLICIT HumanString}

PrivateCapabilities ::= SEQUENCE {
  operators       [0]  IMPLICIT SEQUENCE OF SEQUENCE {
              operator  [0] IMPLICIT InternationalString,
              description  [1] IMPLICIT HumanString OPTIONAL } OPTIONAL,
  searchKeys    [1]  IMPLICIT SEQUENCE OF SearchKey OPTIONAL,  -- field names that can be searched
  description    [2]  IMPLICIT SEQUENCE OF HumanString OPTIONAL }

RpnCapabilities ::= SEQUENCE {
  operators                    [0] IMPLICIT SEQUENCE OF INTEGER OPTIONAL,
                                        -- Omitted means all operators are supported.
  resultSetAsOperandSupported  [1] IMPLICIT BOOLEAN,
  restrictionOperandSupported    [2] IMPLICIT BOOLEAN,
  proximity                    [3] IMPLICIT ProximitySupport OPTIONAL}

Iso8777Capabilities ::= SEQUENCE {
  searchKeys  [0]  IMPLICIT SEQUENCE OF SearchKey,  -- field names that may be searched
  restrictions   [1]  IMPLICIT HumanString OPTIONAL 
            -- Omitted means supported, not specifying units.
              }

ProximitySupport ::= SEQUENCE {
  anySupport      [0]   IMPLICIT BOOLEAN,
          -- 'false' means no proximity support, in which case unitsSupported not supplied.
  unitsSupported  [1]   IMPLICIT SEQUENCE OF CHOICE{  
             known  [1] IMPLICIT INTEGER, -- values from KnownProximityUnit
          private  [2] IMPLICIT SEQUENCE{  
                      unit    [0] IMPLICIT INTEGER,  
                description  [1] HumanString OPTIONAL}} OPTIONAL}

SearchKey ::= SEQUENCE {
  searchKey     [0]  IMPLICIT InternationalString,
  description     [1]  IMPLICIT HumanString OPTIONAL }
-- End Query details
AccessRestrictions ::= SEQUENCE OF SEQUENCE {
  accessType      [0] INTEGER {
                  any         (0),
                  search         (1),
                  present         (2),
                  specific-elements  (3),
                  extended-services  (4),
            by-database      (5)},
  accessText         [1]  IMPLICIT HumanString OPTIONAL,
  accessChallenges  [2]  IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL}

Costs ::= SEQUENCE {
  connectCharge    [0] IMPLICIT Charge OPTIONAL,    -- Per-connection charge
  connectTime    [1] IMPLICIT Charge OPTIONAL,    -- Time-based charge
  displayCharge     [2] IMPLICIT Charge OPTIONAL,    -- Per-record charge
  searchCharge     [3] IMPLICIT Charge OPTIONAL,    -- Per-search charge
  subscriptCharge  [4]  IMPLICIT Charge OPTIONAL,  -- Subscription charges
  otherCharges    [5] IMPLICIT SEQUENCE OF SEQUENCE{   -- Other charges
            forWhat  [1]  IMPLICIT HumanString,
            charge    [2]  IMPLICIT Charge} OPTIONAL} 
    Charge ::= SEQUENCE{
        cost          [1] IMPLICIT IntUnit,
        perWhat  [2] IMPLICIT Unit OPTIONAL,
                      -- e.g. "second," "minute," "line," "record"...
        text          [3] IMPLICIT HumanString OPTIONAL} 
-- End Auxiliary definitions for AccessInfo

DatabaseList ::= SEQUENCE OF DatabaseName

AttributeCombinations ::= SEQUENCE {
  defaultAttributeSet  [0] IMPLICIT AttributeSetId,
                 -- Default for the combinations. Also probably a good choice for the default
              -- in searches, but that isn't required.
  legalCombinations  [1] IMPLICIT SEQUENCE OF AttributeCombination }


AttributeCombination ::= SEQUENCE OF AttributeOccurrence
            -- An AttributeCombination is a pattern for legal combination of attributes


AttributeOccurrence ::= SEQUENCE {   
      -- An AttributeOccurrence lists the legal values for a specific attribute type in a combination.
       attributeSet       [0]  IMPLICIT AttributeSetId OPTIONAL,
       attributeType      [1]  IMPLICIT INTEGER,
       mustBeSupplied  [2]  IMPLICIT NULL OPTIONAL,
       attributeValues    CHOICE {
                      any-or-none  [3] IMPLICIT NULL, -- All supported values are OK 
                      specific    [4] IMPLICIT SEQUENCE OF StringOrNumeric}}
                                                  -- Only these values allowed
END









RecordSyntax-SUTRS
{Z39-50-recordSyntax SUTRS (101)} DEFINITIONS ::=
BEGIN 
IMPORTS InternationalString  FROM Z39-50-APDU-1995;
        SutrsRecord ::=  InternationalString
-- Line terminator is ASCII LF (X'0A').
-- Recommended maximum line length is 72 characters.
END





RecordSyntax-opac
{Z39-50-recordSyntax opac (102)} DEFINITIONS ::=
BEGIN 
IMPORTS InternationalString  FROM Z39-50-APDU-1995;
OPACRecord ::= SEQUENCE {
  bibliographicRecord   [1]   IMPLICIT EXTERNAL OPTIONAL,
  holdingsData     [2]   IMPLICIT SEQUENCE OF HoldingsRecord OPTIONAL}
HoldingsRecord ::=  CHOICE {
  marcHoldingsRecord  [1]   IMPLICIT EXTERNAL,
  holdingsAndCirc  [2]  IMPLICIT HoldingsAndCircData}
HoldingsAndCircData ::=  SEQUENCE {
-- the following elements are required to display holdings in conformance with NISO standards.
  typeOfRecord    [1]   IMPLICIT InternationalString OPTIONAL, -- LDR 06
  encodingLevel    [2]   IMPLICIT InternationalString OPTIONAL, -- LDR 017
  format      [3]   IMPLICIT InternationalString OPTIONAL, -- 007 00-01
  receiptAcqStatus    [4]   IMPLICIT InternationalString OPTIONAL, -- 008 06
  generalRetention    [5]   IMPLICIT InternationalString OPTIONAL, -- 008 12
  completeness    [6]   IMPLICIT InternationalString OPTIONAL, -- 008 16
       dateOfReport     [7]   IMPLICIT InternationalString OPTIONAL, -- 008 26-31
  nucCode    [8]   IMPLICIT InternationalString OPTIONAL, -- 852 $a
  localLocation    [9]   IMPLICIT InternationalString OPTIONAL, -- 852 $b
  shelvingLocation  [10]   IMPLICIT InternationalString OPTIONAL, -- 852 $c
  callNumber    [11]   IMPLICIT InternationalString OPTIONAL, -- 852 $h and $i
  shelvingData     [12]   IMPLICIT InternationalString OPTIONAL, -- 852 $j thru $m
  copyNumber    [13]   IMPLICIT InternationalString OPTIONAL, -- 852 $t
  publicNote    [14]   IMPLICIT InternationalString OPTIONAL, -- 852 $z
  reproductionNote  [15]   IMPLICIT InternationalString OPTIONAL, -- 843
  termsUseRepro     [16]   IMPLICIT InternationalString OPTIONAL, -- 845
  enumAndChron    [17]   IMPLICIT InternationalString OPTIONAL, -- all 85x, 86x
  volumes     [18]   IMPLICIT SEQUENCE OF Volume OPTIONAL, 
            -- repeats for each volume held
  circulationData    [19]   IMPLICIT SEQUENCE OF CircRecord OPTIONAL 
            -- repeats for each circulating item.
            }
Volume ::=  SEQUENCE {
  enumeration    [1]   IMPLICIT InternationalString OPTIONAL,
  chronology     [2]   IMPLICIT InternationalString OPTIONAL,
  enumAndChron    [3]   IMPLICIT InternationalString OPTIONAL }
CircRecord ::=  SEQUENCE {
  availableNow    [1]   IMPLICIT BOOLEAN,
  availablityDate    [2]   IMPLICIT InternationalString OPTIONAL,
  availableThru      [3]   IMPLICIT InternationalString OPTIONAL,
  restrictions     [4]   IMPLICIT InternationalString OPTIONAL,
  itemId        [5]   IMPLICIT InternationalString OPTIONAL,
  renewable        [6]   IMPLICIT BOOLEAN,
  onHold        [7]   IMPLICIT BOOLEAN,
  enumAndChron     [8]   IMPLICIT InternationalString OPTIONAL,
  midspine    [9]   IMPLICIT InternationalString OPTIONAL,
  temporaryLocation  [10]   IMPLICIT InternationalString OPTIONAL}
END



RecordSyntax-summary

{Z39-50-recordSyntax summary (103)} DEFINITIONS ::=
BEGIN 
IMPORTS OtherInformation, InternationalString  FROM Z39-50-APDU-1995;
BriefBib ::= SEQUENCE {
  title           [1]   IMPLICIT InternationalString,
  author            [2]   IMPLICIT InternationalString OPTIONAL,
  callNumber         [3]   IMPLICIT InternationalString OPTIONAL,
  recordType      [4]   IMPLICIT InternationalString OPTIONAL,
  bibliographicLevel  [5]   IMPLICIT InternationalString OPTIONAL,
  format        [6]   IMPLICIT SEQUENCE OF FormatSpec OPTIONAL,
  publicationPlace    [7]   IMPLICIT InternationalString OPTIONAL,
  publicationDate     [8]   IMPLICIT InternationalString OPTIONAL,
  targetSystemKey   [9]   IMPLICIT InternationalString OPTIONAL,
  satisfyingElement  [10]   IMPLICIT InternationalString OPTIONAL,
  rank         [11]   IMPLICIT INTEGER OPTIONAL,
  documentId     [12]   IMPLICIT InternationalString OPTIONAL,
  abstract       [13]   IMPLICIT InternationalString OPTIONAL,
  otherInfo        OtherInformation OPTIONAL}

FormatSpec     ::=  SEQUENCE {
  type         [1]   IMPLICIT InternationalString,
  size      [2]   IMPLICIT INTEGER OPTIONAL,
  bestPosn     [3]   IMPLICIT INTEGER OPTIONAL}
END










RecordSyntax-generic  -- For detailed semantics, see Appendix RET.
{Z39-50-recordSyntax GRS-1 (105)} DEFINITIONS ::=
BEGIN 
EXPORTS Variant;
IMPORTS IntUnit, Unit, InternationalString, StringOrNumeric, Term FROM Z39-50-APDU-1995;

GenericRecord ::= SEQUENCE OF TaggedElement  
TaggedElement ::= SEQUENCE {
  tagType    [1] IMPLICIT INTEGER OPTIONAL,
              -- If omitted, default should be supplied dynamically by tagSet-M; 
              -- otherwise it should be statically specified by the schema.
  tagValue    [2] StringOrNumeric,
  tagOccurrence  [3] IMPLICIT INTEGER OPTIONAL,
                             -- Occurrence within the database record, and relative to the parent. No
              -- default; if omitted, target not telling or it is irrelevant.
  content      [4] ElementData,
  metaData    [5] IMPLICIT ElementMetaData OPTIONAL,
  appliedVariant  [6] IMPLICIT Variant OPTIONAL}

ElementData ::= CHOICE{
  octets      OCTET STRING,
  numeric    INTEGER,
  date      GeneralizedTime,
  ext        EXTERNAL,
  string      InternationalString,
  trueOrFalse    BOOLEAN,
  oid        OBJECT IDENTIFIER,
  intUnit          [1]  IMPLICIT IntUnit,
   elementNotThere    [2] IMPLICIT NULL,  -- element requested but not there
  elementEmpty      [3] IMPLICIT NULL,  -- element there, but empty
  noDataRequested    [4] IMPLICIT NULL,  -- variant request said 'no data'
  diagnostic        [5] IMPLICIT EXTERNAL,
  subtree          [6] SEQUENCE OF TaggedElement -- recursive, for nested tags
              }


ElementMetaData ::= SEQUENCE{
  seriesOrder        [1]   IMPLICIT Order OPTIONAL, -- only for a non-leaf node
  usageRight        [2]   IMPLICIT Usage OPTIONAL,
  hits            [3]    IMPLICIT SEQUENCE OF HitVector OPTIONAL,
  displayName      [4]    IMPLICIT InternationalString OPTIONAL, 
                    -- name for element that origin can use for display
  supportedVariants    [5]   IMPLICIT SEQUENCE OF Variant OPTIONAL,
  message        [6]    IMPLICIT InternationalString OPTIONAL,
  elementDescriptor    [7]   IMPLICIT OCTET STRING OPTIONAL,
  surrogateFor      [8]   IMPLICIT TagPath OPTIONAL,  
                    -- the retrieved element is a surrogate for the element given by this path  
  surrogateElement    [9]   IMPLICIT TagPath OPTIONAL,
                    -- the element given by this path is a surrogate for the retrieved element
    other          [99]  IMPLICIT EXTERNAL OPTIONAL}

        TagPath ::= SEQUENCE  OF SEQUENCE{
          tagType      [1]  IMPLICIT INTEGER OPTIONAL,
            tagValue      [2]  StringOrNumeric,
            tagOccurrence    [3]  IMPLICIT INTEGER OPTIONAL}



Order ::= SEQUENCE{
  ascending    [1] IMPLICIT BOOLEAN,
              -- "true" means monotonically increasing (i.e. non-decreasing); 
              -- "false" means monotonically decreasing (i.e. non-increasing).
  order      [2] IMPLICIT INTEGER
              -- Same as defined by 'elementOrdering' in tagSet-M, though this may be
              -- overridden by schema.
          }



Usage ::= SEQUENCE  {
  type        [1] IMPLICIT INTEGER{
              redistributable    (1),   -- Element is freely redistributable.
              restricted      (2),   -- Restriction contains statement.
              licensePointer    (3)   -- Restriction contains license pointer.
              },
  restriction    [2] IMPLICIT InternationalString OPTIONAL}



HitVector ::= SEQUENCE{ 
    -- Each hit vector points to a fragment within the element, via location and/or token.
  satisfier            Term OPTIONAL, -- sourceword, etc.
  offsetIntoElement    [1] IMPLICIT IntUnit OPTIONAL,
  length          [2] IMPLICIT IntUnit OPTIONAL,
  hitRank          [3] IMPLICIT INTEGER OPTIONAL,
  targetToken        [4] IMPLICIT OCTET STRING OPTIONAL
                  -- Origin may use token subsequently within a variantRequest (in
                  --  an elementRequest) to retrieve (or to refer to) the fragment.  
              }




Variant ::= SEQUENCE{
    globalVariantSetId    [1] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
                  -- Applies to the triples below, when variantSetId omitted. If
                  -- globalVariantSetId omitted, default applies. Default may be provided by
                  -- the tagSet-M element defaultVariantSetId.




  triples          [2]  IMPLICIT SEQUENCE OF SEQUENCE{
                  variantSetId  [0]  IMPLICIT OBJECT IDENTIFIER OPTIONAL,
                              -- If omitted, globalVariantSetId (above)
                              -- applies, unless that too is omitted, in
                               -- which case, default used.
                  class      [1]  IMPLICIT INTEGER,
                  type      [2]  IMPLICIT INTEGER,
                  value      [3]  CHOICE{
                               integer INTEGER,
                               internationalString InternationalString,
                               octetString OCTET STRING,
                               objectIdentifier OBJECT IDENTIFIER,
                               boolean BOOLEAN,
                              null NULL,
                          -- Following need context tags:
                            unit      [1] IMPLICIT Unit, 
                            valueAndUnit  [2] IMPLICIT IntUnit}}}
END



RecordSyntax-ESTaskPackage
{Z39-50-recordSyntax ESTaskPackage (106)} DEFINITIONS ::=
BEGIN 
IMPORTS Permissions, InternationalString, IntUnit, DiagRec FROM Z39-50-APDU-1995;

TaskPackage ::= SEQUENCE{
  packageType      [1]   IMPLICIT OBJECT IDENTIFIER,
                    -- oid of specific ES definition
  packageName      [2]   IMPLICIT InternationalString OPTIONAL,
  userId          [3]   IMPLICIT InternationalString OPTIONAL,
  retentionTime      [4]   IMPLICIT IntUnit OPTIONAL,
  permissions        [5]   IMPLICIT Permissions OPTIONAL,
  description        [6]   IMPLICIT InternationalString OPTIONAL,
  targetReference      [7]   IMPLICIT OCTET STRING OPTIONAL,
  creationDateTime    [8]   IMPLICIT GeneralizedTime OPTIONAL,
  taskStatus        [9]   IMPLICIT INTEGER{
                      pending    (0),
                      active    (1),
                      complete  (2),
                      aborted    (3)},
  packageDiagnostics    [10]  IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
  taskSpecificParameters  [11]  IMPLICIT EXTERNAL
                    -- Use oid for specific ES definition
                    -- (same oid as packageType above)
                    -- and select [2] "taskPackage."
    } 
END




ResourceReport-Format-Resource-1
{Z39-50-resourceReport resource-1 (1)} DEFINITIONS ::=
BEGIN 
IMPORTS InternationalString FROM Z39-50-APDU-1995;  
--
ResourceReport ::= SEQUENCE{
estimates    [1]   IMPLICIT SEQUENCE OF Estimate,
message      [2]   IMPLICIT InternationalString}
--
Estimate ::= SEQUENCE{
type        [1]   IMPLICIT EstimateType,
value        [2]   IMPLICIT INTEGER,  -- the actual estimate
currency-code  [3]   IMPLICIT INTEGER OPTIONAL
                -- code for representation of currencies defined in ISO 4217-1990.  
                -- Applicable only to monetary estimates.
                              }
EstimateType ::= INTEGER{
currentSearchRecords    (1),         -- estimated no. records in current (incomplete) result set for search
finalSearchRecords       (2),        -- estimated no. records that will be in result set if search completes
currentPresentRecords    (3),        -- estimated number of records in current (incomplete) set of
                      -- records to be returned on Present
finalPresentRecords      (4),  -- estimated number of records that will be in the set of records
                      -- to be returned by Present if Present completes
currentOpTimeProcessing  (5),  -- processing time (in .001 CPU seconds) used by operation so far
finalOpTimeProcessing    (6),                -- estimated total processing time (in .001 CPU seconds) that will
                              -- be used by this operation if it completes
currentAssocTime      (7),  -- estimated processing time used by association (in .001 CPU sec.)
currentOperationCost      (8),  -- estimated cost for this operation so far
finalOperationCost      (9),  -- estimated cost for this operation if it completes
currentAssocCost        (10),  -- estimated cost for this association so far
finalOpTimeElapsed            (11),  -- estimated elapsed time for operation if it completes (in .001 sec.) 
percentComplete         (12), -- estimated percent complete
currentSearchAssocCost    (13),  -- estimated search cost for association so far
currentPresentAssocCost  (14),  -- estimated present cost for this association so far
currentConnectAssocCost    (15),  -- estimated connect time cost for association so far
currentOtherAssocCost    (16)  -- estimated other cost (not included in 13-15) for association so far
                  }
END













ResourceReport-Format-Resource-2
{Z39-50-resourceReport resource-2 (2)} DEFINITIONS ::=
BEGIN 
IMPORTS InternationalString, StringOrNumeric, IntUnit FROM Z39-50-APDU-1995;  
--
ResourceReport ::= SEQUENCE{
estimates    [1]   IMPLICIT SEQUENCE OF Estimate OPTIONAL,
message      [2]   IMPLICIT InternationalString OPTIONAL}
--
Estimate ::= SEQUENCE{
type      [1]   StringOrNumeric,
              -- Numeric values of 1-16 are the same as used in Resource-1.
value      [2]   IMPLICIT IntUnit
              -- When expressing currency:
              --    unitSystem (of Unit) is 'z3950'  (case insensitive)
              --    unitType is 'iso4217-1990'       (case insensitive)
              --    unit is currency code from ISO 4217-1990.
}
END





AccessControlFormat-prompt-1
{Z39-50-accessControl prompt-1 (1)} DEFINITIONS ::=
BEGIN
IMPORTS InternationalString, DiagRec FROM Z39-50-APDU-1995;
--
PromptObject ::= CHOICE{
  challenge      [1] IMPLICIT Challenge,
   response        [2] IMPLICIT Response}

  Challenge ::= SEQUENCE OF SEQUENCE {
    promptId      [1] PromptId,
                    -- Target supplies a number (for an enumerated prompt) or string (for a non
                    -- -enumerated prompt), for each prompt, and the origin returns it in response, for
                    -- this prompt, so target may correlate the prompt response with the prompt.
    defaultResponse  [2] IMPLICIT InternationalString OPTIONAL,
     promptInfo      [3] CHOICE{ 
                    character  [1] IMPLICIT InternationalString,
                    encrypted  [2] IMPLICIT Encryption} OPTIONAL,
                    -- Information corresponding to an enumerated prompt. For example if 'type', within
                    -- PromptId, is 'copyright', then promptInfo may contain a copyright statement.  
    regExpr        [4] IMPLICIT InternationalString OPTIONAL,
                              -- A regular expression that promptResponse should match. See IEEE 1003.2
                    -- Volume 1, Section 2.8 "Regular Expression Notation." For example if promptId
                    -- is "Year of publication," regExpr might be "19[89][0-9]|20[0-9][0-9]".
    responseRequired  [5] IMPLICIT NULL OPTIONAL,
     allowedValues    [6] IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
                        -- e.g. promptId="Desired color"; allowed = 'red', 'blue','Green'.
    shouldSave      [7] IMPLICIT NULL OPTIONAL,
                        -- Target recommends that origin save the data that it prompts from the
                     -- user corresponding to this prompt, because it is likely to be requested again (so
                    -- origin might not have to prompt the user next time).
        dataType        [8] IMPLICIT INTEGER{
                             integer        (1),
                          date            (2),
                        float           (3),
                        alphaNumeric  (4),
                        url-urn       (5),
                        boolean       (6)} OPTIONAL,
                        -- Target telling origin type of data it wants. E.g., if "date" is specified,
                        -- presumably the origin will try to prompt something "date-like" from the user.
        diagnostic       [9] IMPLICIT EXTERNAL OPTIONAL
                          -- Intended for repeat requests when there is an error the origin 
                        -- should report to the user from previous attempt.
                }


  Response ::= SEQUENCE OF SEQUENCE {
      promptId    [1] PromptId,
                  -- Corresponds to a prompt in the challenge, or may be unprompted, for
                  -- example "newPassword." If unprompted, should be "enumerated." 
                  -- If this responds to a non-enumerated prompt, then nonEnumeratedPrompt
                   -- should contain the prompt string from the challenge.
    promptResponse  [2] CHOICE{
                    string      [1] IMPLICIT InternationalString,
                    accept      [2] IMPLICIT BOOLEAN,
                    acknowledge  [3] IMPLICIT NULL,
                    diagnostic    [4] DiagRec,
                     encrypted    [5] IMPLICIT Encryption}}


 PromptId ::= CHOICE{
  enummeratedPrompt    [1] IMPLICIT SEQUENCE{
                      type            [1] IMPLICIT INTEGER{
                                      groupId    (0),
                                      userId     (1),
                                      password   (2),
                                      newPassword  (3),
                                      copyright    (4),
                            -- When type on Challenge is 'copyright', promptInfo has text of
                            -- copyright message to be displayed verbatim to the user. If
                            -- promptResponse indicates 'acceptance', this indicates the user has been
                            -- shown, and accepted, the terms of the copyright. This is not intended
                            -- to be legally binding, but provides a good-faith attempt on
                            -- the part of the target to inform the user of the copyright.
                                      sessionId      (5)},
                      suggestedString    [2] IMPLICIT InternationalString OPTIONAL},
   nonEnumeratedPrompt  [2] IMPLICIT InternationalString}


 Encryption ::= SEQUENCE{
  cryptType    [1] IMPLICIT OCTET STRING OPTIONAL, 
  credential    [2] IMPLICIT OCTET STRING OPTIONAL,
                    --random number, SALT, or other factor
  data        [3] IMPLICIT OCTET STRING}

END




AccessControlFormat-des-1
{Z39-50-accessControlFormat  des-1 (2)} DEFINITIONS ::=
BEGIN
    DES-RN-Object ::= CHOICE {
      challenge    [1]    IMPLICIT DRNType,
      response      [2]    IMPLICIT DRNType}
    DRNType ::= SEQUENCE{
          userId        [1]    IMPLICIT OCTET STRING OPTIONAL,
          salt          [2]    IMPLICIT OCTET STRING OPTIONAL,
          randomNumber  [3]    IMPLICIT OCTET STRING}
END


AccessControlFormat-krb-1
{Z39-50-accessControlFormat  krb-1 (3)} DEFINITIONS ::=
BEGIN
IMPORTS InternationalString FROM Z39-50-APDU-1995;

     KRBObject ::= CHOICE {
       challenge   [1]    IMPLICIT KRBRequest,
       response    [2]    IMPLICIT KRBResponse}
     KRBRequest ::= SEQUENCE{
           service         [1]   IMPLICIT InternationalString,
           instance        [2]   IMPLICIT InternationalString OPTIONAL,
           realm          [3]   IMPLICIT InternationalString OPTIONAL}
        -- target requests a ticket for the given service, instance, and realm
     KRBResponse ::= SEQUENCE{
           userid            [1]   IMPLICIT InternationalString OPTIONAL,
           ticket           [2]  IMPLICIT OCTET STRING}
        -- origin responds with a ticket for the requested service
END









ESFormat-PersistentResultSet
{Z39-50-extendedService PersistentResultSet (1)} DEFINITIONS ::=
BEGIN
IMPORTS InternationalString FROM Z39-50-APDU-1995;
PersistentResultSet ::= CHOICE{
    esRequest    [1] IMPLICIT SEQUENCE{
        toKeep    [1] IMPLICIT NULL,
        notToKeep  [2] OriginPartNotToKeep OPTIONAL},
    taskPackage  [2] IMPLICIT SEQUENCE{
        originPart  [1] IMPLICIT NULL,
        targetPart  [2] TargetPart OPTIONAL}}
OriginPartNotToKeep ::= SEQUENCE{
  originSuppliedResultSet  [1] IMPLICIT InternationalString OPTIONAL,
          -- name of transient result set, supplied on request, mandatory unless function is 'delete'
  replaceOrAppend    [2] IMPLICIT INTEGER{  -- only if function is "modify"
          replace    (1),
          append    (2)} OPTIONAL}
TargetPart ::= SEQUENCE{
  targetSuppliedResultSet  [1] IMPLICIT InternationalString OPTIONAL, 
          -- Name of transient result set, supplied by target, representing the persistent result set to which
          -- package pertains. Meaningful only when package  is presented. (i.e. not on ES response).
  numberOfRecords  [2] IMPLICIT INTEGER OPTIONAL}
END


ESFormat-PersistentQuery
{Z39-50-extendedService PersistentQuery (2)} DEFINITIONS ::=
BEGIN
IMPORTS Query, InternationalString, OtherInformation FROM Z39-50-APDU-1995;
PersistentQuery ::= CHOICE{
    esRequest      [1] IMPLICIT SEQUENCE{
        toKeep    [1] OriginPartToKeep OPTIONAL,
        notToKeep  [2] OriginPartNotToKeep},
    taskPackage    [2] IMPLICIT SEQUENCE{
        originPart  [1] OriginPartToKeep OPTIONAL,
        targetPart  [2] TargetPart}}
OriginPartToKeep ::= SEQUENCE{
  dbNames        [2] IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
  additionalSearchInfo  [3] OtherInformation OPTIONAL}
OriginPartNotToKeep ::= CHOICE{
  package    [1] IMPLICIT InternationalString,
  query    [2] Query}
TargetPart ::= Query          
END

ESFormat-PeriodicQuerySchedule
{Z39-50-extendedService PeriodicQuerySchedule (3)} DEFINITIONS ::=
BEGIN
IMPORTS Query, InternationalString, IntUnit FROM Z39-50-APDU-1995 
ExportSpecification, Destination FROM ESFormat-ExportSpecification;

PeriodicQuerySchedule ::= CHOICE{
    esRequest    [1] IMPLICIT SEQUENCE{
              toKeep    [1] OriginPartToKeep,
              notToKeep  [2] OriginPartNotToKeep},
    taskPackage    [2] IMPLICIT SEQUENCE{
              originPart  [1] OriginPartToKeep,
              targetPart  [2] TargetPart}}

OriginPartToKeep ::=SEQUENCE{
  activeFlag          [1] IMPLICIT BOOLEAN,
  databaseNames        [2] IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
  resultSetDisposition      [3] IMPLICIT INTEGER{
                    replace    (1),
                    append    (2),
                    createNew  (3)  -- Only if origin and target have agreement about
                            -- naming convention for the resulting package,
                             -- and only if no result set is specified.
                } OPTIONAL,   -- Mandatory on 'create' if result set is specified, in
                        -- which case it must be 'replace' or 'append.
  alertDestination        [4] Destination OPTIONAL,
  exportParameters      [5] CHOICE{
                    packageName  [1]   IMPLICIT InternationalString,
                    exportPackage  [2] ExportSpecification} OPTIONAL}

OriginPartNotToKeep ::= SEQUENCE{
  querySpec           [1] CHOICE{
                    actualQuery    [1] Query,
                    packageName  [2] IMPLICIT InternationalString} OPTIONAL,
                  -- mandatory for 'create'
  originSuggestedPeriod    [2] Period OPTIONAL,  -- mandatory for 'create'
  expiration          [3] IMPLICIT GeneralizedTime OPTIONAL,
  resultSetPackage        [4] IMPLICIT InternationalString OPTIONAL}

TargetPart ::= SEQUENCE{
  actualQuery        [1] Query,
  targetStatedPeriod    [2] Period,
                  -- Target supplies the period, which may be same as origin proposed.
  expiration        [3] IMPLICIT GeneralizedTime OPTIONAL,
                  -- Target supplies value for task package. It may be the same as origin
                  -- proposed or different from (and overrides) origin proposal, but if
                  -- omitted, there is no expiration.
  resultSetPackage      [4] IMPLICIT InternationalString OPTIONAL,
                  -- May be omitted only if exportParameters was supplied. Target
                  -- supplies same name as origin supplied, if origin did supply a name.
  lastQueryTime      [5] IMPLICIT GeneralizedTime,
  lastResultNumber    [6] IMPLICIT INTEGER,
  numberSinceModify    [7] IMPLICIT INTEGER OPTIONAL}




  Period ::= CHOICE{
                unit             [1] IMPLICIT IntUnit,
                 businessDaily     [2] IMPLICIT NULL,
              continuous       [3] IMPLICIT NULL,
              other         [4] IMPLICIT InternationalString}
END


ESFormat-ItemOrder
{Z39-50-extendedService ItemOrder (4)} DEFINITIONS ::=
BEGIN
IMPORTS InternationalString FROM Z39-50-APDU-1995;
ItemOrder ::= CHOICE{
    esRequest  [1] IMPLICIT SEQUENCE{
              toKeep    [1] OriginPartToKeep OPTIONAL,
              notToKeep  [2] OriginPartNotToKeep},
    taskPackage  [2] IMPLICIT SEQUENCE{
              originPart  [1] OriginPartToKeep OPTIONAL,
              targetPart  [2] TargetPart}}
OriginPartToKeep ::= SEQUENCE{
  supplDescription    [1] IMPLICIT EXTERNAL OPTIONAL,
  contact        [2] IMPLICIT SEQUENCE{
                       name  [1]   IMPLICIT InternationalString OPTIONAL,
                         phone  [2]   IMPLICIT InternationalString OPTIONAL,
                       email  [3]   IMPLICIT InternationalString OPTIONAL} OPTIONAL,
  addlBilling      [3] IMPLICIT SEQUENCE{
                paymentMethod    [1]   CHOICE{
                                  billInvoice              [0] IMPLICIT NULL,
                                    prepay                [1] IMPLICIT NULL,
                                    depositAccount        [2] IMPLICIT NULL,
                                    creditCard          [3] IMPLICIT CreditCardInfo,
                    cardInfoPreviouslySupplied  [4] IMPLICIT NULL,
                    privateKnown        [5] IMPLICIT NULL,
                    privateNotKnown      [6] IMPLICIT EXTERNAL},
                customerReference  [2] IMPLICIT InternationalString OPTIONAL,
                     customerPONumber  [3] IMPLICIT InternationalString OPTIONAL}
                                 OPTIONAL}
CreditCardInfo   ::= SEQUENCE{
       nameOnCard    [1] IMPLICIT InternationalString,
      expirationDate    [2] IMPLICIT InternationalString,
    cardNumber      [3] IMPLICIT InternationalString} 

OriginPartNotToKeep ::= SEQUENCE{ -- Corresponds to 'requestedItem' in service definition.
      --  Must supply at least one, and may supply both.
  resultSetItem    [1]   IMPLICIT SEQUENCE{  
                resultSetId    [1]   IMPLICIT InternationalString,
                    item      [2]   IMPLICIT INTEGER} OPTIONAL,
  itemRequest      [2] IMPLICIT EXTERNAL OPTIONAL
                -- When itemRequest is an ILL-Request APDU, 
                -- use OID {iso standard 10161 abstract-syntax (2) ill-apdus (1)}
              }

TargetPart ::= SEQUENCE{
  itemRequest      [1]  IMPLICIT EXTERNAL OPTIONAL,
    -- When itemRequest is an ILL-Request APDU, use OID 1.0.10161.2.1 (as above)
  statusOrErrorReport  [2] IMPLICIT EXTERNAL OPTIONAL,
    -- When statusOrErrorReport is an ILL Status-Or-Error-Report APDU, use OID  1.0.10161.2.1 (as above)
  auxiliaryStatus    [3]  IMPLICIT INTEGER{
                notReceived      (1),
                loanQueue      (2),
                forwarded      (3),
                unfilledCopyright  (4),
                filledCopyright    (5)} OPTIONAL}
END




ESFormat-Update0
{Z39-50-extendedService Update (5)} DEFINITIONS ::=
BEGIN
IMPORTS DiagRec, InternationalString FROM Z39-50-APDU-1995; 
Update ::= CHOICE{
    esRequest  [1] IMPLICIT SEQUENCE{
              toKeep    [1] OriginPartToKeep,
              notToKeep  [2] OriginPartNotToKeep},
    taskPackage  [2] IMPLICIT SEQUENCE{
              originPart  [1] OriginPartToKeep,
              targetPart  [2] TargetPart}}


OriginPartToKeep ::= SEQUENCE{
  action          [1] IMPLICIT INTEGER{
                   recordInsert    (1),
                   recordReplace  (2),
                  recordDelete  (3),
                  elementUpdate  (4)},
  databaseName      [2] IMPLICIT InternationalString,
  schema          [3] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
  elementSetName      [4] IMPLICIT InternationalString OPTIONAL}


OriginPartNotToKeep ::= SuppliedRecords


TargetPart ::= SEQUENCE{
  updateStatus    [1] IMPLICIT INTEGER{
                  success  (1),
                  partial  (2),
                  failure  (3)},
  globalDiagnostics  [2] IMPLICIT SEQUENCE OF DiagRec OPTIONAL,
                -- These are non-surrogate diagnostics relating to the task, 
                -- not to individual records.
  taskPackageRecords  [3] IMPLICIT SEQUENCE OF TaskPackageRecordStructure OPTIONAL
                -- There should be a TaskPackageRecordStructure for every record
                -- supplied. The target should create such a structure for every
                      -- record immediately upon creating the task package to include
                -- correlation information and status. The record itself would not
                -- be included until processing for that record is complete.
            }

-- Auxiliary definitions for Update
SuppliedRecords ::= SEQUENCE OF SEQUENCE{
  recordId    [1] CHOICE{
              number  [1] IMPLICIT INTEGER,
              string  [2] IMPLICIT InternationalString,
              opaque  [3]  IMPLICIT OCTET STRING} OPTIONAL,
  supplementalId  [2] CHOICE{
              timeStamp    [1] IMPLICIT GeneralizedTime,
              versionNumber  [2] IMPLICIT InternationalString,
              previousVersion  [3] IMPLICIT EXTERNAL} OPTIONAL,
  correlationInfo  [3] IMPLICIT CorrelationInfo OPTIONAL,
  record      [4] IMPLICIT EXTERNAL}

CorrelationInfo ::= SEQUENCE{
          -- origin may supply one or both for any record:
  note  [1] IMPLICIT InternationalString OPTIONAL,
  id    [2] IMPLICIT INTEGER OPTIONAL}

TaskPackageRecordStructure ::= SEQUENCE{
    recordOrSurDiag  [1] CHOICE {
                record    [1] IMPLICIT EXTERNAL,
                        -- Choose 'record' if recordStatus is 'success', and
                        -- elementSetName was supplied.
                diagnostic  [2] DiagRec
                        -- Choose 'diagnostic', if RecordStatus is failure.
                                } OPTIONAL,
                -- The parameter recordOrSurDiag will thus be omitted only if
                -- 'elementSetName' was omitted and recordStatus is
                -- 'success'; or if record status is 'queued' or in 'process'.
    correlationInfo    [2] IMPLICIT CorrelationInfo OPTIONAL,
                -- This should be included if it was supplied by the origin.
    recordStatus      [3] IMPLICIT INTEGER{
                  success    (1),
                  queued    (2),
                  inProcess  (3),
                  failure    (4)}}
END


ESFormat-ExportSpecification
{Z39-50-extendedService ExportSpecification (6)} DEFINITIONS ::=
BEGIN
EXPORTS ExportSpecification, Destination; IMPORTS CompSpec, InternationalString FROM Z39-50-APDU-1995;
ExportSpecification ::= CHOICE{
    esRequest    [1] IMPLICIT SEQUENCE{
        toKeep    [1] OriginPartToKeep,
        notToKeep  [2] IMPLICIT NULL},
    taskPackage    [2] IMPLICIT SEQUENCE{
        originPart  [1] OriginPartToKeep,
        targetPart  [2] IMPLICIT NULL}}
OriginPartToKeep ::= SEQUENCE{
  composition        [1] IMPLICIT CompSpec,
  exportDestination    [2] Destination}

  Destination ::= CHOICE{
  phoneNumber    [1]    IMPLICIT InternationalString,
  faxNumber      [2]   IMPLICIT InternationalString,
  x400address      [3]   IMPLICIT InternationalString,
  emailAddress    [4]   IMPLICIT InternationalString,
  pagerNumber    [5]   IMPLICIT InternationalString,
  ftpAddress      [6]   IMPLICIT InternationalString,
  ftamAddress    [7]   IMPLICIT InternationalString,
  printerAddress    [8]   IMPLICIT InternationalString,
  other        [100]  IMPLICIT SEQUENCE{
                  vehicle      [1]  IMPLICIT InternationalString  OPTIONAL,
                  destination    [2] IMPLICIT InternationalString}}
END




ESFormat-ExportInvocation
{Z39-50-extendedService ExportInvocation (7)} DEFINITIONS ::=
BEGIN
IMPORTS InternationalString, IntUnit FROM Z39-50-APDU-1995 
ExportSpecification FROM ESFormat-ExportSpecification;
ExportInvocation ::= CHOICE{
    esRequest    [1] IMPLICIT SEQUENCE{
        toKeep    [1] OriginPartToKeep,
        notToKeep  [2] OriginPartNotToKeep},
    taskPackage    [2] IMPLICIT SEQUENCE{
        originPart  [1] OriginPartToKeep,
        targetPart  [2] TargetPart OPTIONAL}}

OriginPartToKeep ::= SEQUENCE{
  exportSpec    [1] CHOICE{
              packageName    [1] IMPLICIT InternationalString,
              packageSpec    [2] ExportSpecification},
  numberOfCopies  [2] IMPLICIT INTEGER}





OriginPartNotToKeep  ::= SEQUENCE{
  resultSetId      [1] IMPLICIT InternationalString,
  records        [2] CHOICE{
                all    [1] IMPLICIT NULL,
                ranges  [2]   IMPLICIT SEQUENCE OF SEQUENCE{
                        start  [1] IMPLICIT INTEGER,
                        count  [2] IMPLICIT INTEGER OPTIONAL
                          -- Count may be omitted only on last range, to indicate
                          -- "all remaining records beginning with 'start'."
                    }}}

TargetPart   ::= SEQUENCE{
    estimatedQuantity    [1] IMPLICIT IntUnit OPTIONAL,
    quantitySoFar      [2] IMPLICIT IntUnit OPTIONAL,
    estimatedCost      [3] IMPLICIT IntUnit OPTIONAL,
    costSoFar        [4] IMPLICIT IntUnit OPTIONAL}
END



UserInfoFormat-searchResult-1
{Z39-50-userInfoFormat searchResult-1 (1)} DEFINITIONS ::=
BEGIN
IMPORTS DatabaseName, Term, Query, IntUnit, InternationalString FROM Z39-50-APDU-1995;
SearchInfoReport ::= SEQUENCE OF SEQUENCE{
  subqueryId      [1] IMPLICIT InternationalString OPTIONAL, 
                           -- shorthand identifier of subquery
  fullQuery        [2] IMPLICIT BOOLEAN,     -- 'true' means this is the full query; 'false',
                          -- a sub-query 
  subqueryExpression    [3] QueryExpression OPTIONAL,  -- A subquery of the query as
                          -- submitted. May be whole query;
                          -- if so, "fullQuery" should be 'true'.
  subqueryInterpretation  [4] QueryExpression OPTIONAL,  -- how target interpreted subquery
  subqueryRecommendation  [5] QueryExpression OPTIONAL,  -- target-recommended alternative
  subqueryCount      [6] IMPLICIT INTEGER OPTIONAL,  -- Number of records for this
                          -- subQuery, across all of the specified
                          -- databases. (If during search, via resource
                           -- control, number of records so far).
  subqueryWeight     [7] IMPLICIT IntUnit OPTIONAL,  -- relative weight of this subquery
  resultsByDB          [8] IMPLICIT ResultsByDB OPTIONAL}

ResultsByDB ::= SEQUENCE OF SEQUENCE{
  databases      [1] CHOICE{
            all     [1] IMPLICIT NULL,
                  -- applies across all of the databases in Search PDU
            list    [2]  IMPLICIT SEQUENCE OF DatabaseName
                  -- applies across all databases in this list
              },
  count        [2] IMPLICIT INTEGER OPTIONAL,
            -- Number of records for query component (and, as above, if during search,
             -- via resource control, number of records so far).
  resultSetName    [3] IMPLICIT InternationalString OPTIONAL
                        -- Target-assigned result set by which subQuery is available. Should not
             -- be provided unless processing for this query component is concluded (i.e.,
            -- when this report comes during search, via resource control, as opposed
            -- to after search, via additionalSearchInfo).
              }

QueryExpression ::=  CHOICE {
                term   [1] IMPLICIT SEQUENCE{
              queryTerm  [1]  Term,
              termComment            [2] IMPLICIT InternationalString OPTIONAL},
           query  [2] Query}
END



ElementSpecificationFormat-eSpec-1
{Z39-50-elementSpec eSpec-1 (1)} DEFINITIONS ::=
BEGIN
IMPORTS Variant FROM RecordSyntax-generic
StringOrNumeric, InternationalString FROM Z39-50-APDU-1995;
--
Espec-1 ::= SEQUENCE{
  elementSetNames    [1] IMPLICIT SEQUENCE OF InternationalString OPTIONAL,
                  -- Origin may include one or more element set names, each
                  -- specifying a set of elements. Each of the elements is to be
                  -- treated as an elementRequest in the form of simpleElement,
                  -- where occurrence is 1. 
  defaultVariantSetId    [2] IMPLICIT OBJECT IDENTIFIER OPTIONAL,
                  -- If supplied, applies whenever variantRequest 
                  -- does not include variantSetId. 
  defaultVariantRequest  [3] IMPLICIT Variant OPTIONAL,
                  -- If supplied, then for each simple elementRequest that does not
                   -- include a variantRequest, the defaultVariantRequest applies.
                  -- (defaultVariantRequest does not apply to a compositeRequest.)
  defaultTagType      [4] IMPLICIT INTEGER OPTIONAL,
                  -- If supplied, applies whenever 'tagType' (within 'tag' within TagPath) 
                  -- is omitted.
  elements        [5] IMPLICIT SEQUENCE OF ElementRequest OPTIONAL}
--

ElementRequest::= CHOICE{
  simpleElement    [1]   IMPLICIT SimpleElement,
  compositeElement  [2] IMPLICIT SEQUENCE{
            elementList    [1] CHOICE{
                  primitives    [1]   IMPLICIT SEQUENCE OF InternationalString,
                              -- Origin may specify one or more element
                              -- set names, each identifying a set of elements,
                              -- and the composite element is the union.
                  specs      [2] IMPLICIT SEQUENCE OF SimpleElement},

            deliveryTag    [2] IMPLICIT TagPath,
                          -- DeliveryTag tagPath for compositeElement may not
                          -- include wildThing or wildPath.
            variantRequest  [3] IMPLICIT Variant OPTIONAL}}

SimpleElement ::= SEQUENCE{
      path        [1] IMPLICIT TagPath,
      variantRequest  [2] IMPLICIT Variant OPTIONAL}
  

TagPath ::= SEQUENCE OF CHOICE{  
  specificTag  [1] IMPLICIT SEQUENCE{
            tagType  [1] IMPLICIT INTEGER OPTIONAL,
                      -- If omitted, then 'defaultTagType' (above) applies, if supplied, and
                      -- if not supplied, then default listed in schema applies.
            tagValue  [2] StringOrNumeric,
             occurrence  [3] Occurrences OPTIONAL 
                      -- default is "first occurrence"
                  },
  wildThing  [2] Occurrences,
              -- Get Nth "thing" at this level, regardless of tag, for each N specified by
            -- "Occurrences" (which may be 'all' meaning match every element at this level).
            -- E.g., if "Occurrences" is 3, get third element regardless of its tag or the tag of
            -- the first two elements.
  wildPath  [3] IMPLICIT NULL
              -- Match any tag, at this level or below, that is on a path for which next tag in this 
              -- TagPath sequence occurs. WildPath may not be last member of the TagPath
            -- sequence.
                      }
--

Occurrences ::= CHOICE{
  all    [1] IMPLICIT NULL,
  last    [2] IMPLICIT NULL,
  values  [3] IMPLICIT SEQUENCE{
          start    [1] IMPLICIT INTEGER,
                  -- if 'start' alone is included, then single occurrence is requested
          howMany  [2] IMPLICIT INTEGER OPTIONAL
                  -- For example, if 'start' is 5 and 'howMany' is 6, then request is for
                  -- "occurrences 5 through 10."
                  }}
END

