ca

-- Module DirectoryAbstractService (X.511:08/1997)
DirectoryAbstractService {joint-iso-itu-t ds(5) module(1)
  directoryAbstractService(2) 3} DEFINITIONS ::=
BEGIN

-- EXPORTS All 
-- The types and values defined in this module are exported for use in the other ASN.1 modules contained 
-- within the Directory Specifications, and for the use of other applications which will use them to access 
-- Directory services. Other applications may use them for their own purposes, but this will not constrain
-- extensions and modifications needed to maintain or improve the Directory service.

IMPORTS
    informationFramework, authenticationFramework, basicAccessControl
    FROM UsefulDefinitions {joint-iso-itu-t ds(5) module(1) usefulDefinitions(0) 3}
    AttributeTypeAndValue FROM BasicAccessControl basicAccessControl
    Attribute, AttributeType, AttributeValue, AttributeValueAssertion,
    DistinguishedName, Name, RelativeDistinguishedName, SupportedAttributes,
    ATTRIBUTE, MATCHING-RULE, ContextAssertion, AttributeTypeAssertion,
    OBJECT-CLASS, RelaxationPolicy
    FROM InformationFramework informationFramework
    CertificationPath, SIGNED{}, SIGNATURE{}, ENCRYPTED{}, AlgorithmIdentifier, AttributeCertificationPath
    FROM AuthenticationFramework authenticationFramework;

-- Common data types 
-- Parameterized type for representing optional signing 

OPTIONALLY-SIGNED {Type} ::= CHOICE {
  unsigned  Type,
  signed    SIGNED {Type}
}

AgreementID ::= SEQUENCE {
  identifier  INTEGER,
  version     INTEGER }

Code ::= CHOICE {
  local   INTEGER,
  global  OBJECT IDENTIFIER }

OperationProgress ::= SET {
  nameResolutionPhase  [0]  ENUMERATED {notStarted(1), proceeding(2), completed(3)},
  nextRDNToBeResolved  [1]  INTEGER OPTIONAL }

ReferenceType ::= ENUMERATED {
  superior(1), subordinate(2), cross(3), nonSpecificSubordinate(4),
  supplier(5), master(6), immediateSuperior(7), self(8)}

CommonArguments ::= SET {
  serviceControls     [30]  ServiceControls DEFAULT {},
  securityParameters  [29]  SecurityParameters OPTIONAL,
  requestor           [28]  DistinguishedName OPTIONAL,
  operationProgress   [27]  OperationProgress DEFAULT {
    nameResolutionPhase notStarted },
  aliasedRDNs         [26]  INTEGER OPTIONAL,
  criticalExtensions  [25]  BIT STRING OPTIONAL,
  referenceType       [24]  ReferenceType OPTIONAL,
  entryOnly           [23]  BOOLEAN DEFAULT TRUE,
  nameResolveOnMaste  [21]  BOOLEAN DEFAULT FALSE,
  operationContexts   [20]  ContextSelection OPTIONAL,
  familyGrouping      [19]  FamilyGrouping DEFAULT entryOnly
}

FamilyGrouping ::= ENUMERATED {
  entryOnly(1), compoundEntry(2), strands(3), multiStrand(4)}

CommonResults ::= SET {
  securityParameters  [30]  SecurityParameters OPTIONAL,
  performer           [29]  DistinguishedName OPTIONAL,
  aliasDereferenced   [28]  BOOLEAN DEFAULT FALSE,
  notification        [27]  SEQUENCE SIZE (1..MAX) OF Attribute OPTIONAL
}

CommonResultsSeq ::= SEQUENCE {
  securityParameters  [30]  SecurityParameters OPTIONAL,
  performer           [29]  DistinguishedName OPTIONAL,
  aliasDereferenced   [28]  BOOLEAN DEFAULT FALSE
}

ServiceControls ::= SET {
  options              [0]  ServiceControlOptions DEFAULT {},
  priority             [1]  INTEGER {low(0), medium(1), high(2)} DEFAULT medium,
  timeLimit            [2]  INTEGER OPTIONAL,
  sizeLimit            [3]  INTEGER OPTIONAL,
  scopeOfReferral      [4]  INTEGER {dmd(0), country(1)} OPTIONAL,
  attributeSizeLimit   [5]  INTEGER OPTIONAL,
  manageDSAITPlaneRef  [6]  SEQUENCE {
    dsaName      Name,
    agreementID  AgreementID } OPTIONAL,
  serviceType          [7]  OBJECT IDENTIFIER OPTIONAL,
  userClass            [8]  INTEGER OPTIONAL
}

ServiceControlOptions ::= BIT STRING {
  preferChaining(0), chainingProhibited(1), localScope(2), dontUseCopy(3),
  dontDereferenceAliases(4), subentries(5), copyShallDo(6),
  partialNameResolution(7), manageDSAIT(8), noSubtypeMatch(9),
  noSubtypeSelection(10), countFamily(11)}

EntryInformationSelection ::= SET {
  attributes CHOICE {
    allUserAttributes  [0]  NULL,
    select             [1]  SET OF AttributeType
  } DEFAULT allUserAttributes:NULL,
  infoTypes [2]  INTEGER {
    attributeTypesOnly(0),
    attributeTypesAndValues(1) } DEFAULT attributeTypesAndValues,
  extraAttributes CHOICE {
    allOperationalAttributes  [3]  NULL,
    select                    [4]  SET OF AttributeType} OPTIONAL,
  contextSelection  ContextSelection OPTIONAL,
  returnContexts    BOOLEAN DEFAULT FALSE,
  familyReturn      FamilyReturn DEFAULT {memberSelect contributingEntriesOnly}
}

