-- Remote-Operations-Apdus.asn
--
-- Taken from ITU ASN.1 database
-- http://www.itu.int/ITU-T/asn1/database/itu-t/h/h450.1/1998/Remote-Operations-Apdus.asn
--
-- $Id$
--

-- Module Remote-Operations-Apdus (H.450.1:02/1998)
Remote-Operations-Apdus {itu-t recommendation h 450 1 version1(0)
  remote-operations-apdus(11)} DEFINITIONS AUTOMATIC TAGS ::=
BEGIN

-- exports everything
IMPORTS
  OPERATION, ERROR
    FROM Remote-Operations-Information-Objects {joint-iso-itu-t
      remote-operations(4) informationObjects(5) version1(0)};

ROS{InvokeId:InvokeIdSet, OPERATION:Invokable, OPERATION:Returnable} ::=
  CHOICE {
  invoke        [1]  Invoke{{InvokeIdSet}, {Invokable}},
  returnResult  [2]  ReturnResult{{Returnable}},
  returnError   [3]  ReturnError{{Errors  {{Returnable}}}},
  reject        [4]  Reject
}
(CONSTRAINED BY { -- must conform to the above definition --} !
 RejectProblem:general-unrecognizedPDU)

Invoke{InvokeId:InvokeIdSet, OPERATION:Operations} ::= SEQUENCE {
  invokeId
    InvokeId(InvokeIdSet)
      (CONSTRAINED BY {-- must be unambiguous -- } !
       RejectProblem:invoke-duplicateInvocation),
  linkedId
    InvokeId
      (CONSTRAINED BY {-- must identify an outstanding operation -- } !
       RejectProblem:invoke-unrecognizedLinkedId)
      (CONSTRAINED BY {-- which has one or more linked operations-- } !
       RejectProblem:invoke-linkedResponseUnexpected) OPTIONAL,
  opcode
    OPERATION.&operationCode
      ({Operations} !RejectProblem:invoke-unrecognizedOperation),
  argument
    OPERATION.&ArgumentType
      ({Operations}{@opcode} !RejectProblem:invoke-mistypedArgument) OPTIONAL
}
(CONSTRAINED BY { -- must conform to the above definition --} !
 RejectProblem:general-mistypedPDU)

--(
--	WITH COMPONENTS
--	{ 
--		..., 
--		linkedId	ABSENT
--	}
--	WITH COMPONENTS	{
--		..., 
--		linkedId	PRESENT, 
--		opcode 	(CONSTRAINED BY { 
-- must be in the &Linked field of the associated operation 
-- } ! RejectProblem : invoke-unexpectedLinkedOperation) 
--	}
--)
ReturnResult{OPERATION:Operations} ::= SEQUENCE {
  invokeId
    InvokeId
      (CONSTRAINED BY {-- must be that for an outstanding operation -- } !
       RejectProblem:returnResult-unrecognizedInvocation)
      (CONSTRAINED BY {-- which returns a result -- } !
       RejectProblem:returnResult-resultResponseUnexpected),
  result
    SEQUENCE {opcode
                OPERATION.&operationCode({Operations})
                  (CONSTRAINED BY {-- identified by invokeId -- } !
                   RejectProblem:returnResult-unrecognizedInvocation),
              result
                OPERATION.&ResultType
                  ({Operations}{@.opcode} !
                   RejectProblem:returnResult-mistypedResult)} OPTIONAL
}
(CONSTRAINED BY { -- must conform to the above definition --} !
 RejectProblem:general-mistypedPDU)

ReturnError{ERROR:Errors} ::= SEQUENCE {
  invokeId
    InvokeId
      (CONSTRAINED BY {-- must be that for an outstanding operation -- } !
       RejectProblem:returnError-unrecognizedInvocation)
      (CONSTRAINED BY {-- which returns an error -- } !
       RejectProblem:returnError-errorResponseUnexpected),
  errcode
    ERROR.&errorCode({Errors} !RejectProblem:returnError-unrecognizedError)
      (CONSTRAINED BY {--must be in the &Errors field of the associated operation -- 
         } !RejectProblem:returnError-unexpectedError),
  parameter
    ERROR.&ParameterType
      ({Errors}{@errcode} !RejectProblem:returnError-mistypedParameter)
      OPTIONAL
}
(CONSTRAINED BY { -- must conform to the above definition --} !
 RejectProblem:general-mistypedPDU)

Reject ::= SEQUENCE {
  invokeId  InvokeId,
  problem
    CHOICE {general       GeneralProblem,
            invoke        InvokeProblem,
            returnResult  ReturnResultProblem,
            returnError   ReturnErrorProblem}
}
(CONSTRAINED BY { -- must conform to the above definition --} !
 RejectProblem:general-mistypedPDU)

GeneralProblem ::= INTEGER {
  unrecognizedComponent(0), mistypedComponent(1), badlyStructuredComponent(2)
}

InvokeProblem ::= INTEGER {
  duplicateInvocation(0), unrecognizedOperation(1), mistypedArgument(2),
  resourceLimitation(3), releaseInProgress(4), unrecognizedLinkedId(5),
  linkedResponseUnexpected(6), unexpectedLinkedOperation(7)}

ReturnResultProblem ::= INTEGER {
  unrecognizedInvocation(0), resultResponseUnexpected(1), mistypedResult(2)
}

ReturnErrorProblem ::= INTEGER {
  unrecognizedInvocation(0), errorResponseUnexpected(1), unrecognizedError(2),
  unexpectedError(3), mistypedParameter(4)}

RejectProblem ::= INTEGER {
  general-unrecognizedPDU(0), general-mistypedPDU(1),
  general-badlyStructuredPDU(2), invoke-duplicateInvocation(10),
  invoke-unrecognizedOperation(11), invoke-mistypedArgument(12),
  invoke-resourceLimitation(13), invoke-releaseInProgress(14),
  invoke-unrecognizedLinkedId(15), invoke-linkedResponseUnexpected(16),
  invoke-unexpectedLinkedOperation(17),
  returnResult-unrecognizedInvocation(20),
  returnResult-resultResponseUnexpected(21), returnResult-mistypedResult(22),
  returnError-unrecognizedInvocation(30),
  returnError-errorResponseUnexpected(31), returnError-unrecognizedError(32),
  returnError-unexpectedError(33), returnError-mistypedParameter(34)}

InvokeId ::= INTEGER

Errors{OPERATION:Operations} ERROR ::= {Operations.&Errors}

END -- end of Remote-Operations-Apdus definitions

-- Generated by Asnp, the ASN.1 pretty-printer of France Telecom R&D