ContextSelection ::= CHOICE {
  allContexts       NULL,
  selectedContexts  SET OF TypeAndContextAssertion
}

TypeAndContextAssertion ::= SEQUENCE {
  type               AttributeType,
  contextAssertions  CHOICE {
    preference  SEQUENCE OF ContextAssertion,
    all         SET OF ContextAssertion
  }
}

FamilyReturn ::= SEQUENCE {
  memberSelect  ENUMERATED {contributingEntriesOnly(1), participatingEntriesOnly(2), compoundEntry(3)},
  familySelect  SEQUENCE SIZE (1..MAX) OF OBJECT-CLASS.&id OPTIONAL
}

FamilyEntries ::= SEQUENCE {
  family-class   OBJECT-CLASS.&id, -- structural object class value
  familyEntries  SEQUENCE OF FamilyEntry }

FamilyEntry ::= SEQUENCE {
  rdn          RelativeDistinguishedName,
  information  SEQUENCE OF CHOICE {attributeType AttributeType,attribute Attribute},
  family-info  SEQUENCE SIZE (1..MAX) OF FamilyEntries OPTIONAL }

EntryInformation ::= SEQUENCE {
  name                   Name,
  fromEntry              BOOLEAN DEFAULT TRUE,
  information SET SIZE (1..MAX) OF CHOICE {
    attributeType  AttributeType,
    attribute      Attribute} OPTIONAL,
  incompleteEntry        [3] BOOLEAN DEFAULT FALSE, -- not in 1988-edition systems
  partialNameResolution  [4] BOOLEAN DEFAULT FALSE -- not in 1988 or 1993 edition systems --
}

Filter ::= CHOICE {
  item  [0]  FilterItem,
  and   [1]  SET OF Filter,
  or    [2]  SET OF Filter,
  not   [3]  Filter }

FilterItem ::= CHOICE {
  equality          [0]  AttributeValueAssertion,
  substrings        [1]  SEQUENCE {
    type     ATTRIBUTE.&id({SupportedAttributes}),
    strings  SEQUENCE OF CHOICE {
      initial [0] ATTRIBUTE.&Type ({SupportedAttributes}{@substrings.type}),
      any     [1] ATTRIBUTE.&Type ({SupportedAttributes}{@substrings.type}),
      final   [2] ATTRIBUTE.&Type ({SupportedAttributes}{@substrings.type}),
      control  Attribute}},
  greaterOrEqual    [2]  AttributeValueAssertion,
  lessOrEqual       [3]  AttributeValueAssertion,
  present           [4]  AttributeType,
  approximateMatch  [5]  AttributeValueAssertion,
  extensibleMatch   [6]  MatchingRuleAssertion,
  contextPresent    [7]  AttributeTypeAssertion
}

MatchingRuleAssertion ::= SEQUENCE {
  matchingRule  [1]  SET SIZE (1..MAX) OF MATCHING-RULE.&id,
  type          [2]  AttributeType OPTIONAL,
  matchValue    [3]  MATCHING-RULE.&AssertionType (CONSTRAINED BY {}),
  dnAttributes  [4]  BOOLEAN DEFAULT FALSE
}

PagedResultsRequest ::= CHOICE {
  newRequest SEQUENCE {
    pageSize  INTEGER,
    sortKeys  SEQUENCE SIZE (1..MAX) OF SortKey OPTIONAL,
    reverse   [1]  BOOLEAN DEFAULT FALSE,
    unmerged  [2]  BOOLEAN DEFAULT FALSE},
  queryReference  OCTET STRING }

SortKey ::= SEQUENCE {
  type          AttributeType,
  orderingRule  MATCHING-RULE.&id OPTIONAL }

SecurityParameters ::= SET {
  certification-path          [0]  CertificationPath OPTIONAL,
  name                        [1]  DistinguishedName OPTIONAL,
  time                        [2]  Time OPTIONAL,
  random                      [3]  BIT STRING OPTIONAL,
  target                      [4]  ProtectionRequest OPTIONAL,
  response                    [5]  BIT STRING OPTIONAL,
  operationCode               [6]  Code OPTIONAL,
  attributeCertificationPath  [7]  AttributeCertificationPath OPTIONAL,
  errorProtection             [8]  ErrorProtectionRequest OPTIONAL,
  errorCode                   [9]  Code OPTIONAL }

HierarchySelections ::= BIT STRING {
  self(0), children(1), parent(2), hierarchy(3), top(4), subtree(5),
  siblings(6), siblingChildren(7), siblingSubtree(8), all(9)}

SearchControlOptions ::= BIT STRING {
  searchAliases(0), matchedValuesOnly(1), checkOverspecified(2),
  performExactly(3), includeAllAreas(4), noSystemRelaxation(5), dnAttribute(6),
  matchOnResidualName(7), entryCount(8), useSubset(9),
  separateFamilyMembers(10), searchFamily(11)}

ProtectionRequest ::= INTEGER {
  none(0), signed(1), encrypted(2), signed-encrypted(3)}

Time ::= CHOICE {
  utcTime          UTCTime,
  generalizedTime  GeneralizedTime }

ErrorProtectionRequest ::= INTEGER {
  none(0), signed(1), encrypted(2), signed-encrypted(3)}

END -- DirectoryAbstractService