Enum autosar_data_specification::EnumItem

source · [−]

#[repr(u16)]
pub enum EnumItem {
Show 2398 variants    _500Miles,
    _1000baseT,
    _1000baseT1,
    _100baseT1,
    _100baseTx,
    _10baseT1s,
    Aa,
    Ab,
    Abstract,
    AbstractAccessPoint,
    AbstractCanCluster,
    AbstractCanCommunicationConnector,
    AbstractCanCommunicationController,
    AbstractCanPhysicalChannel,
    AbstractClassTailoring,
    AbstractDoIpLogicAddressProps,
    AbstractEthernetFrame,
    AbstractEvent,
    AbstractExecutionContext,
    AbstractIamRemoteSubject,
    AbstractImplementationDataType,
    AbstractImplementationDataTypeElement,
    AbstractProvidedPortPrototype,
    AbstractRawDataStreamInterface,
    AbstractRequiredPortPrototype,
    AbstractSecurityEventFilter,
    AbstractSecurityIdsmInstanceFilter,
    AbstractServiceInstance,
    AbstractSignalBasedToISignalTriggeringMapping,
    AbstractSynchronizedTimeBaseInterface,
    AcceptAll,
    AcceptConfigured,
    AccesPerrmissionServiceClass,
    AccessPermissionInstanceOverridesClass,
    AccessPermissionServiceClass,
    AccessPermissionServiceInstance,
    AckWithRt,
    AckWithoutRt,
    AclObjectSet,
    AclOperation,
    AclPermission,
    AclRole,
    Action,
    ActionItem,
    ActionList,
    Activate,
    ActivationAndTriggerUnicast,
    ActivationMulticast,
    ActivationUnicast,
    Active,
    AdaptiveApplicationSwComponentType,
    AdaptiveAutosarApplication,
    AdaptiveEventReceived,
    AdaptiveEventSent,
    AdaptiveFieldGetterCalled,
    AdaptiveFieldGetterCompleted,
    AdaptiveFieldNotificationReceived,
    AdaptiveFieldNotificationSent,
    AdaptiveFieldSetterCalled,
    AdaptiveFieldSetterCompleted,
    AdaptiveMethodCallReceived,
    AdaptiveMethodCalled,
    AdaptiveMethodResponseReceived,
    AdaptiveMethodResponseSent,
    AdaptiveModuleInstantiation,
    AdaptivePlatformServiceInstance,
    AdaptiveServiceFindCompleted,
    AdaptiveServiceFindStarted,
    AdaptiveServiceOfferCompleted,
    AdaptiveServiceOfferStarted,
    AdaptiveServiceStopSubscriptionCompleted,
    AdaptiveServiceStopSubscriptionStarted,
    AdaptiveServiceSubscriptionAcknowledgeCompleted,
    AdaptiveServiceSubscriptionAcknowledgeStarted,
    AdaptiveServiceSubscriptionCompleted,
    AdaptiveServiceSubscriptionStarted,
    AdaptiveSwcInternalBehavior,
    AddrMethodShortName,
    AddrMethodShortNameAndAlignment,
    Af,
    AfterSales,
    Aftermaket,
    Aftermarket,
    Age,
    AgeConstraint,
    AggregationTailoring,
    Agreed,
    Ah,
    AliasNameSet,
    AliveSupervision,
    All,
    All16Bit,
    AllIndicesDifferentArraySize,
    AllIndicesSameArraySize,
    AllSupportedDtcs,
    Allocator,
    Alternating8Bit,
    Always,
    Am,
    AmberWarning,
    AnalyzedExecutionTime,
    And,
    Any,
    AnySendOperation,
    AnyStandardized,
    Ap,
    ApApplicationEndpoint,
    ApApplicationError,
    ApApplicationErrorDomain,
    ApApplicationErrorSet,
    ApSomeipTransformationProps,
    Api,
    ApiBased,
    ApiUse,
    AppOsTaskProxyToEcuTaskProxyMapping,
    Application,
    ApplicationActionItem,
    ApplicationArrayDataType,
    ApplicationArrayElement,
    ApplicationAssocMapDataType,
    ApplicationAssocMapElement,
    ApplicationCompositeDataType,
    ApplicationCompositeElementDataPrototype,
    ApplicationDataType,
    ApplicationDeferredDataType,
    ApplicationEndpoint,
    ApplicationError,
    ApplicationInterface,
    ApplicationModeRequestPhmActionItem,
    ApplicationOnly,
    ApplicationPartition,
    ApplicationPartitionToEcuPartitionMapping,
    ApplicationPrimitiveDataType,
    ApplicationRecordDataType,
    ApplicationRecordElement,
    ApplicationSwComponentType,
    Ar,
    ArClientServer,
    ArElement,
    ArPackage,
    ArbitraryEventTriggering,
    Arbitration,
    ArgumentDataPrototype,
    Array,
    ArtifactChecksum,
    ArtifactChecksumToCryptoProviderMapping,
    As,
    AsIs,
    AssemblySwConnector,
    AsymmetricFromByteArray,
    AsymmetricToByteArray,
    Asynchronous,
    AsynchronousServerCallPoint,
    AsynchronousServerCallResultPoint,
    AsynchronousServerCallReturnsEvent,
    AtomicSwComponentType,
    AtpBlueprint,
    AtpBlueprintable,
    AtpClassifier,
    AtpDefinition,
    AtpFeature,
    AtpPrototype,
    AtpStructureElement,
    AtpType,
    AttributeTailoring,
    Authenticate,
    Auto,
    AutoIp,
    AutoIpDoip,
    AutoIpdhcpv4,
    Autonomous,
    AutosarDataPrototype,
    AutosarDataType,
    AutosarOperationArgumentInstance,
    AutosarVariableInstance,
    AvbIeee8021As,
    Ay,
    Az,
    Ba,
    BackgroundEvent,
    BaseT,
    BaseType,
    BasicSoftwareModeManager,
    Be,
    Bg,
    Bh,
    Bi,
    Bidirectional,
    BinaryManifestAddressableObject,
    BinaryManifestItem,
    BinaryManifestItemDefinition,
    BinaryManifestMetaDataField,
    BinaryManifestProvideResource,
    BinaryManifestRequireResource,
    BinaryManifestResource,
    BinaryManifestResourceDefinition,
    BlinkMode,
    BlinkOrContinuousOnMode,
    BlockSource,
    BlockState,
    BlueprintDerivationTime,
    BlueprintMappingSet,
    Bmp,
    Bn,
    Bo,
    Bold,
    Bolditalic,
    Bonjour,
    Bottom,
    Br,
    Break,
    Brief,
    BriefBypassingFilters,
    BroadRReach,
    Bsw,
    BswAsynchronousServerCallPoint,
    BswAsynchronousServerCallResultPoint,
    BswAsynchronousServerCallReturnsEvent,
    BswBackgroundEvent,
    BswCalledEntity,
    BswCompositionTiming,
    BswDataReceivedEvent,
    BswDebugInfo,
    BswDirectCallPoint,
    BswDistinguishedPartition,
    BswEntryRelationshipSet,
    BswEvent,
    BswExternalTriggerOccurredEvent,
    BswImplementation,
    BswInternalBehavior,
    BswInternalTriggerOccurredEvent,
    BswInternalTriggeringPoint,
    BswInterruptEntity,
    BswMEntryCallReturned,
    BswMEntryCalled,
    BswMgrNeeds,
    BswModeManagerErrorEvent,
    BswModeSwitchEvent,
    BswModeSwitchedAckEvent,
    BswModuleCallPoint,
    BswModuleClientServerEntry,
    BswModuleDependency,
    BswModuleDescription,
    BswModuleEntity,
    BswModuleEntityActivated,
    BswModuleEntityStarted,
    BswModuleEntityTerminated,
    BswModuleEntry,
    BswModuleTiming,
    BswOperationInvokedEvent,
    BswOsTaskExecutionEvent,
    BswSchedulableEntity,
    BswScheduleEvent,
    BswSchedulerNamePrefix,
    BswServiceDependencyIdent,
    BswSynchronousServerCallPoint,
    BswTimingEvent,
    BswVariableAccess,
    Build,
    BuildAction,
    BuildActionEntity,
    BuildActionEnvironment,
    BuildActionManifest,
    BuildTypeDebug,
    BuildTypeRelease,
    BulkNvDataDescriptor,
    BurstPatternEventTriggering,
    BusMirrorChannelMapping,
    BusMirrorChannelMappingCan,
    BusMirrorChannelMappingFlexray,
    BusMirrorChannelMappingIp,
    BusMirrorChannelMappingUserDefined,
    C,
    Ca,
    Calculated,
    CalibrationOffline,
    CalibrationOnline,
    CalibrationParameterValueSet,
    CalibrationVariables,
    Callback,
    Callout,
    Calprm,
    Can20,
    CanBeTerminated,
    CanBeTerminatedAndRestarted,
    CanCluster,
    CanCommunicationConnector,
    CanCommunicationController,
    CanFd,
    CanFrame,
    CanFrameTriggering,
    CanNmCluster,
    CanNmNode,
    CanPhysicalChannel,
    CanTpAddress,
    CanTpChannel,
    CanTpConfig,
    CanTpNode,
    Cancel,
    Caption,
    CaptureAsynchronousToReporting,
    CaptureAsynchronouslyToReporting,
    CaptureSynchronousToReporting,
    CaptureSynchronouslyToReporting,
    Cat1,
    Cat2,
    Caution,
    Center,
    ChannelA,
    ChannelB,
    Chapter,
    CheckAtNextHalt,
    CheckpointTransition,
    Circle,
    ClassContentConditional,
    Classic,
    Clear,
    ClearAllDtcs,
    ClearDynamicallyDefineDataIdentifier,
    ClientAuthenticate,
    ClientDecrypt,
    ClientEncrypt,
    ClientIdDefinition,
    ClientIdDefinitionSet,
    ClientMacGenerate,
    ClientMacVerify,
    ClientServerInterface,
    ClientServerInterfaceMapping,
    ClientServerInterfaceToBswModuleEntryBlueprintMapping,
    ClientServerOperation,
    ClientVerify,
    Closed,
    Co,
    Code,
    CodeGenerationTime,
    Codegeneration,
    Coldstart,
    CollectableElement,
    Collection,
    ComAxis,
    ComCertificateToCryptoCertificateMapping,
    ComEventGrant,
    ComEventGrantDesign,
    ComFieldGrant,
    ComFieldGrantDesign,
    ComFindServiceGrant,
    ComFindServiceGrantDesign,
    ComGrant,
    ComGrantDesign,
    ComKeyToCryptoKeySlotMapping,
    ComManagementMapping,
    ComManager,
    ComMethodGrant,
    ComMethodGrantDesign,
    ComMgrUserNeeds,
    ComOfferServiceGrant,
    ComOfferServiceGrantDesign,
    ComSecOcToCryptoKeySlotMapping,
    ComTriggerGrantDesign,
    CommConnectorPort,
    CommandLineLongForm,
    CommandLineShortForm,
    CommandLineSimpleForm,
    Common,
    CommunicationCluster,
    CommunicationConnector,
    CommunicationController,
    CommunicationInterEcu,
    CommunicationIntraPartition,
    Compile,
    Compiler,
    ComplexDeviceDriverSwComponentType,
    CompositeInterface,
    CompositionPPortToExecutablePPortMapping,
    CompositionPortToExecutablePortMapping,
    CompositionRPortToExecutableRPortMapping,
    CompositionSwComponentType,
    CompuMethod,
    Comaxis,
    Concrete,
    ConcreteClassTailoring,
    ConcretePatternEventTriggering,
    Conditional,
    ConfigData,
    Configured,
    Confirmed,
    ConfirmedDtcBit,
    Connect,
    ConsistencyNeeds,
    ConsistencyNeedsBlueprintSet,
    Console,
    Const,
    ConstantSpecification,
    ConstantSpecificationMappingSet,
    ConstraintTailoring,
    ConsumedEventGroup,
    ConsumedProvidedServiceInstanceGroup,
    ConsumedServiceInstance,
    Consumer,
    ContainerIPdu,
    ContinueAtItPosition,
    ContinuousOnMode,
    CouplingElement,
    CouplingPort,
    CouplingPortFifo,
    CouplingPortScheduler,
    CouplingPortShaper,
    CouplingPortStructuralElement,
    CouplingPortTrafficClassAssignment,
    Cp,
    CpSoftwareCluster,
    CpSoftwareClusterBinaryManifestDescriptor,
    CpSoftwareClusterCommunicationResource,
    CpSoftwareClusterMappingSet,
    CpSoftwareClusterResource,
    CpSoftwareClusterResourcePool,
    CpSoftwareClusterResourceToApplicationPartitionMapping,
    CpSoftwareClusterServiceResource,
    CpSoftwareClusterToEcuInstanceMapping,
    CpSoftwareClusterToResourceMapping,
    CpSwClusterResourceToDiagDataElemMapping,
    CpSwClusterResourceToDiagFunctionIdMapping,
    CpSwClusterToDiagEventMapping,
    CpSwClusterToDiagRoutineSubfunctionMapping,
    Cpp,
    CppImplementationDataType,
    CppImplementationDataTypeContextTarget,
    CppImplementationDataTypeElement,
    CrcIgnored,
    CrcNotSupported,
    CrcNotValidated,
    CrcOptional,
    CrcSupported,
    CrcValidated,
    CryptoCertificate,
    CryptoCertificateInterface,
    CryptoCertificateKeySlotNeeds,
    CryptoCertificateToPortPrototypeMapping,
    CryptoDriver,
    CryptoEllipticCurveProps,
    CryptoInterface,
    CryptoJob,
    CryptoKeyManagement,
    CryptoKeyManagementNeeds,
    CryptoKeySlot,
    CryptoKeySlotInterface,
    CryptoKeySlotToPortPrototypeMapping,
    CryptoModuleInstantiation,
    CryptoNeed,
    CryptoNeedToCryptoJobMapping,
    CryptoNeedToPortPrototypeMapping,
    CryptoNeeds,
    CryptoPrimitive,
    CryptoProvider,
    CryptoProviderInterface,
    CryptoProviderToPortPrototypeMapping,
    CryptoServiceCertificate,
    CryptoServiceJobNeeds,
    CryptoServiceKey,
    CryptoServiceManager,
    CryptoServiceMapping,
    CryptoServiceNeeds,
    CryptoServicePrimitive,
    CryptoServiceQueue,
    CryptoSignatureScheme,
    CryptoTrustMasterInterface,
    Cs,
    CurveAxis,
    Curveaxis,
    Custom,
    CustomCppImplementationDataType,
    Cvc,
    Cy,
    CycleRepetition1,
    CycleRepetition10,
    CycleRepetition16,
    CycleRepetition2,
    CycleRepetition20,
    CycleRepetition32,
    CycleRepetition4,
    CycleRepetition40,
    CycleRepetition5,
    CycleRepetition50,
    CycleRepetition64,
    CycleRepetition8,
    Cyclic,
    CyclicAndOnChange,
    Da,
    DataConstr,
    DataExchangePoint,
    DataFormatElementReference,
    DataFormatElementScope,
    DataInterface,
    DataPrototype,
    DataPrototypeGroup,
    DataReceiveErrorEvent,
    DataReceivedEvent,
    DataSendCompletedEvent,
    DataTransformation,
    DataTransformationSet,
    DataTypeMappingSet,
    DataWriteCompletedEvent,
    DcmIPdu,
    DdsDomainRange,
    DdsEventDeployment,
    DdsFieldDeployment,
    DdsMethodDeployment,
    DdsProvidedServiceInstance,
    DdsRequiredServiceInstance,
    DdsRpcServiceDeployment,
    DdsSecureComProps,
    DdsSecureGovernance,
    DdsServiceInstanceToMachineMapping,
    DdsServiceInterfaceDeployment,
    DdsTopicAccessRule,
    De,
    DeadlineSupervision,
    DebounceData,
    Debug,
    Decreasing,
    Dedicated,
    DefItem,
    Default,
    DefaultErrorTracer,
    DefaultIfRevisionUpdate,
    DefaultIfUndefined,
    DefaultMode,
    DefaultTraceStateDisabled,
    DefaultTraceStateEnabled,
    DefaultTrigger,
    Deferred,
    DeficitRoundRobin,
    DefineByIdentifier,
    DefineByMemoryAddress,
    Deflate,
    DelegationSwConnector,
    Delete,
    Dependant,
    DependencyOnArtifact,
    DerivedFrom,
    Descendant,
    Deselected,
    Detailed,
    DetailedBypassingFilters,
    DeterministicClient,
    DeterministicClientResourceNeeds,
    Development,
    DevelopmentError,
    DevelopmentErrorTracer,
    Dhcpv4,
    Dhcpv6,
    DiagEventDebounceAlgorithm,
    DiagEventDebounceCounterBased,
    DiagEventDebounceMonitorInternal,
    DiagEventDebounceTimeBased,
    DiagRequest,
    DiagResponse,
    DiagnosticAbstractAliasEvent,
    DiagnosticAbstractDataIdentifier,
    DiagnosticAbstractDataIdentifierInterface,
    DiagnosticAbstractRoutineInterface,
    DiagnosticAccessPermission,
    DiagnosticAging,
    DiagnosticAuthRole,
    DiagnosticAuthentication,
    DiagnosticAuthenticationClass,
    DiagnosticAuthenticationConfiguration,
    DiagnosticAuthenticationInterface,
    DiagnosticAuthenticationPortMapping,
    DiagnosticCapabilityElement,
    DiagnosticClearCondition,
    DiagnosticClearConditionGroup,
    DiagnosticClearConditionNeeds,
    DiagnosticClearConditionPortMapping,
    DiagnosticClearDiagnosticInformation,
    DiagnosticClearDiagnosticInformationClass,
    DiagnosticClearResetEmissionRelatedInfo,
    DiagnosticClearResetEmissionRelatedInfoClass,
    DiagnosticComControl,
    DiagnosticComControlClass,
    DiagnosticComControlInterface,
    DiagnosticCommonElement,
    DiagnosticCommunicationManager,
    DiagnosticCommunicationManagerNeeds,
    DiagnosticComponentNeeds,
    DiagnosticCondition,
    DiagnosticConditionGroup,
    DiagnosticConditionInterface,
    DiagnosticConnectedIndicator,
    DiagnosticConnection,
    DiagnosticContributionSet,
    DiagnosticControlDtcSetting,
    DiagnosticControlDtcSettingClass,
    DiagnosticControlNeeds,
    DiagnosticCustomServiceClass,
    DiagnosticCustomServiceInstance,
    DiagnosticDataByIdentifier,
    DiagnosticDataElement,
    DiagnosticDataElementInterface,
    DiagnosticDataIdentifier,
    DiagnosticDataIdentifierGenericInterface,
    DiagnosticDataIdentifierInterface,
    DiagnosticDataIdentifierSet,
    DiagnosticDataPortMapping,
    DiagnosticDataTransfer,
    DiagnosticDataTransferClass,
    DiagnosticDeAuthentication,
    DiagnosticDebounceAlgorithmProps,
    DiagnosticDemProvidedDataMapping,
    DiagnosticDoIpActivationLineInterface,
    DiagnosticDoIpGroupIdentificationInterface,
    DiagnosticDoIpPowerModeInterface,
    DiagnosticDoIpTriggerVehicleAnnouncementInterface,
    DiagnosticDownloadInterface,
    DiagnosticDtcInformationInterface,
    DiagnosticDynamicDataIdentifier,
    DiagnosticDynamicallyDefineDataIdentifier,
    DiagnosticDynamicallyDefineDataIdentifierClass,
    DiagnosticEcuInstanceProps,
    DiagnosticEcuReset,
    DiagnosticEcuResetClass,
    DiagnosticEcuResetInterface,
    DiagnosticEnableCondition,
    DiagnosticEnableConditionGroup,
    DiagnosticEnableConditionNeeds,
    DiagnosticEnableConditionPortMapping,
    DiagnosticEnvBswModeElement,
    DiagnosticEnvModeElement,
    DiagnosticEnvSwcModeElement,
    DiagnosticEnvironmentalCondition,
    DiagnosticEvent,
    DiagnosticEventInfoNeeds,
    DiagnosticEventInterface,
    DiagnosticEventManager,
    DiagnosticEventManagerNeeds,
    DiagnosticEventNeeds,
    DiagnosticEventPortMapping,
    DiagnosticEventToDebounceAlgorithmMapping,
    DiagnosticEventToEnableConditionGroupMapping,
    DiagnosticEventToOperationCycleMapping,
    DiagnosticEventToSecurityEventMapping,
    DiagnosticEventToStorageConditionGroupMapping,
    DiagnosticEventToTroubleCodeJ1939Mapping,
    DiagnosticEventToTroubleCodeUdsMapping,
    DiagnosticExtendedDataRecord,
    DiagnosticExternalAuthenticationInterface,
    DiagnosticExternalAuthenticationPortMapping,
    DiagnosticFimAliasEvent,
    DiagnosticFimAliasEventGroup,
    DiagnosticFimAliasEventGroupMapping,
    DiagnosticFimAliasEventMapping,
    DiagnosticFimEventGroup,
    DiagnosticFimFunctionMapping,
    DiagnosticFreezeFrame,
    DiagnosticFunctionIdentifier,
    DiagnosticFunctionIdentifierInhibit,
    DiagnosticFunctionInhibitSource,
    DiagnosticGenericUdsInterface,
    DiagnosticGenericUdsNeeds,
    DiagnosticGenericUdsPortMapping,
    DiagnosticIndicator,
    DiagnosticIndicatorInterface,
    DiagnosticIndicatorNeeds,
    DiagnosticIndicatorPortMapping,
    DiagnosticInfoType,
    DiagnosticInhibitSourceEventMapping,
    DiagnosticIoControl,
    DiagnosticIoControlClass,
    DiagnosticIoControlNeeds,
    DiagnosticIumpr,
    DiagnosticIumprDenominatorGroup,
    DiagnosticIumprGroup,
    DiagnosticIumprToFunctionIdentifierMapping,
    DiagnosticJ1939ExpandedFreezeFrame,
    DiagnosticJ1939FreezeFrame,
    DiagnosticJ1939Node,
    DiagnosticJ1939Spn,
    DiagnosticJ1939SpnMapping,
    DiagnosticJ1939SwMapping,
    DiagnosticLogAndTrace,
    DiagnosticMapping,
    DiagnosticMasterToSlaveEventMapping,
    DiagnosticMasterToSlaveEventMappingSet,
    DiagnosticMeasurementIdentifier,
    DiagnosticMemoryAddressableRangeAccess,
    DiagnosticMemoryByAddress,
    DiagnosticMemoryDestination,
    DiagnosticMemoryDestinationMirror,
    DiagnosticMemoryDestinationPortMapping,
    DiagnosticMemoryDestinationPrimary,
    DiagnosticMemoryDestinationUserDefined,
    DiagnosticMemoryIdentifier,
    DiagnosticMonitorInterface,
    DiagnosticMonitorPortMapping,
    DiagnosticOperationCycle,
    DiagnosticOperationCycleInterface,
    DiagnosticOperationCycleNeeds,
    DiagnosticOperationCyclePortMapping,
    DiagnosticParameterIdentifier,
    DiagnosticPortInterface,
    DiagnosticPowertrainFreezeFrame,
    DiagnosticProofOfOwnership,
    DiagnosticProtocol,
    DiagnosticProvidedDataMapping,
    DiagnosticReadDataByIdentifier,
    DiagnosticReadDataByIdentifierClass,
    DiagnosticReadDataByPeriodicId,
    DiagnosticReadDataByPeriodicIdClass,
    DiagnosticReadDtcInformation,
    DiagnosticReadDtcInformationClass,
    DiagnosticReadMemoryByAddress,
    DiagnosticReadMemoryByAddressClass,
    DiagnosticReadScalingDataByIdentifier,
    DiagnosticReadScalingDataByIdentifierClass,
    DiagnosticRequestControlOfOnBoardDevice,
    DiagnosticRequestControlOfOnBoardDeviceClass,
    DiagnosticRequestCurrentPowertrainData,
    DiagnosticRequestCurrentPowertrainDataClass,
    DiagnosticRequestDownload,
    DiagnosticRequestDownloadClass,
    DiagnosticRequestEmissionRelatedDtc,
    DiagnosticRequestEmissionRelatedDtcClass,
    DiagnosticRequestEmissionRelatedDtcPermanentStatus,
    DiagnosticRequestEmissionRelatedDtcPermanentStatusClass,
    DiagnosticRequestFileTransfer,
    DiagnosticRequestFileTransferClass,
    DiagnosticRequestFileTransferNeeds,
    DiagnosticRequestOnBoardMonitoringTestResults,
    DiagnosticRequestOnBoardMonitoringTestResultsClass,
    DiagnosticRequestPowertrainFreezeFrameData,
    DiagnosticRequestPowertrainFreezeFrameDataClass,
    DiagnosticRequestRoutineResults,
    DiagnosticRequestUpload,
    DiagnosticRequestUploadClass,
    DiagnosticRequestVehicleInfo,
    DiagnosticRequestVehicleInfoClass,
    DiagnosticResponseOnEvent,
    DiagnosticResponseOnEventClass,
    DiagnosticResponseOnEventNeeds,
    DiagnosticRoutine,
    DiagnosticRoutineControl,
    DiagnosticRoutineControlClass,
    DiagnosticRoutineGenericInterface,
    DiagnosticRoutineInterface,
    DiagnosticRoutineNeeds,
    DiagnosticRoutineSubfunction,
    DiagnosticSecurityAccess,
    DiagnosticSecurityAccessClass,
    DiagnosticSecurityEventReportingModeMapping,
    DiagnosticSecurityLevel,
    DiagnosticSecurityLevelInterface,
    DiagnosticSecurityLevelPortMapping,
    DiagnosticServiceClass,
    DiagnosticServiceDataIdentifierMapping,
    DiagnosticServiceDataIdentifierPortMapping,
    DiagnosticServiceDataMapping,
    DiagnosticServiceGenericMapping,
    DiagnosticServiceInstance,
    DiagnosticServiceSwMapping,
    DiagnosticServiceTable,
    DiagnosticServiceValidationInterface,
    DiagnosticServiceValidationMapping,
    DiagnosticSession,
    DiagnosticSessionControl,
    DiagnosticSessionControlClass,
    DiagnosticSoftwareClusterProps,
    DiagnosticStartRoutine,
    DiagnosticStopRoutine,
    DiagnosticStorageCondition,
    DiagnosticStorageConditionGroup,
    DiagnosticStorageConditionNeeds,
    DiagnosticStorageConditionPortMapping,
    DiagnosticSwMapping,
    DiagnosticTestResult,
    DiagnosticTestRoutineIdentifier,
    DiagnosticTransferExit,
    DiagnosticTransferExitClass,
    DiagnosticTroubleCode,
    DiagnosticTroubleCodeGroup,
    DiagnosticTroubleCodeJ1939,
    DiagnosticTroubleCodeObd,
    DiagnosticTroubleCodeProps,
    DiagnosticTroubleCodeUds,
    DiagnosticTroubleCodeUdsToClearConditionGroupMapping,
    DiagnosticTroubleCodeUdsToTroubleCodeObdMapping,
    DiagnosticUploadDownloadNeeds,
    DiagnosticUploadDownloadPortMapping,
    DiagnosticUploadInterface,
    DiagnosticValueNeeds,
    DiagnosticVerifyCertificateBidirectional,
    DiagnosticVerifyCertificateUnidirectional,
    DiagnosticWriteDataByIdentifier,
    DiagnosticWriteDataByIdentifierClass,
    DiagnosticWriteMemoryByAddress,
    DiagnosticWriteMemoryByAddressClass,
    DiagnosticsCommunicationSecurityNeeds,
    Disable,
    Dlna,
    DltApplication,
    DltApplicationToProcessMapping,
    DltArgument,
    DltContext,
    DltEcu,
    DltLogChannel,
    DltLogChannelDesign,
    DltLogChannelDesignToProcessDesignMapping,
    DltLogChannelToProcessMapping,
    DltLogSink,
    DltLogSinkToPortPrototypeMapping,
    DltMessage,
    DltMessageCollectionSet,
    DltUserNeeds,
    DoIp,
    DoIpActivationLineNeeds,
    DoIpGidNeeds,
    DoIpGidSynchronizationNeeds,
    DoIpInstantiation,
    DoIpInterface,
    DoIpLogicAddress,
    DoIpLogicTargetAddressProps,
    DoIpLogicTesterAddressProps,
    DoIpPowerModeStatusNeeds,
    DoIpRoutingActivation,
    DoIpRoutingActivationAuthenticationNeeds,
    DoIpRoutingActivationConfirmationNeeds,
    DoIpServiceNeeds,
    DoIpTpConfig,
    DocumentElementScope,
    Documentation,
    DocumentationContext,
    DoesNotReportExecutionState,
    DoesNotSupportBufferLocking,
    DoesNotUseLogging,
    DomainParticipantUserDataQos,
    DontInvalidate,
    Drop,
    DropFrame,
    DropUntagged,
    Dsa,
    DtcStatusChangeNotificationNeeds,
    DynamicPartTrigger,
    Dz,
    E2EProfileCompatibilityProps,
    E2EProfileConfiguration,
    E2EProfileConfigurationSet,
    Ecc,
    Ecu,
    EcuAbstractionSwComponentType,
    EcuInstance,
    EcuManager,
    EcuMapping,
    EcuPartition,
    EcuStateMgrUserNeeds,
    EcuTiming,
    EcucAbstractExternalReferenceDef,
    EcucAbstractInternalReferenceDef,
    EcucAbstractReferenceDef,
    EcucAbstractStringParamDef,
    EcucAddInfoParamDef,
    EcucBooleanParamDef,
    EcucChoiceContainerDef,
    EcucChoiceReferenceDef,
    EcucCommonAttributes,
    EcucContainerDef,
    EcucContainerValue,
    EcucDefinitionCollection,
    EcucDefinitionElement,
    EcucDestinationUriDef,
    EcucDestinationUriDefSet,
    EcucEnumerationLiteralDef,
    EcucEnumerationParamDef,
    EcucFloatParamDef,
    EcucForeignReferenceDef,
    EcucFunctionNameDef,
    EcucInstanceReferenceDef,
    EcucIntegerParamDef,
    EcucLinkerSymbolDef,
    EcucModuleConfigurationValues,
    EcucModuleDef,
    EcucMultilineStringParamDef,
    EcucParamConfContainerDef,
    EcucParameterDef,
    EcucQuery,
    EcucQueryExpression,
    EcucReferenceDef,
    EcucStringParamDef,
    EcucSymbolicNameReferenceDef,
    EcucUriReferenceDef,
    EcucValidationCondition,
    EcucValueCollection,
    EdgeNode,
    El,
    EmissionRelatedDtc,
    En,
    Enable,
    Enabled,
    EncryptAndSign,
    EncryptAndSignWithOriginAuthentication,
    Encryption,
    End2EndEventProtectionProps,
    End2EndMethodProtectionProps,
    EndToEndProtection,
    EndToEndProtectionISignalIPdu,
    EndToEndProtectionSet,
    EndToEndProtectionVariablePrototype,
    Enhanced,
    EnumerationMappingTable,
    Eo,
    EocEventRef,
    EocExecutableEntityRef,
    EocExecutableEntityRefAbstract,
    EocExecutableEntityRefGroup,
    Eps,
    Equal,
    Error,
    ErrorCorrection,
    ErrorDetection,
    ErrorTracer,
    ErrorTracerNeeds,
    Es,
    Esp,
    Et,
    EthIpProps,
    EthTcpIpIcmpProps,
    EthTcpIpProps,
    EthTpConfig,
    EthernetCluster,
    EthernetCommunicationConnector,
    EthernetCommunicationController,
    EthernetFrame,
    EthernetFrameTriggering,
    EthernetNetworkConfiguration,
    EthernetPhysicalChannel,
    EthernetPriorityRegeneration,
    EthernetRawDataStreamClientMapping,
    EthernetRawDataStreamGrant,
    EthernetRawDataStreamMapping,
    EthernetRawDataStreamServerMapping,
    EthernetWakeupSleepOnDatalineConfig,
    EthernetWakeupSleepOnDatalineConfigSet,
    Eu,
    EvaluatedVariantSet,
    Evap,
    EventAcceptanceDisabled,
    EventAcceptanceEnabled,
    EventCombinationOnRetrieval,
    EventCombinationOnStorage,
    EventHandler,
    EventMapping,
    EventStorageDisabled,
    EventStorageEnabled,
    EventTriggeringConstraint,
    EventWindowCurrentAndFollowingCycle,
    EventWindowCurrentCycle,
    EventWindowInfinite,
    ExactOrAnyMinorVersion,
    Example,
    ExcludeFromFlash,
    Exclusive,
    ExclusiveArea,
    ExclusiveAreaNestingOrder,
    Executable,
    ExecutableEntity,
    ExecutableEntityActivationReason,
    ExecutableGroup,
    ExecutableTiming,
    Execute,
    ExecutionOrderConstraint,
    ExecutionTime,
    ExecutionTimeConstraint,
    Exercise,
    Explicit,
    Extended,
    ExternalReplacement,
    ExternalTriggerOccurredEvent,
    ExternalTriggeringPointIdent,
    Fa,
    FailureAndSuccess,
    FailureOnly,
    False,
    FastFlashingMode,
    Fatal,
    Fault,
    FdcThreshold,
    Fi,
    FibexElement,
    Field,
    FieldMapping,
    File,
    Filtered,
    Finish,
    FireAndForgetMapping,
    FirstContainedTrigger,
    FirstToSecond,
    FitToPage,
    FitToText,
    FixAxis,
    Fixed,
    FixedSize,
    Fixaxis,
    Fj,
    FlatInstanceDescriptor,
    FlatMap,
    FlexrayArTpConfig,
    FlexrayArTpNode,
    FlexrayCluster,
    FlexrayCommunicationConnector,
    FlexrayCommunicationController,
    FlexrayFrame,
    FlexrayFrameTriggering,
    FlexrayNmCluster,
    FlexrayNmNode,
    FlexrayPhysicalChannel,
    FlexrayTpConfig,
    FlexrayTpConnectionControl,
    FlexrayTpNode,
    FlexrayTpPduPool,
    Float,
    FmAttributeDef,
    FmFeature,
    FmFeatureMap,
    FmFeatureMapAssertion,
    FmFeatureMapCondition,
    FmFeatureMapElement,
    FmFeatureModel,
    FmFeatureRelation,
    FmFeatureRestriction,
    FmFeatureSelection,
    FmFeatureSelectionSet,
    Fo,
    ForAll,
    Forget,
    ForwardAsIs,
    Fr,
    Frame,
    FrameEthernetQueuedForTransmission,
    FrameEthernetReceivedByIf,
    FrameEthernetReceivedOnBus,
    FrameEthernetSentOnBus,
    FramePort,
    FrameQueuedForTransmission,
    FrameReceivedByIf,
    FrameTransmittedOnBus,
    FrameTriggering,
    Full,
    FullDuplexMode,
    FunctionGroupModeRequestPhmActionItem,
    FunctionGroupSet,
    FunctionInhibitionAvailabilityNeeds,
    FunctionInhibitionManager,
    FunctionInhibitionNeeds,
    Functional,
    FunctionalAddress,
    FunctionalCanFd,
    FunctionalClusterInteractsWithFunctionalClusterMapping,
    FurtherActionByteNeeds,
    Fy,
    Ga,
    Gateway,
    Gd,
    GeneralParameter,
    GeneralPurposeConnection,
    GeneralPurposeIPdu,
    GeneralPurposePdu,
    GenericEthernetFrame,
    GenericModuleInstantiation,
    Get,
    Getter,
    GetterSetter,
    Gif,
    Gl,
    GlobalSupervision,
    GlobalSupervisionEntity,
    GlobalSupervisionNeeds,
    GlobalTimeCanMaster,
    GlobalTimeCanSlave,
    GlobalTimeDomain,
    GlobalTimeEthMaster,
    GlobalTimeEthSlave,
    GlobalTimeFrMaster,
    GlobalTimeFrSlave,
    GlobalTimeGateway,
    GlobalTimeMaster,
    GlobalTimeSlave,
    Gn,
    Grant,
    GrantDesign,
    Gross,
    Gu,
    Gzip,
    Ha,
    HalfDuplexMode,
    HardwareTestManager,
    HardwareTestNeeds,
    Head,
    HealthChannel,
    HealthChannelExternalMode,
    HealthChannelExternalStatus,
    HealthChannelSupervision,
    HeapUsage,
    Hi,
    HierarchicalEoc,
    High,
    Hint,
    Hook,
    HostPort,
    Hr,
    Hu,
    Hub,
    HwAttributeDef,
    HwAttributeLiteralDef,
    HwCategory,
    HwDescriptionEntity,
    HwElement,
    HwPin,
    HwPinGroup,
    HwType,
    Hy,
    I4G,
    IPdu,
    IPduPort,
    IPduReceivedByCom,
    IPduSentToIf,
    IPduTriggering,
    IPv6ExtHeaderFilterList,
    IPv6ExtHeaderFilterSet,
    ISignal,
    ISignalAvailableForRte,
    ISignalGroup,
    ISignalIPdu,
    ISignalIPduGroup,
    ISignalPort,
    ISignalSentToCom,
    ISignalToIPduMapping,
    ISignalTriggering,
    Ia,
    IamModuleInstantiation,
    Icmp,
    IdentCaption,
    Identifiable,
    IdsCommonElement,
    IdsDesign,
    IdsMapping,
    IdsMgrCustomTimestampNeeds,
    IdsMgrNeeds,
    IdsPlatformInstantiation,
    IdsmInstance,
    IdsmModuleInstantiation,
    IdsmProperties,
    IdsmRateLimitation,
    IdsmTrafficLimitation,
    Ie,
    Ieee1722TpEthernetFrame,
    Ieee80211p,
    Ieee8021as,
    Ieee8021asAutosar,
    Ignition,
    Ignore,
    Ik,
    Immediate,
    Immediately,
    Implementation,
    ImplementationDataType,
    ImplementationDataTypeElement,
    ImplementationDataTypeElementExtension,
    ImplementationDataTypeExtension,
    ImplementationProps,
    In,
    Increasing,
    Indicate,
    IndicatorStatusNeeds,
    Individual,
    Infinite,
    InfiniteTimeToResponse,
    Info,
    InheritedFromArrayElementTypeSize,
    InitEvent,
    Inline,
    InlineConditional,
    Inout,
    Install,
    InstanceId,
    Instruction,
    InterPartitionIntraEcu,
    InterfaceMapping,
    InterfaceMappingSet,
    InternalBehavior,
    InternalTriggerOccurredEvent,
    InternalTriggeringPoint,
    InterpolationRoutineMappingSet,
    Interrupt,
    InterruptCat1,
    InterruptCat2,
    IntrusionDetectionSecurityManagement,
    Invalid,
    IpIamRemoteSubject,
    IpSecConfigProps,
    IpSecIamRemoteSubject,
    IpSecRule,
    Ipsec,
    Is,
    IsEqual,
    IsExpired,
    IsFailed,
    IsGreaterOrEqual,
    IsGreaterThan,
    IsGreaterThanOrEqual,
    IsLessOrEqual,
    IsLessThan,
    IsLessThanOrEqual,
    IsNotEqual,
    IsNotRelevant,
    IsOk,
    IsRelevant,
    IsStopped,
    Iso,
    Iso119924,
    Iso142291,
    Iso150316,
    Iso6,
    It,
    Italic,
    Iw,
    J1939,
    J1939Cluster,
    J1939ControllerApplication,
    J1939Dcm,
    J1939DcmDm19Support,
    J1939DcmIPdu,
    J1939NmCluster,
    J1939NmNode,
    J1939RequestManager,
    J1939RmIncomingRequestServiceNeeds,
    J1939RmOutgoingRequestServiceNeeds,
    J1939SharedAddressCluster,
    J1939TpConfig,
    J1939TpNode,
    Ja,
    Java,
    Ji,
    Jpg,
    Justify,
    Jw,
    Ka,
    Keep,
    KeepExisting,
    KeyDerivation,
    KeyStorage,
    Keyword,
    KeywordSet,
    Kk,
    Kl,
    Km,
    Kn,
    Ko,
    Ks,
    Ku,
    Ky,
    La,
    Land,
    LastFailed,
    LastIsBest,
    LastMode,
    LatencyTimingConstraint,
    LeafOfTargetContainer,
    Left,
    Legacy,
    LifeCycleInfoSet,
    LifeCycleState,
    LifeCycleStateDefinitionGroup,
    LimitToPage,
    LimitToText,
    LinCluster,
    LinCommunicationConnector,
    LinCommunicationController,
    LinEventTriggeredFrame,
    LinFrame,
    LinFrameTriggering,
    LinMaster,
    LinNmCluster,
    LinPhysicalChannel,
    LinScheduleTable,
    LinSlave,
    LinSlaveConfigIdent,
    LinSporadicFrame,
    LinTpConfig,
    LinTpNode,
    LinUnconditionalFrame,
    Link,
    LinkLocal,
    LinkLocalDoip,
    LinkTime,
    Linker,
    Listen,
    Ln,
    Lo,
    Local,
    LocalSupervision,
    LogAndTraceInstantiation,
    LogAndTraceInterface,
    LogAndTraceMessageCollectionSet,
    LogicAddress,
    LogicalAnd,
    LogicalExpression,
    LogicalOr,
    LogicalSupervision,
    LongHeader,
    Low,
    Lower12Bit,
    Lower8Bit,
    Lt,
    LtAffectsPb,
    Lts13,
    Lv,
    MacMulticastGroup,
    Machine,
    MachineDesign,
    MachineModeRequestPhmActionItem,
    MachineTiming,
    Macro,
    MaintenanceOnly,
    Malfunction,
    Manufacturing,
    MappingScopeCore,
    MappingScopeEcu,
    MappingScopePartition,
    MasekdNewEqualsMaskedOld,
    MasekdNewEqualsX,
    MaskedNewDiffersMaskedOld,
    MaskedNewDiffersX,
    MaskedNewEqualsMaskedOld,
    MaskedNewEqualsX,
    Master,
    MasterEcu,
    Max,
    McDataInstance,
    McFunction,
    McGroup,
    MeasuredExecutionTime,
    MeasuredHeapUsage,
    MeasuredStackUsage,
    MeasurementPoint,
    Medium,
    MemorySection,
    MethodMapping,
    Mg,
    Mi,
    Middle,
    Min,
    MinimumMinorVersion,
    Mixed,
    Mixed29Bit,
    Mk,
    Ml,
    Mn,
    Mo,
    ModeAccessPointIdent,
    ModeDeclaration,
    ModeDeclarationGroup,
    ModeDeclarationGroupPrototype,
    ModeDeclarationMapping,
    ModeDeclarationMappingSet,
    ModeDeclarationRequested,
    ModeDeclarationSwitchCompleted,
    ModeDeclarationSwitchInitiated,
    ModeInterfaceMapping,
    ModeSwitchInterface,
    ModeSwitchPoint,
    ModeSwitchedAckEvent,
    ModeTransition,
    Modeled,
    MonitorMode,
    Mono,
    Monotonous,
    MostSignificantByteFirst,
    MostSignificantByteLast,
    Mr,
    Ms,
    Mt,
    MulticoreReentrant,
    MultilanguageReferrable,
    Multiple,
    MultipleOccurrences,
    MultiplexedIPdu,
    My,
    NPdu,
    Na,
    Nand,
    Ne,
    Net,
    Network,
    NetworkConfiguration,
    NetworkEndpoint,
    NetworkRepresentationFromComSpec,
    Never,
    NewIsDifferent,
    NewIsEqual,
    NewIsGreater,
    NewIsGreaterOrEqual,
    NewIsLess,
    NewIsLessOrEqual,
    NewIsOutside,
    NewIsWithin,
    Newline,
    NewlineIfNecessary,
    Nfold,
    Nl,
    NmCluster,
    NmConfig,
    NmEcu,
    NmHandleToFunctionGroupStateMapping,
    NmInstantiation,
    NmNetworkHandle,
    NmNode,
    NmPdu,
    No,
    NoAck,
    NoAffect,
    NoBoot,
    NoBreak,
    NoDefault,
    NoFloat,
    NoHeader,
    NoKeep,
    NoMonotony,
    NoNewline,
    NoObdSupport,
    NoPgwide,
    NoProtection,
    NoReturnValueProvided,
    NoSeverity,
    NoShowAliasName,
    NoShowCategory,
    NoShowContent,
    NoShowLongName,
    NoShowNumber,
    NoShowPage,
    NoShowSee,
    NoShowShortName,
    NoShowType,
    NoSloppy,
    NoStatusByteChange,
    NoStoreEvent,
    NoSupervision,
    NoSupport,
    NoTransformerErrorHandling,
    NoTransformerStatusForwarding,
    NoTrustedPlatformSupport,
    Node,
    Nohref,
    NonEmmissionRelatedDtc,
    NonOsModuleInstantiation,
    NonReentrant,
    NonVolatile,
    NonVolatileRamManager,
    None,
    Normalfixed,
    Not,
    NotAccessible,
    NotAvailable,
    NotDefined,
    NotEqual,
    NotSent,
    NotTested,
    NotValid,
    Nothing,
    Notification,
    NtpRfc958,
    Number,
    NvBlockDescriptor,
    NvBlockNeeds,
    NvBlockSwComponentType,
    NvDataInterface,
    NvRamManager,
    Obd,
    ObdControlServiceNeeds,
    ObdDcy,
    ObdDrivingCycle,
    ObdInfoServiceNeeds,
    ObdMonitorServiceNeeds,
    ObdPidServiceNeeds,
    ObdRatioDenominatorNeeds,
    ObdRatioServiceNeeds,
    Observer,
    ObserverBased,
    Oc,
    Occurence,
    OemBoot,
    OemBootRespApp,
    Off,
    Offset,
    OffsetTimingConstraint,
    Om,
    OnChangeOfDataIdentifier,
    OnComparisonOfValues,
    OnDtcStatusChange,
    OnEntry,
    OnExit,
    OnTransition,
    OneEveryN,
    OnlyThisCycleAndReadiness,
    Opaque,
    Open,
    OperatingSystem,
    OperationCallReceived,
    OperationCallResponseReceived,
    OperationCallResponseSent,
    OperationCalled,
    OperationInvokedEvent,
    Options,
    Or,
    OrdinaryEoc,
    OsModuleInstantiation,
    OsTaskExecutionEvent,
    OsTaskProxy,
    Other,
    Out,
    Override,
    Overwrite,
    PPortPrototype,
    Pa,
    PackageableElement,
    ParameterAccess,
    ParameterDataPrototype,
    ParameterInterface,
    ParameterSwComponentType,
    PartialNetwork,
    Partition,
    PassThroughSwConnector,
    Passive,
    Passthrough,
    PayloadAsArray,
    PayloadAsPointerToArray,
    PcAffectsLt,
    PcAffectsLtAndPb,
    PcAffectsPb,
    Pdf,
    Pdu,
    PduActivationRoutingGroup,
    PduR,
    PduToFrameMapping,
    PduTriggering,
    PdurIPduGroup,
    Pending,
    PerExecutable,
    PerInstanceMemory,
    PeriodicEventTriggering,
    PeriodicRateFast,
    PeriodicRateMedium,
    PeriodicRateSlow,
    PersistencyDataElement,
    PersistencyDeployment,
    PersistencyDeploymentElement,
    PersistencyDeploymentElementToCryptoKeySlotMapping,
    PersistencyDeploymentToCryptoKeySlotMapping,
    PersistencyDeploymentToDltLogChannelMapping,
    PersistencyDeploymentToDltLogSinkMapping,
    PersistencyFile,
    PersistencyFileArray,
    PersistencyFileElement,
    PersistencyFileProxy,
    PersistencyFileProxyInterface,
    PersistencyFileProxyToFileMapping,
    PersistencyFileStorage,
    PersistencyFileStorageInterface,
    PersistencyInterface,
    PersistencyInterfaceElement,
    PersistencyKeyValueDatabase,
    PersistencyKeyValueDatabaseInterface,
    PersistencyKeyValuePair,
    PersistencyKeyValueStorage,
    PersistencyKeyValueStorageInterface,
    PersistencyPortPrototypeToDeploymentMapping,
    PersistencyPortPrototypeToFileArrayMapping,
    PersistencyPortPrototypeToFileStorageMapping,
    PersistencyPortPrototypeToKeyValueDatabaseMapping,
    PersistencyPortPrototypeToKeyValueStorageMapping,
    PersistencyRedundancyHandlingScopeDatabase,
    PersistencyRedundancyHandlingScopeElement,
    PersistencyRedundancyHandlingScopeFile,
    PersistencyRedundancyHandlingScopeKey,
    PersistencyRedundancyHandlingScopeStorage,
    Pgwide,
    PhmAbstractRecoveryNotificationInterface,
    PhmAction,
    PhmActionItem,
    PhmActionList,
    PhmArbitration,
    PhmCheckpoint,
    PhmContributionToMachineMapping,
    PhmHealthChannelInterface,
    PhmHealthChannelRecoveryNotificationInterface,
    PhmHealthChannelStatus,
    PhmLogicalExpression,
    PhmRecoveryActionInterface,
    PhmRule,
    PhmSupervisedEntityInterface,
    PhmSupervision,
    PhmSupervisionRecoveryNotificationInterface,
    Physical,
    PhysicalAddress,
    PhysicalCanFd,
    PhysicalChannel,
    PhysicalDimension,
    PhysicalDimensionMappingSet,
    Pl,
    Plain,
    PlatformActionItem,
    PlatformHealthManagementContribution,
    PlatformHealthManagementInterface,
    PlatformModuleEndpointConfiguration,
    PlatformModuleEthernetEndpointConfiguration,
    PlatformPhmActionItem,
    PncMappingIdent,
    Png,
    Poly,
    Port,
    PortBlueprint,
    PortElementToCommunicationResourceMapping,
    PortGroup,
    PortInterface,
    PortInterfaceDefinition,
    PortInterfaceMapping,
    PortInterfaceMappingSet,
    PortInterfaceToDataTypeMapping,
    PortPrototype,
    PortPrototypeBlueprint,
    PossibleErrorReaction,
    Post,
    PostBuild,
    PostBuildVariantCriterion,
    PostBuildVariantCriterionValueSet,
    Power,
    PowerWindowTime,
    PrPortPrototype,
    PreR42,
    PreCompile,
    PreCompileTime,
    PreconfiguredConfiguration,
    PredefinedVariant,
    PresentationContinuous,
    PresentationDiscrete,
    PresharedKeyIdentity,
    PrimaryEcu,
    Primitive,
    PrimitiveAttributeTailoring,
    PrioOcc,
    PrivateKey,
    Process,
    ProcessDesign,
    ProcessDesignToMachineDesignMapping,
    ProcessDesignToMachineDesignMappingSet,
    ProcessExecutionError,
    ProcessIsNotSelfTerminating,
    ProcessIsSelfTerminating,
    ProcessPhmActionItem,
    ProcessToMachineMapping,
    ProcessToMachineMappingSet,
    ProcessingStyleAsynchronous,
    ProcessingStyleAsynchronousWithError,
    ProcessingStyleSynchronous,
    Processor,
    ProcessorCore,
    Producer,
    ProtectLamp,
    Protected,
    ProvidedApServiceInstance,
    ProvidedDdsServiceInstance,
    ProvidedServiceInstance,
    ProvidedServiceInstanceToSwClusterDesignPPortPrototypeMapping,
    ProvidedSomeipServiceInstance,
    ProvidedUserDefinedServiceInstance,
    Ps,
    Psk,
    PskIdentityToKeySlotMapping,
    Pt,
    PtpIeee15882002,
    PtpIeee15882008,
    PublicKey,
    PublishedInformation,
    PureLocalTimeBase,
    Put,
    Qu,
    Queued,
    R42,
    RPortPrototype,
    RapidPrototypingScenario,
    Raw,
    RawData,
    RawDataStreamClientInterface,
    RawDataStreamDeployment,
    RawDataStreamGrant,
    RawDataStreamGrantDesign,
    RawDataStreamInterface,
    RawDataStreamMapping,
    RawDataStreamMethodDeployment,
    RawDataStreamServerInterface,
    Reaction,
    ReadOnly,
    ReadWrite,
    Reboot,
    RecommendedConfiguration,
    RecordValueField,
    RecoveryNotification,
    RecoveryNotificationToPPortPrototypeMapping,
    RecoveryViaApplicationAction,
    RecoveryViaApplicationActionToClientServerOperationMapping,
    Rect,
    RedStopLamp,
    Redundant,
    RedundantPerElement,
    RedundantPerKey,
    RefAll,
    RefNonStandard,
    RefNone,
    ReferenceTailoring,
    Referrable,
    Regular,
    Reject,
    Remove,
    RepetitiveEoc,
    Replace,
    ReplaceByTimeoutSubstitutionValue,
    Report,
    ReportAfterInit,
    ReportBeforeInit,
    ReportDtcRecordInformationOnDtcStatusChange,
    ReportMostRecentDtcOnStatusChange,
    ReportingInChronlogicalOrderOldestFirst,
    ReportsExecutionState,
    Request,
    RequestCallbackTypeManufacturer,
    RequestCallbackTypeSupplier,
    RequestNoReturn,
    RequiredApServiceInstance,
    RequiredDdsServiceInstance,
    RequiredServiceInstanceToSwClusterDesignRPortPrototypeMapping,
    RequiredSomeipServiceInstance,
    RequiredUserDefinedServiceInstance,
    RequiresCallbackExecution,
    ResAxis,
    ResetEcu,
    ResetMachine,
    ResetMcu,
    ResetVm,
    ResourceConsumption,
    ResourceGroup,
    RespondAfterReset,
    RespondBeforeReset,
    Response,
    ResponseSynchronization,
    RestAbstractEndpoint,
    RestAbstractNumericalPropertyDef,
    RestAbstractPropertyDef,
    RestArrayPropertyDef,
    RestBooleanPropertyDef,
    RestElementDef,
    RestEndpointDelete,
    RestEndpointGet,
    RestEndpointPost,
    RestEndpointPut,
    RestHttpPortPrototypeMapping,
    RestIntegerPropertyDef,
    RestNumberPropertyDef,
    RestObjectRef,
    RestPrimitivePropertyDef,
    RestResourceDef,
    RestServiceInterface,
    RestStringPropertyDef,
    Restart,
    RestartApplication,
    Resaxis,
    ReturnOnEventCleared,
    ReturnOnEventStopped,
    ReturnValueProvided,
    Right,
    Rm,
    Rn,
    Ro,
    RollBack,
    RootSwClusterDesignComponentPrototype,
    RootSwComponentPrototype,
    RootSwCompositionPrototype,
    Rotate180,
    Rotate180LimitToText,
    Rotate90Ccw,
    Rotate90CcwFitToText,
    Rotate90CcwLimitToText,
    Rotate90Cw,
    Rotate90CwFitToText,
    Rotate90CwLimitToText,
    RoughEstimateHeapUsage,
    RoughEstimateOfExecutionTime,
    RoughEstimateStackUsage,
    Router,
    RouterAdvertisement,
    RptComponent,
    RptContainer,
    RptEnablerRam,
    RptEnablerRamAndRom,
    RptEnablerRom,
    RptExecutableEntity,
    RptExecutableEntityEvent,
    RptExecutionContext,
    RptLevel1,
    RptLevel2,
    RptLevel3,
    RptProfile,
    RptServicePoint,
    Rsa,
    RteEvent,
    RteEventInCompositionSeparation,
    RteEventInCompositionToOsTaskProxyMapping,
    RteEventInSystemSeparation,
    RteEventInSystemToOsTaskProxyMapping,
    Rtpge,
    Ru,
    Rule,
    RunContinuous,
    RunOnce,
    RunnableEntity,
    RunnableEntityActivated,
    RunnableEntityGroup,
    RunnableEntityStarted,
    RunnableEntityTerminated,
    RunnableEntityVariableAccess,
    RuntimeError,
    Rw,
    RxTrigger,
    Sa,
    SaeJ193973,
    SaeJ2012Da,
    Safety,
    Saturate,
    ScheduleVariant1,
    ScheduleVariant2,
    ScheduleVariant3,
    ScheduleVariant4,
    ScheduleVariant5,
    ScheduleVariant6,
    ScheduleVariant7,
    Scheduled,
    Sd,
    SdgAbstractForeignReference,
    SdgAbstractPrimitiveAttribute,
    SdgAggregationWithVariation,
    SdgAttribute,
    SdgCaption,
    SdgClass,
    SdgDef,
    SdgForeignReference,
    SdgForeignReferenceWithVariation,
    SdgPrimitiveAttribute,
    SdgPrimitiveAttributeWithVariation,
    SdgReference,
    SdgTailoring,
    SearchForAll,
    SearchForAllInstances,
    SearchForAny,
    SearchForId,
    SearchForSpecificInstance,
    SecOcCryptoServiceMapping,
    SecOcDeployment,
    SecOcJobMapping,
    SecOcJobRequirement,
    SecOcSecureComProps,
    SecondToFirst,
    SecondaryEcu,
    SecretSeed,
    SectionNamePrefix,
    SecureComProps,
    SecureComPropsSet,
    SecureCommunicationAuthenticationProps,
    SecureCommunicationDeployment,
    SecureCommunicationFreshnessProps,
    SecureCommunicationPropsSet,
    SecureOnBoardCommunication,
    SecureOnBoardCommunicationNeeds,
    SecuredIPdu,
    SecuredPduHeader08Bit,
    SecuredPduHeader16Bit,
    SecuredPduHeader32Bit,
    Security,
    SecurityEventAggregationFilter,
    SecurityEventContextMapping,
    SecurityEventContextMappingApplication,
    SecurityEventContextMappingBswModule,
    SecurityEventContextMappingCommConnector,
    SecurityEventContextMappingFunctionalCluster,
    SecurityEventContextProps,
    SecurityEventDefinition,
    SecurityEventFilterChain,
    SecurityEventMapping,
    SecurityEventOneEveryNFilter,
    SecurityEventReportInterface,
    SecurityEventReportToSecurityEventDefinitionMapping,
    SecurityEventStateFilter,
    SecurityEventThresholdFilter,
    Selected,
    SenderReceiverInterface,
    SensorActuatorSwComponentType,
    SentTagged,
    SentUntagged,
    SerializationTechnology,
    Serializer,
    ServerAuthenticate,
    ServerCallPoint,
    ServerDecrypt,
    ServerEncrypt,
    ServerMacGenerate,
    ServerMacVerify,
    ServerVerify,
    ServiceDiscovery,
    ServiceEventDeployment,
    ServiceFieldDeployment,
    ServiceInstanceCollectionSet,
    ServiceInstanceToApplicationEndpointMapping,
    ServiceInstanceToMachineMapping,
    ServiceInstanceToPortPrototypeMapping,
    ServiceInstanceToSignalMapping,
    ServiceInstanceToSignalMappingSet,
    ServiceInstanceToSwClusterDesignPortPrototypeMapping,
    ServiceInterface,
    ServiceInterfaceApplicationErrorMapping,
    ServiceInterfaceDeployment,
    ServiceInterfaceElementMapping,
    ServiceInterfaceElementSecureComConfig,
    ServiceInterfaceEventMapping,
    ServiceInterfaceFieldMapping,
    ServiceInterfaceMapping,
    ServiceInterfaceMappingSet,
    ServiceInterfaceMethodMapping,
    ServiceInterfacePedigree,
    ServiceInterfaceTriggerMapping,
    ServiceMethodDeployment,
    ServiceNeeds,
    ServiceOnly,
    ServiceProxySwComponentType,
    ServiceSwComponentType,
    ServiceTiming,
    SessionHandlingActive,
    SessionHandlingInactive,
    Setter,
    Sg,
    Sh,
    ShortHeader,
    ShowAliasName,
    ShowCategory,
    ShowContent,
    ShowLongName,
    ShowNumber,
    ShowPage,
    ShowSee,
    ShowShortName,
    ShowType,
    Si,
    Sides,
    Sign,
    SignWithOriginAuthentication,
    SignalBased,
    SignalBasedEventDeployment,
    SignalBasedEventElementToISignalTriggeringMapping,
    SignalBasedFieldDeployment,
    SignalBasedFieldToISignalTriggeringMapping,
    SignalBasedMethodDeployment,
    SignalBasedMethodToISignalTriggeringMapping,
    SignalBasedServiceInterfaceDeployment,
    SignalBasedTriggerToISignalTriggeringMapping,
    SignalServiceTranslationElementProps,
    SignalServiceTranslationEventProps,
    SignalServiceTranslationProps,
    SignalServiceTranslationPropsSet,
    Signature,
    Silent,
    SimulatedExecutionTime,
    Single,
    SingleCoreReentrant,
    SingleLanguageReferrable,
    SingleOccurrence,
    Sk,
    Sl,
    Slave,
    Sloppy,
    SlowFlashingMode,
    Slp,
    Sm,
    Sn,
    So,
    SoAdRoutingGroup,
    SoConIPduIdentifier,
    SocketAddress,
    SocketConnectionBundle,
    SocketConnectionIpduIdentifierSet,
    SoftwareActivationDependency,
    SoftwareCluster,
    SoftwareClusterDesign,
    SoftwareClusterRequirement,
    SoftwarePackage,
    SoftwarePackageStep,
    Someip,
    SomeipDataPrototypeTransformationProps,
    SomeipEvent,
    SomeipEventDeployment,
    SomeipEventGroup,
    SomeipField,
    SomeipFieldDeployment,
    SomeipMethod,
    SomeipMethodDeployment,
    SomeipProvidedEventGroup,
    SomeipRequiredEventGroup,
    SomeipSdClientEventGroupTimingConfig,
    SomeipSdClientServiceInstanceConfig,
    SomeipSdServerEventGroupTimingConfig,
    SomeipSdServerServiceInstanceConfig,
    SomeipServiceInstanceToMachineMapping,
    SomeipServiceInterface,
    SomeipServiceInterfaceDeployment,
    SomeipTpChannel,
    SomeipTpConfig,
    SomeipTransformationProps,
    SpecElementReference,
    SpecElementScope,
    SpecificationDocumentScope,
    SporadicEventTriggering,
    Sq,
    Sr,
    Ss,
    Ssdp,
    St,
    StackUsage,
    Standard,
    StandardPort,
    Start,
    StartFromBeginning,
    StartupConfig,
    StartupConfigSet,
    StaticOrDynamicPartTrigger,
    StaticPartTrigger,
    StaticSocketConnection,
    StatusBitAgingAndDisplacement,
    StatusBitNormal,
    Std,
    StdAxis,
    StdCppImplementationDataType,
    Stdaxis,
    Steady,
    StimulusSynchronization,
    Stop,
    StopTrigger,
    StoreEvent,
    StorePersistently,
    StrictMode,
    StrictMonotonous,
    StrictPriority,
    StrictlyDecreasing,
    StrictlyIncreasing,
    StructuredReq,
    Su,
    SupervisedEntityCheckpointNeeds,
    SupervisedEntityNeeds,
    SupervisionCheckpoint,
    SupervisionEntity,
    SupervisionMode,
    SupervisionModeCondition,
    Supplier,
    SupportsBufferLocking,
    Sv,
    Svg,
    Sw,
    SwAddrMethod,
    SwAxisType,
    SwBaseType,
    SwCalibrationMethod,
    SwCalprmPrototype,
    SwClassAttrImpl,
    SwClassInstance,
    SwClassPrototype,
    SwCodeSyntax,
    SwComponentMappingConstraints,
    SwComponentPrototype,
    SwComponentType,
    SwConnector,
    SwGenericAxisParamType,
    SwInstance,
    SwMcBaseType,
    SwMcFrame,
    SwMcInterface,
    SwMcInterfaceSource,
    SwRecordLayout,
    SwServiceArg,
    SwServicePrototype,
    SwSystemconst,
    SwSystemconstantValueSet,
    SwVariablePrototype,
    Swc,
    SwcBswMapping,
    SwcImplementation,
    SwcInternalBehavior,
    SwcModeManagerErrorEvent,
    SwcModeSwitchEvent,
    SwcServiceDependency,
    SwcTiming,
    SwcToApplicationPartitionMapping,
    SwcToEcuMapping,
    SwcToImplMapping,
    Switch,
    SymbolProps,
    SymbolicNameProps,
    Symmetric,
    SymmetricKey,
    SyncBaseTimeManager,
    SyncTimeBaseMgrUserNeeds,
    SynchronizationPointConstraint,
    SynchronizationTimingConstraint,
    Synchronized,
    SynchronizedMasterTimeBase,
    SynchronizedSlaveTimeBase,
    SynchronizedTimeBaseConsumer,
    SynchronizedTimeBaseConsumerInterface,
    SynchronizedTimeBaseProvider,
    SynchronizedTimeBaseProviderInterface,
    Synchronous,
    SynchronousServerCallPoint,
    System,
    SystemDesignTime,
    SystemMapping,
    SystemMemoryUsage,
    SystemSignal,
    SystemSignalGroup,
    SystemSupplierBoot,
    SystemSupplierBootRespApp,
    SystemTiming,
    Ta,
    TargetContainer,
    Task,
    Tc,
    Tcp,
    TcpOptionFilterList,
    TcpOptionFilterSet,
    TdCpSoftwareClusterMapping,
    TdCpSoftwareClusterMappingSet,
    TdCpSoftwareClusterResourceMapping,
    TdEventBsw,
    TdEventBswInternalBehavior,
    TdEventBswModeDeclaration,
    TdEventBswModule,
    TdEventCom,
    TdEventComplex,
    TdEventCycleStart,
    TdEventFrClusterCycleStart,
    TdEventFrame,
    TdEventFrameEthernet,
    TdEventIPdu,
    TdEventISignal,
    TdEventModeDeclaration,
    TdEventOperation,
    TdEventServiceInstance,
    TdEventServiceInstanceDiscovery,
    TdEventServiceInstanceEvent,
    TdEventServiceInstanceField,
    TdEventServiceInstanceMethod,
    TdEventSwc,
    TdEventSwcInternalBehavior,
    TdEventSwcInternalBehaviorReference,
    TdEventTrigger,
    TdEventTtCanCycleStart,
    TdEventVariableDataPrototype,
    TdEventVfb,
    TdEventVfbPort,
    TdEventVfbReference,
    Te,
    Terminate,
    TestFailed,
    TestFailedBit,
    TestFailedThisOperationCycle,
    Tested,
    TestedAndFailed,
    Tg,
    Th,
    Ti,
    Tiff,
    Time,
    TimeBaseProviderToPersistencyMapping,
    TimeBaseResource,
    TimeSyncModuleInstantiation,
    TimeSyncPortPrototypeToTimeBaseMapping,
    TimeSyncServerConfiguration,
    TimeSynchronizationInterface,
    TimeSynchronizationMasterInterface,
    TimeSynchronizationPureLocalInterface,
    TimeSynchronizationSlaveInterface,
    TimingCondition,
    TimingConstraint,
    TimingDescription,
    TimingDescriptionEvent,
    TimingDescriptionEventChain,
    TimingEvent,
    TimingExtension,
    TimingExtensionResource,
    TimingModeInstance,
    Tip,
    Tk,
    Tl,
    Tls12,
    Tls13,
    TlsConnectionGroup,
    TlsCryptoCipherSuite,
    TlsCryptoCipherSuiteProps,
    TlsCryptoServiceMapping,
    TlsDeployment,
    TlsIamRemoteSubject,
    TlsJobMapping,
    TlsJobRequirement,
    TlsSecureComProps,
    TlvDataIdDefinitionSet,
    Tn,
    To,
    Top,
    Topbot,
    Topic,
    Topic1,
    TopicPrefix,
    TpAddress,
    TpConfig,
    TpConnectionIdent,
    Tr,
    Trace,
    TraceReferrable,
    Traceable,
    TraceableTable,
    TraceableText,
    TracedFailure,
    Transfer,
    TransformationProps,
    TransformationPropsSet,
    TransformationPropsToServiceInterfaceElementMapping,
    TransformationPropsToServiceInterfaceElementMappingSet,
    TransformationPropsToServiceInterfaceMappingSet,
    TransformationTechnology,
    TransformerErrorHandling,
    TransformerHardErrorEvent,
    TransformerStatusForwarding,
    TransformingISignal,
    TransientFault,
    TranslationStart,
    Transport,
    TransportLayerIndependentIdCollectionSet,
    TransportLayerIndependentInstanceId,
    Trap,
    Trigger,
    TriggerActivated,
    TriggerInterface,
    TriggerInterfaceMapping,
    TriggerReleased,
    TriggerUnicast,
    Triggered,
    TriggeredOnChange,
    TriggeredOnChangeWithoutRepetition,
    TriggeredOnEvaluation,
    TriggeredWithoutRepetition,
    True,
    Ts,
    Tt,
    TtcanCluster,
    TtcanCommunicationConnector,
    TtcanCommunicationController,
    TtcanPhysicalChannel,
    Tunnel,
    Tw,
    TxRefTrigger,
    TxRefTriggerGap,
    TxTriggerMerged,
    TxTriggerSingle,
    Ucm,
    UcmDescription,
    UcmMaster,
    UcmModuleInstantiation,
    UcmStep,
    Udp,
    UdpChecksumDisabled,
    UdpChecksumEnabled,
    UdpNm,
    UdpNmCluster,
    UdpNmNode,
    Uds,
    Uk,
    Undecided,
    Undefined,
    Unit,
    UnitGroup,
    Unnumber,
    Unspecified,
    UpLinkPort,
    Update,
    UploadableExclusivePackageElement,
    UploadablePackageElement,
    Ur,
    UseArgumentType,
    UseArrayBaseType,
    UseFirstContextData,
    UseLastContextData,
    UseVoid,
    UserDefined,
    UserDefinedCluster,
    UserDefinedCommunicationConnector,
    UserDefinedCommunicationController,
    UserDefinedEthernetFrame,
    UserDefinedEventDeployment,
    UserDefinedFieldDeployment,
    UserDefinedGlobalTimeMaster,
    UserDefinedGlobalTimeSlave,
    UserDefinedIPdu,
    UserDefinedMethodDeployment,
    UserDefinedPdu,
    UserDefinedPhysicalChannel,
    UserDefinedServiceInstanceToMachineMapping,
    UserDefinedServiceInterfaceDeployment,
    UserDefinedTransformationProps,
    UsesLogging,
    Uz,
    V2XActiveSupported,
    V2XFacUserNeeds,
    V2XFacilities,
    V2XMUserNeeds,
    V2XManagement,
    V2XNotSupported,
    Valid,
    Var,
    VarFast,
    VarNoInit,
    VarPowerOnInit,
    VariableAccess,
    VariableAndParameterInterfaceMapping,
    VariableDataPrototype,
    VariableDataPrototypeReceived,
    VariableDataPrototypeSent,
    VariableSize,
    VariantLinkTime,
    VariantPostBuild,
    VariantPostBuildLoadable,
    VariantPostBuildSelectable,
    VariantPreCompile,
    VariationPointProxy,
    VehiclePackage,
    VehicleRolloutStep,
    VendorSpecific,
    VendorSpecificServiceNeeds,
    Verbose,
    Verification,
    Verify,
    VertexOfTargetContainer,
    VfbTiming,
    Vi,
    ViewMap,
    ViewMapSet,
    VlanConfig,
    Vo,
    Volatile,
    WaitPoint,
    WaitTimeDate,
    Warmup,
    Warn,
    Warning,
    WarningIndicatorRequestedBitNeeds,
    WatchDogManager,
    WatchTrigger,
    WatchTriggerGap,
    WatchdogActionItem,
    WatchdogPhmActionItem,
    WeightedRoundRobin,
    WillCall,
    WillReceive,
    WillSend,
    Wo,
    WontCall,
    WontReceive,
    WontSend,
    WorstCaseHeapUsage,
    WorstCaseStackUsage,
    WriteOnly,
    WrongTrigger,
    X509,
    XMii,
    XMmi,
    Xcp,
    XcpPdu,
    Xdoc,
    Xfile,
    XgMii,
    Xh,
    Xor,
    XrefTarget,
    XxgMii,
    Yo,
    Zh,
    Zu,
    default,
    preserve,
}

Expand description

Enum of all possible enum values in Autosar

Variants

`_500Miles`

-500-MILES

`_1000baseT`

1000BASE-T

`_1000baseT1`

1000BASE-T1

`_100baseT1`

100BASE-T1

`_100baseTx`

100BASE-TX

`_10baseT1s`

10BASE-T1S

`Aa`

AA

`Ab`

AB

`Abstract`

ABSTRACT

`AbstractAccessPoint`

ABSTRACT-ACCESS-POINT

`AbstractCanCluster`

ABSTRACT-CAN-CLUSTER

`AbstractCanCommunicationConnector`

ABSTRACT-CAN-COMMUNICATION-CONNECTOR

`AbstractCanCommunicationController`

ABSTRACT-CAN-COMMUNICATION-CONTROLLER

`AbstractCanPhysicalChannel`

ABSTRACT-CAN-PHYSICAL-CHANNEL

`AbstractClassTailoring`

ABSTRACT-CLASS-TAILORING

`AbstractDoIpLogicAddressProps`

ABSTRACT-DO-IP-LOGIC-ADDRESS-PROPS

`AbstractEthernetFrame`

ABSTRACT-ETHERNET-FRAME

`AbstractEvent`

ABSTRACT-EVENT

`AbstractExecutionContext`

ABSTRACT-EXECUTION-CONTEXT

`AbstractIamRemoteSubject`

ABSTRACT-IAM-REMOTE-SUBJECT

`AbstractImplementationDataType`

ABSTRACT-IMPLEMENTATION-DATA-TYPE

`AbstractImplementationDataTypeElement`

ABSTRACT-IMPLEMENTATION-DATA-TYPE-ELEMENT

`AbstractProvidedPortPrototype`

ABSTRACT-PROVIDED-PORT-PROTOTYPE

`AbstractRawDataStreamInterface`

ABSTRACT-RAW-DATA-STREAM-INTERFACE

`AbstractRequiredPortPrototype`

ABSTRACT-REQUIRED-PORT-PROTOTYPE

`AbstractSecurityEventFilter`

ABSTRACT-SECURITY-EVENT-FILTER

`AbstractSecurityIdsmInstanceFilter`

ABSTRACT-SECURITY-IDSM-INSTANCE-FILTER

`AbstractServiceInstance`

ABSTRACT-SERVICE-INSTANCE

`AbstractSignalBasedToISignalTriggeringMapping`

ABSTRACT-SIGNAL-BASED-TO-I-SIGNAL-TRIGGERING-MAPPING

`AbstractSynchronizedTimeBaseInterface`

ABSTRACT-SYNCHRONIZED-TIME-BASE-INTERFACE

`AcceptAll`

ACCEPT-ALL

`AcceptConfigured`

ACCEPT-CONFIGURED

`AccesPerrmissionServiceClass`

ACCES-PERRMISSION-SERVICE-CLASS

`AccessPermissionInstanceOverridesClass`

ACCESS-PERMISSION-INSTANCE-OVERRIDES-CLASS

`AccessPermissionServiceClass`

ACCESS-PERMISSION-SERVICE-CLASS

`AccessPermissionServiceInstance`

ACCESS-PERMISSION-SERVICE-INSTANCE

`AckWithRt`

ACK-WITH-RT

`AckWithoutRt`

ACK-WITHOUT-RT

`AclObjectSet`

ACL-OBJECT-SET

`AclOperation`

ACL-OPERATION

`AclPermission`

ACL-PERMISSION

`AclRole`

ACL-ROLE

`Action`

ACTION

`ActionItem`

ACTION-ITEM

`ActionList`

ACTION-LIST

`Activate`

ACTIVATE

`ActivationAndTriggerUnicast`

ACTIVATION-AND-TRIGGER-UNICAST

`ActivationMulticast`

ACTIVATION-MULTICAST

`ActivationUnicast`

ACTIVATION-UNICAST

`Active`

ACTIVE

`AdaptiveApplicationSwComponentType`

ADAPTIVE-APPLICATION-SW-COMPONENT-TYPE

`AdaptiveAutosarApplication`

ADAPTIVE-AUTOSAR-APPLICATION

`AdaptiveEventReceived`

ADAPTIVE-EVENT-RECEIVED

`AdaptiveEventSent`

ADAPTIVE-EVENT-SENT

`AdaptiveFieldGetterCalled`

ADAPTIVE-FIELD-GETTER-CALLED

`AdaptiveFieldGetterCompleted`

ADAPTIVE-FIELD-GETTER-COMPLETED

`AdaptiveFieldNotificationReceived`

ADAPTIVE-FIELD-NOTIFICATION-RECEIVED

`AdaptiveFieldNotificationSent`

ADAPTIVE-FIELD-NOTIFICATION-SENT

`AdaptiveFieldSetterCalled`

ADAPTIVE-FIELD-SETTER-CALLED

`AdaptiveFieldSetterCompleted`

ADAPTIVE-FIELD-SETTER-COMPLETED

`AdaptiveMethodCallReceived`

ADAPTIVE-METHOD-CALL-RECEIVED

`AdaptiveMethodCalled`

ADAPTIVE-METHOD-CALLED

`AdaptiveMethodResponseReceived`

ADAPTIVE-METHOD-RESPONSE-RECEIVED

`AdaptiveMethodResponseSent`

ADAPTIVE-METHOD-RESPONSE-SENT

`AdaptiveModuleInstantiation`

ADAPTIVE-MODULE-INSTANTIATION

`AdaptivePlatformServiceInstance`

ADAPTIVE-PLATFORM-SERVICE-INSTANCE

`AdaptiveServiceFindCompleted`

ADAPTIVE-SERVICE-FIND-COMPLETED

`AdaptiveServiceFindStarted`

ADAPTIVE-SERVICE-FIND-STARTED

`AdaptiveServiceOfferCompleted`

ADAPTIVE-SERVICE-OFFER-COMPLETED

`AdaptiveServiceOfferStarted`

ADAPTIVE-SERVICE-OFFER-STARTED

`AdaptiveServiceStopSubscriptionCompleted`

ADAPTIVE-SERVICE-STOP-SUBSCRIPTION-COMPLETED

`AdaptiveServiceStopSubscriptionStarted`

ADAPTIVE-SERVICE-STOP-SUBSCRIPTION-STARTED

`AdaptiveServiceSubscriptionAcknowledgeCompleted`

ADAPTIVE-SERVICE-SUBSCRIPTION-ACKNOWLEDGE-COMPLETED

`AdaptiveServiceSubscriptionAcknowledgeStarted`

ADAPTIVE-SERVICE-SUBSCRIPTION-ACKNOWLEDGE-STARTED

`AdaptiveServiceSubscriptionCompleted`

ADAPTIVE-SERVICE-SUBSCRIPTION-COMPLETED

`AdaptiveServiceSubscriptionStarted`

ADAPTIVE-SERVICE-SUBSCRIPTION-STARTED

`AdaptiveSwcInternalBehavior`

ADAPTIVE-SWC-INTERNAL-BEHAVIOR

`AddrMethodShortName`

ADDR-METHOD-SHORT-NAME

`AddrMethodShortNameAndAlignment`

ADDR-METHOD-SHORT-NAME-AND-ALIGNMENT

`Af`

AF

`AfterSales`

AFTER-SALES

`Aftermaket`

AFTERMAKET

`Aftermarket`

AFTERMARKET

`Age`

AGE

`AgeConstraint`

AGE-CONSTRAINT

`AggregationTailoring`

AGGREGATION-TAILORING

`Agreed`

AGREED

`Ah`

AH

`AliasNameSet`

ALIAS-NAME-SET

`AliveSupervision`

ALIVE-SUPERVISION

`All`

ALL

`All16Bit`

ALL-16-BIT

`AllIndicesDifferentArraySize`

ALL-INDICES-DIFFERENT-ARRAY-SIZE

`AllIndicesSameArraySize`

ALL-INDICES-SAME-ARRAY-SIZE

`AllSupportedDtcs`

ALL-SUPPORTED-DTCS

`Allocator`

ALLOCATOR

`Alternating8Bit`

ALTERNATING-8-BIT

`Always`

ALWAYS

`Am`

AM

`AmberWarning`

AMBER-WARNING

`AnalyzedExecutionTime`

ANALYZED-EXECUTION-TIME

`And`

AND

`Any`

ANY

`AnySendOperation`

ANY-SEND-OPERATION

`AnyStandardized`

ANY-STANDARDIZED

`Ap`

AP

`ApApplicationEndpoint`

AP-APPLICATION-ENDPOINT

`ApApplicationError`

AP-APPLICATION-ERROR

`ApApplicationErrorDomain`

AP-APPLICATION-ERROR-DOMAIN

`ApApplicationErrorSet`

AP-APPLICATION-ERROR-SET

`ApSomeipTransformationProps`

AP-SOMEIP-TRANSFORMATION-PROPS

`Api`

API

`ApiBased`

API-BASED

`ApiUse`

API-USE

`AppOsTaskProxyToEcuTaskProxyMapping`

APP-OS-TASK-PROXY-TO-ECU-TASK-PROXY-MAPPING

`Application`

APPLICATION

`ApplicationActionItem`

APPLICATION-ACTION-ITEM

`ApplicationArrayDataType`

APPLICATION-ARRAY-DATA-TYPE

`ApplicationArrayElement`

APPLICATION-ARRAY-ELEMENT

`ApplicationAssocMapDataType`

APPLICATION-ASSOC-MAP-DATA-TYPE

`ApplicationAssocMapElement`

APPLICATION-ASSOC-MAP-ELEMENT

`ApplicationCompositeDataType`

APPLICATION-COMPOSITE-DATA-TYPE

`ApplicationCompositeElementDataPrototype`

APPLICATION-COMPOSITE-ELEMENT-DATA-PROTOTYPE

`ApplicationDataType`

APPLICATION-DATA-TYPE

`ApplicationDeferredDataType`

APPLICATION-DEFERRED-DATA-TYPE

`ApplicationEndpoint`

APPLICATION-ENDPOINT

`ApplicationError`

APPLICATION-ERROR

`ApplicationInterface`

APPLICATION-INTERFACE

`ApplicationModeRequestPhmActionItem`

APPLICATION-MODE-REQUEST-PHM-ACTION-ITEM

`ApplicationOnly`

APPLICATION-ONLY

`ApplicationPartition`

APPLICATION-PARTITION

`ApplicationPartitionToEcuPartitionMapping`

APPLICATION-PARTITION-TO-ECU-PARTITION-MAPPING

`ApplicationPrimitiveDataType`

APPLICATION-PRIMITIVE-DATA-TYPE

`ApplicationRecordDataType`

APPLICATION-RECORD-DATA-TYPE

`ApplicationRecordElement`

APPLICATION-RECORD-ELEMENT

`ApplicationSwComponentType`

APPLICATION-SW-COMPONENT-TYPE

`Ar`

AR

`ArClientServer`

AR–CLIENT–SERVER

`ArElement`

AR-ELEMENT

`ArPackage`

AR-PACKAGE

`ArbitraryEventTriggering`

ARBITRARY-EVENT-TRIGGERING

`Arbitration`

ARBITRATION

`ArgumentDataPrototype`

ARGUMENT-DATA-PROTOTYPE

`Array`

ARRAY

`ArtifactChecksum`

ARTIFACT-CHECKSUM

`ArtifactChecksumToCryptoProviderMapping`

ARTIFACT-CHECKSUM-TO-CRYPTO-PROVIDER-MAPPING

`As`

AS

`AsIs`

AS-IS

`AssemblySwConnector`

ASSEMBLY-SW-CONNECTOR

`AsymmetricFromByteArray`

ASYMMETRIC-FROM-BYTE-ARRAY

`AsymmetricToByteArray`

ASYMMETRIC-TO-BYTE-ARRAY

`Asynchronous`

ASYNCHRONOUS

`AsynchronousServerCallPoint`

ASYNCHRONOUS-SERVER-CALL-POINT

`AsynchronousServerCallResultPoint`

ASYNCHRONOUS-SERVER-CALL-RESULT-POINT

`AsynchronousServerCallReturnsEvent`

ASYNCHRONOUS-SERVER-CALL-RETURNS-EVENT

`AtomicSwComponentType`

ATOMIC-SW-COMPONENT-TYPE

`AtpBlueprint`

ATP-BLUEPRINT

`AtpBlueprintable`

ATP-BLUEPRINTABLE

`AtpClassifier`

ATP-CLASSIFIER

`AtpDefinition`

ATP-DEFINITION

`AtpFeature`

ATP-FEATURE

`AtpPrototype`

ATP-PROTOTYPE

`AtpStructureElement`

ATP-STRUCTURE-ELEMENT

`AtpType`

ATP-TYPE

`AttributeTailoring`

ATTRIBUTE-TAILORING

`Authenticate`

AUTHENTICATE

`Auto`

AUTO

`AutoIp`

AUTO-IP

`AutoIpDoip`

AUTO-IP–DOIP

`AutoIpdhcpv4`

AUTO-IPDHCPV-4

`Autonomous`

AUTONOMOUS

`AutosarDataPrototype`

AUTOSAR-DATA-PROTOTYPE

`AutosarDataType`

AUTOSAR-DATA-TYPE

`AutosarOperationArgumentInstance`

AUTOSAR-OPERATION-ARGUMENT-INSTANCE

`AutosarVariableInstance`

AUTOSAR-VARIABLE-INSTANCE

`AvbIeee8021As`

AVB–IEEE-802–1-AS

`Ay`

AY

`Az`

AZ

`Ba`

BA

`BackgroundEvent`

BACKGROUND-EVENT

`BaseT`

BASE-T

`BaseType`

BASE-TYPE

`BasicSoftwareModeManager`

BASIC-SOFTWARE-MODE-MANAGER

`Be`

BE

`Bg`

BG

`Bh`

BH

`Bi`

BI

`Bidirectional`

BIDIRECTIONAL

`BinaryManifestAddressableObject`

BINARY-MANIFEST-ADDRESSABLE-OBJECT

`BinaryManifestItem`

BINARY-MANIFEST-ITEM

`BinaryManifestItemDefinition`

BINARY-MANIFEST-ITEM-DEFINITION

`BinaryManifestMetaDataField`

BINARY-MANIFEST-META-DATA-FIELD

`BinaryManifestProvideResource`

BINARY-MANIFEST-PROVIDE-RESOURCE

`BinaryManifestRequireResource`

BINARY-MANIFEST-REQUIRE-RESOURCE

`BinaryManifestResource`

BINARY-MANIFEST-RESOURCE

`BinaryManifestResourceDefinition`

BINARY-MANIFEST-RESOURCE-DEFINITION

`BlinkMode`

BLINK-MODE

`BlinkOrContinuousOnMode`

BLINK-OR-CONTINUOUS-ON-MODE

`BlockSource`

BLOCK-SOURCE

`BlockState`

BLOCK-STATE

`BlueprintDerivationTime`

BLUEPRINT-DERIVATION-TIME

`BlueprintMappingSet`

BLUEPRINT-MAPPING-SET

`Bmp`

BMP

`Bn`

BN

`Bo`

BO

`Bold`

BOLD

`Bolditalic`

BOLDITALIC

`Bonjour`

BONJOUR

`Bottom`

BOTTOM

`Br`

BR

`Break`

BREAK

`Brief`

BRIEF

`BriefBypassingFilters`

BRIEF-BYPASSING-FILTERS

`BroadRReach`

BROAD-R-REACH

`Bsw`

BSW

`BswAsynchronousServerCallPoint`

BSW-ASYNCHRONOUS-SERVER-CALL-POINT

`BswAsynchronousServerCallResultPoint`

BSW-ASYNCHRONOUS-SERVER-CALL-RESULT-POINT

`BswAsynchronousServerCallReturnsEvent`

BSW-ASYNCHRONOUS-SERVER-CALL-RETURNS-EVENT

`BswBackgroundEvent`

BSW-BACKGROUND-EVENT

`BswCalledEntity`

BSW-CALLED-ENTITY

`BswCompositionTiming`

BSW-COMPOSITION-TIMING

`BswDataReceivedEvent`

BSW-DATA-RECEIVED-EVENT

`BswDebugInfo`

BSW-DEBUG-INFO

`BswDirectCallPoint`

BSW-DIRECT-CALL-POINT

`BswDistinguishedPartition`

BSW-DISTINGUISHED-PARTITION

`BswEntryRelationshipSet`

BSW-ENTRY-RELATIONSHIP-SET

`BswEvent`

BSW-EVENT

`BswExternalTriggerOccurredEvent`

BSW-EXTERNAL-TRIGGER-OCCURRED-EVENT

`BswImplementation`

BSW-IMPLEMENTATION

`BswInternalBehavior`

BSW-INTERNAL-BEHAVIOR

`BswInternalTriggerOccurredEvent`

BSW-INTERNAL-TRIGGER-OCCURRED-EVENT

`BswInternalTriggeringPoint`

BSW-INTERNAL-TRIGGERING-POINT

`BswInterruptEntity`

BSW-INTERRUPT-ENTITY

`BswMEntryCallReturned`

BSW-M-ENTRY-CALL-RETURNED

`BswMEntryCalled`

BSW-M-ENTRY-CALLED

`BswMgrNeeds`

BSW-MGR-NEEDS

`BswModeManagerErrorEvent`

BSW-MODE-MANAGER-ERROR-EVENT

`BswModeSwitchEvent`

BSW-MODE-SWITCH-EVENT

`BswModeSwitchedAckEvent`

BSW-MODE-SWITCHED-ACK-EVENT

`BswModuleCallPoint`

BSW-MODULE-CALL-POINT

`BswModuleClientServerEntry`

BSW-MODULE-CLIENT-SERVER-ENTRY

`BswModuleDependency`

BSW-MODULE-DEPENDENCY

`BswModuleDescription`

BSW-MODULE-DESCRIPTION

`BswModuleEntity`

BSW-MODULE-ENTITY

`BswModuleEntityActivated`

BSW-MODULE-ENTITY-ACTIVATED

`BswModuleEntityStarted`

BSW-MODULE-ENTITY-STARTED

`BswModuleEntityTerminated`

BSW-MODULE-ENTITY-TERMINATED

`BswModuleEntry`

BSW-MODULE-ENTRY

`BswModuleTiming`

BSW-MODULE-TIMING

`BswOperationInvokedEvent`

BSW-OPERATION-INVOKED-EVENT

`BswOsTaskExecutionEvent`

BSW-OS-TASK-EXECUTION-EVENT

`BswSchedulableEntity`

BSW-SCHEDULABLE-ENTITY

`BswScheduleEvent`

BSW-SCHEDULE-EVENT

`BswSchedulerNamePrefix`

BSW-SCHEDULER-NAME-PREFIX

`BswServiceDependencyIdent`

BSW-SERVICE-DEPENDENCY-IDENT

`BswSynchronousServerCallPoint`

BSW-SYNCHRONOUS-SERVER-CALL-POINT

`BswTimingEvent`

BSW-TIMING-EVENT

`BswVariableAccess`

BSW-VARIABLE-ACCESS

`Build`

BUILD

`BuildAction`

BUILD-ACTION

`BuildActionEntity`

BUILD-ACTION-ENTITY

`BuildActionEnvironment`

BUILD-ACTION-ENVIRONMENT

`BuildActionManifest`

BUILD-ACTION-MANIFEST

`BuildTypeDebug`

BUILD-TYPE-DEBUG

`BuildTypeRelease`

BUILD-TYPE-RELEASE

`BulkNvDataDescriptor`

BULK-NV-DATA-DESCRIPTOR

`BurstPatternEventTriggering`

BURST-PATTERN-EVENT-TRIGGERING

`BusMirrorChannelMapping`

BUS-MIRROR-CHANNEL-MAPPING

`BusMirrorChannelMappingCan`

BUS-MIRROR-CHANNEL-MAPPING-CAN

`BusMirrorChannelMappingFlexray`

BUS-MIRROR-CHANNEL-MAPPING-FLEXRAY

`BusMirrorChannelMappingIp`

BUS-MIRROR-CHANNEL-MAPPING-IP

`BusMirrorChannelMappingUserDefined`

BUS-MIRROR-CHANNEL-MAPPING-USER-DEFINED

`C`

C

`Ca`

CA

`Calculated`

CALCULATED

`CalibrationOffline`

CALIBRATION-OFFLINE

`CalibrationOnline`

CALIBRATION-ONLINE

`CalibrationParameterValueSet`

CALIBRATION-PARAMETER-VALUE-SET

`CalibrationVariables`

CALIBRATION-VARIABLES

`Callback`

CALLBACK

`Callout`

CALLOUT

`Calprm`

CALPRM

`Can20`

CAN-20

`CanBeTerminated`

CAN-BE-TERMINATED

`CanBeTerminatedAndRestarted`

CAN-BE-TERMINATED-AND-RESTARTED

`CanCluster`

CAN-CLUSTER

`CanCommunicationConnector`

CAN-COMMUNICATION-CONNECTOR

`CanCommunicationController`

CAN-COMMUNICATION-CONTROLLER

`CanFd`

CAN-FD

`CanFrame`

CAN-FRAME

`CanFrameTriggering`

CAN-FRAME-TRIGGERING

`CanNmCluster`

CAN-NM-CLUSTER

`CanNmNode`

CAN-NM-NODE

`CanPhysicalChannel`

CAN-PHYSICAL-CHANNEL

`CanTpAddress`

CAN-TP-ADDRESS

`CanTpChannel`

CAN-TP-CHANNEL

`CanTpConfig`

CAN-TP-CONFIG

`CanTpNode`

CAN-TP-NODE

`Cancel`

CANCEL

`Caption`

CAPTION

`CaptureAsynchronousToReporting`

CAPTURE-ASYNCHRONOUS-TO-REPORTING

`CaptureAsynchronouslyToReporting`

CAPTURE-ASYNCHRONOUSLY-TO-REPORTING

`CaptureSynchronousToReporting`

CAPTURE-SYNCHRONOUS-TO-REPORTING

`CaptureSynchronouslyToReporting`

CAPTURE-SYNCHRONOUSLY-TO-REPORTING

`Cat1`

CAT-1

`Cat2`

CAT-2

`Caution`

CAUTION

`Center`

CENTER

`ChannelA`

CHANNEL-A

`ChannelB`

CHANNEL-B

`Chapter`

CHAPTER

`CheckAtNextHalt`

CHECK-AT-NEXT-HALT

`CheckpointTransition`

CHECKPOINT-TRANSITION

`Circle`

CIRCLE

`ClassContentConditional`

CLASS-CONTENT-CONDITIONAL

`Classic`

CLASSIC

`Clear`

CLEAR

`ClearAllDtcs`

CLEAR-ALL-DTCS

`ClearDynamicallyDefineDataIdentifier`

CLEAR-DYNAMICALLY-DEFINE-DATA-IDENTIFIER

`ClientAuthenticate`

CLIENT-AUTHENTICATE

`ClientDecrypt`

CLIENT-DECRYPT

`ClientEncrypt`

CLIENT-ENCRYPT

`ClientIdDefinition`

CLIENT-ID-DEFINITION

`ClientIdDefinitionSet`

CLIENT-ID-DEFINITION-SET

`ClientMacGenerate`

CLIENT-MAC-GENERATE

`ClientMacVerify`

CLIENT-MAC-VERIFY

`ClientServerInterface`

CLIENT-SERVER-INTERFACE

`ClientServerInterfaceMapping`

CLIENT-SERVER-INTERFACE-MAPPING

`ClientServerInterfaceToBswModuleEntryBlueprintMapping`

CLIENT-SERVER-INTERFACE-TO-BSW-MODULE-ENTRY-BLUEPRINT-MAPPING

`ClientServerOperation`

CLIENT-SERVER-OPERATION

`ClientVerify`

CLIENT-VERIFY

`Closed`

CLOSED

`Co`

CO

`Code`

CODE

`CodeGenerationTime`

CODE-GENERATION-TIME

`Codegeneration`

CODEGENERATION

`Coldstart`

COLDSTART

`CollectableElement`

COLLECTABLE-ELEMENT

`Collection`

COLLECTION

`ComAxis`

COM-AXIS

`ComCertificateToCryptoCertificateMapping`

COM-CERTIFICATE-TO-CRYPTO-CERTIFICATE-MAPPING

`ComEventGrant`

COM-EVENT-GRANT

`ComEventGrantDesign`

COM-EVENT-GRANT-DESIGN

`ComFieldGrant`

COM-FIELD-GRANT

`ComFieldGrantDesign`

COM-FIELD-GRANT-DESIGN

`ComFindServiceGrant`

COM-FIND-SERVICE-GRANT

`ComFindServiceGrantDesign`

COM-FIND-SERVICE-GRANT-DESIGN

`ComGrant`

COM-GRANT

`ComGrantDesign`

COM-GRANT-DESIGN

`ComKeyToCryptoKeySlotMapping`

COM-KEY-TO-CRYPTO-KEY-SLOT-MAPPING

`ComManagementMapping`

COM-MANAGEMENT-MAPPING

`ComManager`

COM-MANAGER

`ComMethodGrant`

COM-METHOD-GRANT

`ComMethodGrantDesign`

COM-METHOD-GRANT-DESIGN

`ComMgrUserNeeds`

COM-MGR-USER-NEEDS

`ComOfferServiceGrant`

COM-OFFER-SERVICE-GRANT

`ComOfferServiceGrantDesign`

COM-OFFER-SERVICE-GRANT-DESIGN

`ComSecOcToCryptoKeySlotMapping`

COM-SEC-OC-TO-CRYPTO-KEY-SLOT-MAPPING

`ComTriggerGrantDesign`

COM-TRIGGER-GRANT-DESIGN

`CommConnectorPort`

COMM-CONNECTOR-PORT

`CommandLineLongForm`

COMMAND-LINE-LONG-FORM

`CommandLineShortForm`

COMMAND-LINE-SHORT-FORM

`CommandLineSimpleForm`

COMMAND-LINE-SIMPLE-FORM

`Common`

COMMON

`CommunicationCluster`

COMMUNICATION-CLUSTER

`CommunicationConnector`

COMMUNICATION-CONNECTOR

`CommunicationController`

COMMUNICATION-CONTROLLER

`CommunicationInterEcu`

COMMUNICATION-INTER-ECU

`CommunicationIntraPartition`

COMMUNICATION-INTRA-PARTITION

`Compile`

COMPILE

`Compiler`

COMPILER

`ComplexDeviceDriverSwComponentType`

COMPLEX-DEVICE-DRIVER-SW-COMPONENT-TYPE

`CompositeInterface`

COMPOSITE-INTERFACE

`CompositionPPortToExecutablePPortMapping`

COMPOSITION-P-PORT-TO-EXECUTABLE-P-PORT-MAPPING

`CompositionPortToExecutablePortMapping`

COMPOSITION-PORT-TO-EXECUTABLE-PORT-MAPPING

`CompositionRPortToExecutableRPortMapping`

COMPOSITION-R-PORT-TO-EXECUTABLE-R-PORT-MAPPING

`CompositionSwComponentType`

COMPOSITION-SW-COMPONENT-TYPE

`CompuMethod`

COMPU-METHOD

`Comaxis`

COM_AXIS

`Concrete`

CONCRETE

`ConcreteClassTailoring`

CONCRETE-CLASS-TAILORING

`ConcretePatternEventTriggering`

CONCRETE-PATTERN-EVENT-TRIGGERING

`Conditional`

CONDITIONAL

`ConfigData`

CONFIG-DATA

`Configured`

CONFIGURED

`Confirmed`

CONFIRMED

`ConfirmedDtcBit`

CONFIRMED-DTC-BIT

`Connect`

CONNECT

`ConsistencyNeeds`

CONSISTENCY-NEEDS

`ConsistencyNeedsBlueprintSet`

CONSISTENCY-NEEDS-BLUEPRINT-SET

`Console`

CONSOLE

`Const`

CONST

`ConstantSpecification`

CONSTANT-SPECIFICATION

`ConstantSpecificationMappingSet`

CONSTANT-SPECIFICATION-MAPPING-SET

`ConstraintTailoring`

CONSTRAINT-TAILORING

`ConsumedEventGroup`

CONSUMED-EVENT-GROUP

`ConsumedProvidedServiceInstanceGroup`

CONSUMED-PROVIDED-SERVICE-INSTANCE-GROUP

`ConsumedServiceInstance`

CONSUMED-SERVICE-INSTANCE

`Consumer`

CONSUMER

`ContainerIPdu`

CONTAINER-I-PDU

`ContinueAtItPosition`

CONTINUE-AT-IT-POSITION

`ContinuousOnMode`

CONTINUOUS-ON-MODE

`CouplingElement`

COUPLING-ELEMENT

`CouplingPort`

COUPLING-PORT

`CouplingPortFifo`

COUPLING-PORT-FIFO

`CouplingPortScheduler`

COUPLING-PORT-SCHEDULER

`CouplingPortShaper`

COUPLING-PORT-SHAPER

`CouplingPortStructuralElement`

COUPLING-PORT-STRUCTURAL-ELEMENT

`CouplingPortTrafficClassAssignment`

COUPLING-PORT-TRAFFIC-CLASS-ASSIGNMENT

`Cp`

CP

`CpSoftwareCluster`

CP-SOFTWARE-CLUSTER

`CpSoftwareClusterBinaryManifestDescriptor`

CP-SOFTWARE-CLUSTER-BINARY-MANIFEST-DESCRIPTOR

`CpSoftwareClusterCommunicationResource`

CP-SOFTWARE-CLUSTER-COMMUNICATION-RESOURCE

`CpSoftwareClusterMappingSet`

CP-SOFTWARE-CLUSTER-MAPPING-SET

`CpSoftwareClusterResource`

CP-SOFTWARE-CLUSTER-RESOURCE

`CpSoftwareClusterResourcePool`

CP-SOFTWARE-CLUSTER-RESOURCE-POOL

`CpSoftwareClusterResourceToApplicationPartitionMapping`

CP-SOFTWARE-CLUSTER-RESOURCE-TO-APPLICATION-PARTITION-MAPPING

`CpSoftwareClusterServiceResource`

CP-SOFTWARE-CLUSTER-SERVICE-RESOURCE

`CpSoftwareClusterToEcuInstanceMapping`

CP-SOFTWARE-CLUSTER-TO-ECU-INSTANCE-MAPPING

`CpSoftwareClusterToResourceMapping`

CP-SOFTWARE-CLUSTER-TO-RESOURCE-MAPPING

`CpSwClusterResourceToDiagDataElemMapping`

CP-SW-CLUSTER-RESOURCE-TO-DIAG-DATA-ELEM-MAPPING

`CpSwClusterResourceToDiagFunctionIdMapping`

CP-SW-CLUSTER-RESOURCE-TO-DIAG-FUNCTION-ID-MAPPING

`CpSwClusterToDiagEventMapping`

CP-SW-CLUSTER-TO-DIAG-EVENT-MAPPING

`CpSwClusterToDiagRoutineSubfunctionMapping`

CP-SW-CLUSTER-TO-DIAG-ROUTINE-SUBFUNCTION-MAPPING

`Cpp`

CPP

`CppImplementationDataType`

CPP-IMPLEMENTATION-DATA-TYPE

`CppImplementationDataTypeContextTarget`

CPP-IMPLEMENTATION-DATA-TYPE-CONTEXT-TARGET

`CppImplementationDataTypeElement`

CPP-IMPLEMENTATION-DATA-TYPE-ELEMENT

`CrcIgnored`

CRC-IGNORED

`CrcNotSupported`

CRC-NOT-SUPPORTED

`CrcNotValidated`

CRC-NOT-VALIDATED

`CrcOptional`

CRC-OPTIONAL

`CrcSupported`

CRC-SUPPORTED

`CrcValidated`

CRC-VALIDATED

`CryptoCertificate`

CRYPTO-CERTIFICATE

`CryptoCertificateInterface`

CRYPTO-CERTIFICATE-INTERFACE

`CryptoCertificateKeySlotNeeds`

CRYPTO-CERTIFICATE-KEY-SLOT-NEEDS

`CryptoCertificateToPortPrototypeMapping`

CRYPTO-CERTIFICATE-TO-PORT-PROTOTYPE-MAPPING

`CryptoDriver`

CRYPTO-DRIVER

`CryptoEllipticCurveProps`

CRYPTO-ELLIPTIC-CURVE-PROPS

`CryptoInterface`

CRYPTO-INTERFACE

`CryptoJob`

CRYPTO-JOB

`CryptoKeyManagement`

CRYPTO-KEY-MANAGEMENT

`CryptoKeyManagementNeeds`

CRYPTO-KEY-MANAGEMENT-NEEDS

`CryptoKeySlot`

CRYPTO-KEY-SLOT

`CryptoKeySlotInterface`

CRYPTO-KEY-SLOT-INTERFACE

`CryptoKeySlotToPortPrototypeMapping`

CRYPTO-KEY-SLOT-TO-PORT-PROTOTYPE-MAPPING

`CryptoModuleInstantiation`

CRYPTO-MODULE-INSTANTIATION

`CryptoNeed`

CRYPTO-NEED

`CryptoNeedToCryptoJobMapping`

CRYPTO-NEED-TO-CRYPTO-JOB-MAPPING

`CryptoNeedToPortPrototypeMapping`

CRYPTO-NEED-TO-PORT-PROTOTYPE-MAPPING

`CryptoNeeds`

CRYPTO-NEEDS

`CryptoPrimitive`

CRYPTO-PRIMITIVE

`CryptoProvider`

CRYPTO-PROVIDER

`CryptoProviderInterface`

CRYPTO-PROVIDER-INTERFACE

`CryptoProviderToPortPrototypeMapping`

CRYPTO-PROVIDER-TO-PORT-PROTOTYPE-MAPPING

`CryptoServiceCertificate`

CRYPTO-SERVICE-CERTIFICATE

`CryptoServiceJobNeeds`

CRYPTO-SERVICE-JOB-NEEDS

`CryptoServiceKey`

CRYPTO-SERVICE-KEY

`CryptoServiceManager`

CRYPTO-SERVICE-MANAGER

`CryptoServiceMapping`

CRYPTO-SERVICE-MAPPING

`CryptoServiceNeeds`

CRYPTO-SERVICE-NEEDS

`CryptoServicePrimitive`

CRYPTO-SERVICE-PRIMITIVE

`CryptoServiceQueue`

CRYPTO-SERVICE-QUEUE

`CryptoSignatureScheme`

CRYPTO-SIGNATURE-SCHEME

`CryptoTrustMasterInterface`

CRYPTO-TRUST-MASTER-INTERFACE

`Cs`

CS

`CurveAxis`

CURVE-AXIS

`Curveaxis`

CURVE_AXIS

`Custom`

CUSTOM

`CustomCppImplementationDataType`

CUSTOM-CPP-IMPLEMENTATION-DATA-TYPE

`Cvc`

CVC

`Cy`

CY

`CycleRepetition1`

CYCLE-REPETITION-1

`CycleRepetition10`

CYCLE-REPETITION-10

`CycleRepetition16`

CYCLE-REPETITION-16

`CycleRepetition2`

CYCLE-REPETITION-2

`CycleRepetition20`

CYCLE-REPETITION-20

`CycleRepetition32`

CYCLE-REPETITION-32

`CycleRepetition4`

CYCLE-REPETITION-4

`CycleRepetition40`

CYCLE-REPETITION-40

`CycleRepetition5`

CYCLE-REPETITION-5

`CycleRepetition50`

CYCLE-REPETITION-50

`CycleRepetition64`

CYCLE-REPETITION-64

`CycleRepetition8`

CYCLE-REPETITION-8

`Cyclic`

CYCLIC

`CyclicAndOnChange`

CYCLIC-AND-ON-CHANGE

`Da`

DA

`DataConstr`

DATA-CONSTR

`DataExchangePoint`

DATA-EXCHANGE-POINT

`DataFormatElementReference`

DATA-FORMAT-ELEMENT-REFERENCE

`DataFormatElementScope`

DATA-FORMAT-ELEMENT-SCOPE

`DataInterface`

DATA-INTERFACE

`DataPrototype`

DATA-PROTOTYPE

`DataPrototypeGroup`

DATA-PROTOTYPE-GROUP

`DataReceiveErrorEvent`

DATA-RECEIVE-ERROR-EVENT

`DataReceivedEvent`

DATA-RECEIVED-EVENT

`DataSendCompletedEvent`

DATA-SEND-COMPLETED-EVENT

`DataTransformation`

DATA-TRANSFORMATION

`DataTransformationSet`

DATA-TRANSFORMATION-SET

`DataTypeMappingSet`

DATA-TYPE-MAPPING-SET

`DataWriteCompletedEvent`

DATA-WRITE-COMPLETED-EVENT

`DcmIPdu`

DCM-I-PDU

`DdsDomainRange`

DDS-DOMAIN-RANGE

`DdsEventDeployment`

DDS-EVENT-DEPLOYMENT

`DdsFieldDeployment`

DDS-FIELD-DEPLOYMENT

`DdsMethodDeployment`

DDS-METHOD-DEPLOYMENT

`DdsProvidedServiceInstance`

DDS-PROVIDED-SERVICE-INSTANCE

`DdsRequiredServiceInstance`

DDS-REQUIRED-SERVICE-INSTANCE

`DdsRpcServiceDeployment`

DDS-RPC-SERVICE-DEPLOYMENT

`DdsSecureComProps`

DDS-SECURE-COM-PROPS

`DdsSecureGovernance`

DDS-SECURE-GOVERNANCE

`DdsServiceInstanceToMachineMapping`

DDS-SERVICE-INSTANCE-TO-MACHINE-MAPPING

`DdsServiceInterfaceDeployment`

DDS-SERVICE-INTERFACE-DEPLOYMENT

`DdsTopicAccessRule`

DDS-TOPIC-ACCESS-RULE

`De`

DE

`DeadlineSupervision`

DEADLINE-SUPERVISION

`DebounceData`

DEBOUNCE-DATA

`Debug`

DEBUG

`Decreasing`

DECREASING

`Dedicated`

DEDICATED

`DefItem`

DEF-ITEM

`Default`

DEFAULT

`DefaultErrorTracer`

DEFAULT-ERROR-TRACER

`DefaultIfRevisionUpdate`

DEFAULT-IF-REVISION-UPDATE

`DefaultIfUndefined`

DEFAULT-IF-UNDEFINED

`DefaultMode`

DEFAULT-MODE

`DefaultTraceStateDisabled`

DEFAULT-TRACE-STATE-DISABLED

`DefaultTraceStateEnabled`

DEFAULT-TRACE-STATE-ENABLED

`DefaultTrigger`

DEFAULT-TRIGGER

`Deferred`

DEFERRED

`DeficitRoundRobin`

DEFICIT-ROUND-ROBIN

`DefineByIdentifier`

DEFINE-BY-IDENTIFIER

`DefineByMemoryAddress`

DEFINE-BY-MEMORY-ADDRESS

`Deflate`

DEFLATE

`DelegationSwConnector`

DELEGATION-SW-CONNECTOR

`Delete`

DELETE

`Dependant`

DEPENDANT

`DependencyOnArtifact`

DEPENDENCY-ON-ARTIFACT

`DerivedFrom`

DERIVED-FROM

`Descendant`

DESCENDANT

`Deselected`

DESELECTED

`Detailed`

DETAILED

`DetailedBypassingFilters`

DETAILED-BYPASSING-FILTERS

`DeterministicClient`

DETERMINISTIC-CLIENT

`DeterministicClientResourceNeeds`

DETERMINISTIC-CLIENT-RESOURCE-NEEDS

`Development`

DEVELOPMENT

`DevelopmentError`

DEVELOPMENT-ERROR

`DevelopmentErrorTracer`

DEVELOPMENT-ERROR-TRACER

`Dhcpv4`

DHCPV-4

`Dhcpv6`

DHCPV-6

`DiagEventDebounceAlgorithm`

DIAG-EVENT-DEBOUNCE-ALGORITHM

`DiagEventDebounceCounterBased`

DIAG-EVENT-DEBOUNCE-COUNTER-BASED

`DiagEventDebounceMonitorInternal`

DIAG-EVENT-DEBOUNCE-MONITOR-INTERNAL

`DiagEventDebounceTimeBased`

DIAG-EVENT-DEBOUNCE-TIME-BASED

`DiagRequest`

DIAG-REQUEST

`DiagResponse`

DIAG-RESPONSE

`DiagnosticAbstractAliasEvent`

DIAGNOSTIC-ABSTRACT-ALIAS-EVENT

`DiagnosticAbstractDataIdentifier`

DIAGNOSTIC-ABSTRACT-DATA-IDENTIFIER

`DiagnosticAbstractDataIdentifierInterface`

DIAGNOSTIC-ABSTRACT-DATA-IDENTIFIER-INTERFACE

`DiagnosticAbstractRoutineInterface`

DIAGNOSTIC-ABSTRACT-ROUTINE-INTERFACE

`DiagnosticAccessPermission`

DIAGNOSTIC-ACCESS-PERMISSION

`DiagnosticAging`

DIAGNOSTIC-AGING

`DiagnosticAuthRole`

DIAGNOSTIC-AUTH-ROLE

`DiagnosticAuthentication`

DIAGNOSTIC-AUTHENTICATION

`DiagnosticAuthenticationClass`

DIAGNOSTIC-AUTHENTICATION-CLASS

`DiagnosticAuthenticationConfiguration`

DIAGNOSTIC-AUTHENTICATION-CONFIGURATION

`DiagnosticAuthenticationInterface`

DIAGNOSTIC-AUTHENTICATION-INTERFACE

`DiagnosticAuthenticationPortMapping`

DIAGNOSTIC-AUTHENTICATION-PORT-MAPPING

`DiagnosticCapabilityElement`

DIAGNOSTIC-CAPABILITY-ELEMENT

`DiagnosticClearCondition`

DIAGNOSTIC-CLEAR-CONDITION

`DiagnosticClearConditionGroup`

DIAGNOSTIC-CLEAR-CONDITION-GROUP

`DiagnosticClearConditionNeeds`

DIAGNOSTIC-CLEAR-CONDITION-NEEDS

`DiagnosticClearConditionPortMapping`

DIAGNOSTIC-CLEAR-CONDITION-PORT-MAPPING

`DiagnosticClearDiagnosticInformation`

DIAGNOSTIC-CLEAR-DIAGNOSTIC-INFORMATION

`DiagnosticClearDiagnosticInformationClass`

DIAGNOSTIC-CLEAR-DIAGNOSTIC-INFORMATION-CLASS

`DiagnosticClearResetEmissionRelatedInfo`

DIAGNOSTIC-CLEAR-RESET-EMISSION-RELATED-INFO

`DiagnosticClearResetEmissionRelatedInfoClass`

DIAGNOSTIC-CLEAR-RESET-EMISSION-RELATED-INFO-CLASS

`DiagnosticComControl`

DIAGNOSTIC-COM-CONTROL

`DiagnosticComControlClass`

DIAGNOSTIC-COM-CONTROL-CLASS

`DiagnosticComControlInterface`

DIAGNOSTIC-COM-CONTROL-INTERFACE

`DiagnosticCommonElement`

DIAGNOSTIC-COMMON-ELEMENT

`DiagnosticCommunicationManager`

DIAGNOSTIC-COMMUNICATION-MANAGER

`DiagnosticCommunicationManagerNeeds`

DIAGNOSTIC-COMMUNICATION-MANAGER-NEEDS

`DiagnosticComponentNeeds`

DIAGNOSTIC-COMPONENT-NEEDS

`DiagnosticCondition`

DIAGNOSTIC-CONDITION

`DiagnosticConditionGroup`

DIAGNOSTIC-CONDITION-GROUP

`DiagnosticConditionInterface`

DIAGNOSTIC-CONDITION-INTERFACE

`DiagnosticConnectedIndicator`

DIAGNOSTIC-CONNECTED-INDICATOR

`DiagnosticConnection`

DIAGNOSTIC-CONNECTION

`DiagnosticContributionSet`

DIAGNOSTIC-CONTRIBUTION-SET

`DiagnosticControlDtcSetting`

DIAGNOSTIC-CONTROL-DTC-SETTING

`DiagnosticControlDtcSettingClass`

DIAGNOSTIC-CONTROL-DTC-SETTING-CLASS

`DiagnosticControlNeeds`

DIAGNOSTIC-CONTROL-NEEDS

`DiagnosticCustomServiceClass`

DIAGNOSTIC-CUSTOM-SERVICE-CLASS

`DiagnosticCustomServiceInstance`

DIAGNOSTIC-CUSTOM-SERVICE-INSTANCE

`DiagnosticDataByIdentifier`

DIAGNOSTIC-DATA-BY-IDENTIFIER

`DiagnosticDataElement`

DIAGNOSTIC-DATA-ELEMENT

`DiagnosticDataElementInterface`

DIAGNOSTIC-DATA-ELEMENT-INTERFACE

`DiagnosticDataIdentifier`

DIAGNOSTIC-DATA-IDENTIFIER

`DiagnosticDataIdentifierGenericInterface`

DIAGNOSTIC-DATA-IDENTIFIER-GENERIC-INTERFACE

`DiagnosticDataIdentifierInterface`

DIAGNOSTIC-DATA-IDENTIFIER-INTERFACE

`DiagnosticDataIdentifierSet`

DIAGNOSTIC-DATA-IDENTIFIER-SET

`DiagnosticDataPortMapping`

DIAGNOSTIC-DATA-PORT-MAPPING

`DiagnosticDataTransfer`

DIAGNOSTIC-DATA-TRANSFER

`DiagnosticDataTransferClass`

DIAGNOSTIC-DATA-TRANSFER-CLASS

`DiagnosticDeAuthentication`

DIAGNOSTIC-DE-AUTHENTICATION

`DiagnosticDebounceAlgorithmProps`

DIAGNOSTIC-DEBOUNCE-ALGORITHM-PROPS

`DiagnosticDemProvidedDataMapping`

DIAGNOSTIC-DEM-PROVIDED-DATA-MAPPING

`DiagnosticDoIpActivationLineInterface`

DIAGNOSTIC-DO-IP-ACTIVATION-LINE-INTERFACE

`DiagnosticDoIpGroupIdentificationInterface`

DIAGNOSTIC-DO-IP-GROUP-IDENTIFICATION-INTERFACE

`DiagnosticDoIpPowerModeInterface`

DIAGNOSTIC-DO-IP-POWER-MODE-INTERFACE

`DiagnosticDoIpTriggerVehicleAnnouncementInterface`

DIAGNOSTIC-DO-IP-TRIGGER-VEHICLE-ANNOUNCEMENT-INTERFACE

`DiagnosticDownloadInterface`

DIAGNOSTIC-DOWNLOAD-INTERFACE

`DiagnosticDtcInformationInterface`

DIAGNOSTIC-DTC-INFORMATION-INTERFACE

`DiagnosticDynamicDataIdentifier`

DIAGNOSTIC-DYNAMIC-DATA-IDENTIFIER

`DiagnosticDynamicallyDefineDataIdentifier`

DIAGNOSTIC-DYNAMICALLY-DEFINE-DATA-IDENTIFIER

`DiagnosticDynamicallyDefineDataIdentifierClass`

DIAGNOSTIC-DYNAMICALLY-DEFINE-DATA-IDENTIFIER-CLASS

`DiagnosticEcuInstanceProps`

DIAGNOSTIC-ECU-INSTANCE-PROPS

`DiagnosticEcuReset`

DIAGNOSTIC-ECU-RESET

`DiagnosticEcuResetClass`

DIAGNOSTIC-ECU-RESET-CLASS

`DiagnosticEcuResetInterface`

DIAGNOSTIC-ECU-RESET-INTERFACE

`DiagnosticEnableCondition`

DIAGNOSTIC-ENABLE-CONDITION

`DiagnosticEnableConditionGroup`

DIAGNOSTIC-ENABLE-CONDITION-GROUP

`DiagnosticEnableConditionNeeds`

DIAGNOSTIC-ENABLE-CONDITION-NEEDS

`DiagnosticEnableConditionPortMapping`

DIAGNOSTIC-ENABLE-CONDITION-PORT-MAPPING

`DiagnosticEnvBswModeElement`

DIAGNOSTIC-ENV-BSW-MODE-ELEMENT

`DiagnosticEnvModeElement`

DIAGNOSTIC-ENV-MODE-ELEMENT

`DiagnosticEnvSwcModeElement`

DIAGNOSTIC-ENV-SWC-MODE-ELEMENT

`DiagnosticEnvironmentalCondition`

DIAGNOSTIC-ENVIRONMENTAL-CONDITION

`DiagnosticEvent`

DIAGNOSTIC-EVENT

`DiagnosticEventInfoNeeds`

DIAGNOSTIC-EVENT-INFO-NEEDS

`DiagnosticEventInterface`

DIAGNOSTIC-EVENT-INTERFACE

`DiagnosticEventManager`

DIAGNOSTIC-EVENT-MANAGER

`DiagnosticEventManagerNeeds`

DIAGNOSTIC-EVENT-MANAGER-NEEDS

`DiagnosticEventNeeds`

DIAGNOSTIC-EVENT-NEEDS

`DiagnosticEventPortMapping`

DIAGNOSTIC-EVENT-PORT-MAPPING

`DiagnosticEventToDebounceAlgorithmMapping`

DIAGNOSTIC-EVENT-TO-DEBOUNCE-ALGORITHM-MAPPING

`DiagnosticEventToEnableConditionGroupMapping`

DIAGNOSTIC-EVENT-TO-ENABLE-CONDITION-GROUP-MAPPING

`DiagnosticEventToOperationCycleMapping`

DIAGNOSTIC-EVENT-TO-OPERATION-CYCLE-MAPPING

`DiagnosticEventToSecurityEventMapping`

DIAGNOSTIC-EVENT-TO-SECURITY-EVENT-MAPPING

`DiagnosticEventToStorageConditionGroupMapping`

DIAGNOSTIC-EVENT-TO-STORAGE-CONDITION-GROUP-MAPPING

`DiagnosticEventToTroubleCodeJ1939Mapping`

DIAGNOSTIC-EVENT-TO-TROUBLE-CODE-J-1939-MAPPING

`DiagnosticEventToTroubleCodeUdsMapping`

DIAGNOSTIC-EVENT-TO-TROUBLE-CODE-UDS-MAPPING

`DiagnosticExtendedDataRecord`

DIAGNOSTIC-EXTENDED-DATA-RECORD

`DiagnosticExternalAuthenticationInterface`

DIAGNOSTIC-EXTERNAL-AUTHENTICATION-INTERFACE

`DiagnosticExternalAuthenticationPortMapping`

DIAGNOSTIC-EXTERNAL-AUTHENTICATION-PORT-MAPPING

`DiagnosticFimAliasEvent`

DIAGNOSTIC-FIM-ALIAS-EVENT

`DiagnosticFimAliasEventGroup`

DIAGNOSTIC-FIM-ALIAS-EVENT-GROUP

`DiagnosticFimAliasEventGroupMapping`

DIAGNOSTIC-FIM-ALIAS-EVENT-GROUP-MAPPING

`DiagnosticFimAliasEventMapping`

DIAGNOSTIC-FIM-ALIAS-EVENT-MAPPING

`DiagnosticFimEventGroup`

DIAGNOSTIC-FIM-EVENT-GROUP

`DiagnosticFimFunctionMapping`

DIAGNOSTIC-FIM-FUNCTION-MAPPING

`DiagnosticFreezeFrame`

DIAGNOSTIC-FREEZE-FRAME

`DiagnosticFunctionIdentifier`

DIAGNOSTIC-FUNCTION-IDENTIFIER

`DiagnosticFunctionIdentifierInhibit`

DIAGNOSTIC-FUNCTION-IDENTIFIER-INHIBIT

`DiagnosticFunctionInhibitSource`

DIAGNOSTIC-FUNCTION-INHIBIT-SOURCE

`DiagnosticGenericUdsInterface`

DIAGNOSTIC-GENERIC-UDS-INTERFACE

`DiagnosticGenericUdsNeeds`

DIAGNOSTIC-GENERIC-UDS-NEEDS

`DiagnosticGenericUdsPortMapping`

DIAGNOSTIC-GENERIC-UDS-PORT-MAPPING

`DiagnosticIndicator`

DIAGNOSTIC-INDICATOR

`DiagnosticIndicatorInterface`

DIAGNOSTIC-INDICATOR-INTERFACE

`DiagnosticIndicatorNeeds`

DIAGNOSTIC-INDICATOR-NEEDS

`DiagnosticIndicatorPortMapping`

DIAGNOSTIC-INDICATOR-PORT-MAPPING

`DiagnosticInfoType`

DIAGNOSTIC-INFO-TYPE

`DiagnosticInhibitSourceEventMapping`

DIAGNOSTIC-INHIBIT-SOURCE-EVENT-MAPPING

`DiagnosticIoControl`

DIAGNOSTIC-IO-CONTROL

`DiagnosticIoControlClass`

DIAGNOSTIC-IO-CONTROL-CLASS

`DiagnosticIoControlNeeds`

DIAGNOSTIC-IO-CONTROL-NEEDS

`DiagnosticIumpr`

DIAGNOSTIC-IUMPR

`DiagnosticIumprDenominatorGroup`

DIAGNOSTIC-IUMPR-DENOMINATOR-GROUP

`DiagnosticIumprGroup`

DIAGNOSTIC-IUMPR-GROUP

`DiagnosticIumprToFunctionIdentifierMapping`

DIAGNOSTIC-IUMPR-TO-FUNCTION-IDENTIFIER-MAPPING

`DiagnosticJ1939ExpandedFreezeFrame`

DIAGNOSTIC-J-1939-EXPANDED-FREEZE-FRAME

`DiagnosticJ1939FreezeFrame`

DIAGNOSTIC-J-1939-FREEZE-FRAME

`DiagnosticJ1939Node`

DIAGNOSTIC-J-1939-NODE

`DiagnosticJ1939Spn`

DIAGNOSTIC-J-1939-SPN

`DiagnosticJ1939SpnMapping`

DIAGNOSTIC-J-1939-SPN-MAPPING

`DiagnosticJ1939SwMapping`

DIAGNOSTIC-J-1939-SW-MAPPING

`DiagnosticLogAndTrace`

DIAGNOSTIC-LOG-AND-TRACE

`DiagnosticMapping`

DIAGNOSTIC-MAPPING

`DiagnosticMasterToSlaveEventMapping`

DIAGNOSTIC-MASTER-TO-SLAVE-EVENT-MAPPING

`DiagnosticMasterToSlaveEventMappingSet`

DIAGNOSTIC-MASTER-TO-SLAVE-EVENT-MAPPING-SET

`DiagnosticMeasurementIdentifier`

DIAGNOSTIC-MEASUREMENT-IDENTIFIER

`DiagnosticMemoryAddressableRangeAccess`

DIAGNOSTIC-MEMORY-ADDRESSABLE-RANGE-ACCESS

`DiagnosticMemoryByAddress`

DIAGNOSTIC-MEMORY-BY-ADDRESS

`DiagnosticMemoryDestination`

DIAGNOSTIC-MEMORY-DESTINATION

`DiagnosticMemoryDestinationMirror`

DIAGNOSTIC-MEMORY-DESTINATION-MIRROR

`DiagnosticMemoryDestinationPortMapping`

DIAGNOSTIC-MEMORY-DESTINATION-PORT-MAPPING

`DiagnosticMemoryDestinationPrimary`

DIAGNOSTIC-MEMORY-DESTINATION-PRIMARY

`DiagnosticMemoryDestinationUserDefined`

DIAGNOSTIC-MEMORY-DESTINATION-USER-DEFINED

`DiagnosticMemoryIdentifier`

DIAGNOSTIC-MEMORY-IDENTIFIER

`DiagnosticMonitorInterface`

DIAGNOSTIC-MONITOR-INTERFACE

`DiagnosticMonitorPortMapping`

DIAGNOSTIC-MONITOR-PORT-MAPPING

`DiagnosticOperationCycle`

DIAGNOSTIC-OPERATION-CYCLE

`DiagnosticOperationCycleInterface`

DIAGNOSTIC-OPERATION-CYCLE-INTERFACE

`DiagnosticOperationCycleNeeds`

DIAGNOSTIC-OPERATION-CYCLE-NEEDS

`DiagnosticOperationCyclePortMapping`

DIAGNOSTIC-OPERATION-CYCLE-PORT-MAPPING

`DiagnosticParameterIdentifier`

DIAGNOSTIC-PARAMETER-IDENTIFIER

`DiagnosticPortInterface`

DIAGNOSTIC-PORT-INTERFACE

`DiagnosticPowertrainFreezeFrame`

DIAGNOSTIC-POWERTRAIN-FREEZE-FRAME

`DiagnosticProofOfOwnership`

DIAGNOSTIC-PROOF-OF-OWNERSHIP

`DiagnosticProtocol`

DIAGNOSTIC-PROTOCOL

`DiagnosticProvidedDataMapping`

DIAGNOSTIC-PROVIDED-DATA-MAPPING

`DiagnosticReadDataByIdentifier`

DIAGNOSTIC-READ-DATA-BY-IDENTIFIER

`DiagnosticReadDataByIdentifierClass`

DIAGNOSTIC-READ-DATA-BY-IDENTIFIER-CLASS

`DiagnosticReadDataByPeriodicId`

DIAGNOSTIC-READ-DATA-BY-PERIODIC-ID

`DiagnosticReadDataByPeriodicIdClass`

DIAGNOSTIC-READ-DATA-BY-PERIODIC-ID-CLASS

`DiagnosticReadDtcInformation`

DIAGNOSTIC-READ-DTC-INFORMATION

`DiagnosticReadDtcInformationClass`

DIAGNOSTIC-READ-DTC-INFORMATION-CLASS

`DiagnosticReadMemoryByAddress`

DIAGNOSTIC-READ-MEMORY-BY-ADDRESS

`DiagnosticReadMemoryByAddressClass`

DIAGNOSTIC-READ-MEMORY-BY-ADDRESS-CLASS

`DiagnosticReadScalingDataByIdentifier`

DIAGNOSTIC-READ-SCALING-DATA-BY-IDENTIFIER

`DiagnosticReadScalingDataByIdentifierClass`

DIAGNOSTIC-READ-SCALING-DATA-BY-IDENTIFIER-CLASS

`DiagnosticRequestControlOfOnBoardDevice`

DIAGNOSTIC-REQUEST-CONTROL-OF-ON-BOARD-DEVICE

`DiagnosticRequestControlOfOnBoardDeviceClass`

DIAGNOSTIC-REQUEST-CONTROL-OF-ON-BOARD-DEVICE-CLASS

`DiagnosticRequestCurrentPowertrainData`

DIAGNOSTIC-REQUEST-CURRENT-POWERTRAIN-DATA

`DiagnosticRequestCurrentPowertrainDataClass`

DIAGNOSTIC-REQUEST-CURRENT-POWERTRAIN-DATA-CLASS

`DiagnosticRequestDownload`

DIAGNOSTIC-REQUEST-DOWNLOAD

`DiagnosticRequestDownloadClass`

DIAGNOSTIC-REQUEST-DOWNLOAD-CLASS

`DiagnosticRequestEmissionRelatedDtc`

DIAGNOSTIC-REQUEST-EMISSION-RELATED-DTC

`DiagnosticRequestEmissionRelatedDtcClass`

DIAGNOSTIC-REQUEST-EMISSION-RELATED-DTC-CLASS

`DiagnosticRequestEmissionRelatedDtcPermanentStatus`

DIAGNOSTIC-REQUEST-EMISSION-RELATED-DTC-PERMANENT-STATUS

`DiagnosticRequestEmissionRelatedDtcPermanentStatusClass`

DIAGNOSTIC-REQUEST-EMISSION-RELATED-DTC-PERMANENT-STATUS-CLASS

`DiagnosticRequestFileTransfer`

DIAGNOSTIC-REQUEST-FILE-TRANSFER

`DiagnosticRequestFileTransferClass`

DIAGNOSTIC-REQUEST-FILE-TRANSFER-CLASS

`DiagnosticRequestFileTransferNeeds`

DIAGNOSTIC-REQUEST-FILE-TRANSFER-NEEDS

`DiagnosticRequestOnBoardMonitoringTestResults`

DIAGNOSTIC-REQUEST-ON-BOARD-MONITORING-TEST-RESULTS

`DiagnosticRequestOnBoardMonitoringTestResultsClass`

DIAGNOSTIC-REQUEST-ON-BOARD-MONITORING-TEST-RESULTS-CLASS

`DiagnosticRequestPowertrainFreezeFrameData`

DIAGNOSTIC-REQUEST-POWERTRAIN-FREEZE-FRAME-DATA

`DiagnosticRequestPowertrainFreezeFrameDataClass`

DIAGNOSTIC-REQUEST-POWERTRAIN-FREEZE-FRAME-DATA-CLASS

`DiagnosticRequestRoutineResults`

DIAGNOSTIC-REQUEST-ROUTINE-RESULTS

`DiagnosticRequestUpload`

DIAGNOSTIC-REQUEST-UPLOAD

`DiagnosticRequestUploadClass`

DIAGNOSTIC-REQUEST-UPLOAD-CLASS

`DiagnosticRequestVehicleInfo`

DIAGNOSTIC-REQUEST-VEHICLE-INFO

`DiagnosticRequestVehicleInfoClass`

DIAGNOSTIC-REQUEST-VEHICLE-INFO-CLASS

`DiagnosticResponseOnEvent`

DIAGNOSTIC-RESPONSE-ON-EVENT

`DiagnosticResponseOnEventClass`

DIAGNOSTIC-RESPONSE-ON-EVENT-CLASS

`DiagnosticResponseOnEventNeeds`

DIAGNOSTIC-RESPONSE-ON-EVENT-NEEDS

`DiagnosticRoutine`

DIAGNOSTIC-ROUTINE

`DiagnosticRoutineControl`

DIAGNOSTIC-ROUTINE-CONTROL

`DiagnosticRoutineControlClass`

DIAGNOSTIC-ROUTINE-CONTROL-CLASS

`DiagnosticRoutineGenericInterface`

DIAGNOSTIC-ROUTINE-GENERIC-INTERFACE

`DiagnosticRoutineInterface`

DIAGNOSTIC-ROUTINE-INTERFACE

`DiagnosticRoutineNeeds`

DIAGNOSTIC-ROUTINE-NEEDS

`DiagnosticRoutineSubfunction`

DIAGNOSTIC-ROUTINE-SUBFUNCTION

`DiagnosticSecurityAccess`

DIAGNOSTIC-SECURITY-ACCESS

`DiagnosticSecurityAccessClass`

DIAGNOSTIC-SECURITY-ACCESS-CLASS

`DiagnosticSecurityEventReportingModeMapping`

DIAGNOSTIC-SECURITY-EVENT-REPORTING-MODE-MAPPING

`DiagnosticSecurityLevel`

DIAGNOSTIC-SECURITY-LEVEL

`DiagnosticSecurityLevelInterface`

DIAGNOSTIC-SECURITY-LEVEL-INTERFACE

`DiagnosticSecurityLevelPortMapping`

DIAGNOSTIC-SECURITY-LEVEL-PORT-MAPPING

`DiagnosticServiceClass`

DIAGNOSTIC-SERVICE-CLASS

`DiagnosticServiceDataIdentifierMapping`

DIAGNOSTIC-SERVICE-DATA-IDENTIFIER-MAPPING

`DiagnosticServiceDataIdentifierPortMapping`

DIAGNOSTIC-SERVICE-DATA-IDENTIFIER-PORT-MAPPING

`DiagnosticServiceDataMapping`

DIAGNOSTIC-SERVICE-DATA-MAPPING

`DiagnosticServiceGenericMapping`

DIAGNOSTIC-SERVICE-GENERIC-MAPPING

`DiagnosticServiceInstance`

DIAGNOSTIC-SERVICE-INSTANCE

`DiagnosticServiceSwMapping`

DIAGNOSTIC-SERVICE-SW-MAPPING

`DiagnosticServiceTable`

DIAGNOSTIC-SERVICE-TABLE

`DiagnosticServiceValidationInterface`

DIAGNOSTIC-SERVICE-VALIDATION-INTERFACE

`DiagnosticServiceValidationMapping`

DIAGNOSTIC-SERVICE-VALIDATION-MAPPING

`DiagnosticSession`

DIAGNOSTIC-SESSION

`DiagnosticSessionControl`

DIAGNOSTIC-SESSION-CONTROL

`DiagnosticSessionControlClass`

DIAGNOSTIC-SESSION-CONTROL-CLASS

`DiagnosticSoftwareClusterProps`

DIAGNOSTIC-SOFTWARE-CLUSTER-PROPS

`DiagnosticStartRoutine`

DIAGNOSTIC-START-ROUTINE

`DiagnosticStopRoutine`

DIAGNOSTIC-STOP-ROUTINE

`DiagnosticStorageCondition`

DIAGNOSTIC-STORAGE-CONDITION

`DiagnosticStorageConditionGroup`

DIAGNOSTIC-STORAGE-CONDITION-GROUP

`DiagnosticStorageConditionNeeds`

DIAGNOSTIC-STORAGE-CONDITION-NEEDS

`DiagnosticStorageConditionPortMapping`

DIAGNOSTIC-STORAGE-CONDITION-PORT-MAPPING

`DiagnosticSwMapping`

DIAGNOSTIC-SW-MAPPING

`DiagnosticTestResult`

DIAGNOSTIC-TEST-RESULT

`DiagnosticTestRoutineIdentifier`

DIAGNOSTIC-TEST-ROUTINE-IDENTIFIER

`DiagnosticTransferExit`

DIAGNOSTIC-TRANSFER-EXIT

`DiagnosticTransferExitClass`

DIAGNOSTIC-TRANSFER-EXIT-CLASS

`DiagnosticTroubleCode`

DIAGNOSTIC-TROUBLE-CODE

`DiagnosticTroubleCodeGroup`

DIAGNOSTIC-TROUBLE-CODE-GROUP

`DiagnosticTroubleCodeJ1939`

DIAGNOSTIC-TROUBLE-CODE-J-1939

`DiagnosticTroubleCodeObd`

DIAGNOSTIC-TROUBLE-CODE-OBD

`DiagnosticTroubleCodeProps`

DIAGNOSTIC-TROUBLE-CODE-PROPS

`DiagnosticTroubleCodeUds`

DIAGNOSTIC-TROUBLE-CODE-UDS

`DiagnosticTroubleCodeUdsToClearConditionGroupMapping`

DIAGNOSTIC-TROUBLE-CODE-UDS-TO-CLEAR-CONDITION-GROUP-MAPPING

`DiagnosticTroubleCodeUdsToTroubleCodeObdMapping`

DIAGNOSTIC-TROUBLE-CODE-UDS-TO-TROUBLE-CODE-OBD-MAPPING

`DiagnosticUploadDownloadNeeds`

DIAGNOSTIC-UPLOAD-DOWNLOAD-NEEDS

`DiagnosticUploadDownloadPortMapping`

DIAGNOSTIC-UPLOAD-DOWNLOAD-PORT-MAPPING

`DiagnosticUploadInterface`

DIAGNOSTIC-UPLOAD-INTERFACE

`DiagnosticValueNeeds`

DIAGNOSTIC-VALUE-NEEDS

`DiagnosticVerifyCertificateBidirectional`

DIAGNOSTIC-VERIFY-CERTIFICATE-BIDIRECTIONAL

`DiagnosticVerifyCertificateUnidirectional`

DIAGNOSTIC-VERIFY-CERTIFICATE-UNIDIRECTIONAL

`DiagnosticWriteDataByIdentifier`

DIAGNOSTIC-WRITE-DATA-BY-IDENTIFIER

`DiagnosticWriteDataByIdentifierClass`

DIAGNOSTIC-WRITE-DATA-BY-IDENTIFIER-CLASS

`DiagnosticWriteMemoryByAddress`

DIAGNOSTIC-WRITE-MEMORY-BY-ADDRESS

`DiagnosticWriteMemoryByAddressClass`

DIAGNOSTIC-WRITE-MEMORY-BY-ADDRESS-CLASS

`DiagnosticsCommunicationSecurityNeeds`

DIAGNOSTICS-COMMUNICATION-SECURITY-NEEDS

`Disable`

DISABLE

`Dlna`

DLNA

`DltApplication`

DLT-APPLICATION

`DltApplicationToProcessMapping`

DLT-APPLICATION-TO-PROCESS-MAPPING

`DltArgument`

DLT-ARGUMENT

`DltContext`

DLT-CONTEXT

`DltEcu`

DLT-ECU

`DltLogChannel`

DLT-LOG-CHANNEL

`DltLogChannelDesign`

DLT-LOG-CHANNEL-DESIGN

`DltLogChannelDesignToProcessDesignMapping`

DLT-LOG-CHANNEL-DESIGN-TO-PROCESS-DESIGN-MAPPING

`DltLogChannelToProcessMapping`

DLT-LOG-CHANNEL-TO-PROCESS-MAPPING

`DltLogSink`

DLT-LOG-SINK

`DltLogSinkToPortPrototypeMapping`

DLT-LOG-SINK-TO-PORT-PROTOTYPE-MAPPING

`DltMessage`

DLT-MESSAGE

`DltMessageCollectionSet`

DLT-MESSAGE-COLLECTION-SET

`DltUserNeeds`

DLT-USER-NEEDS

`DoIp`

DO-IP

`DoIpActivationLineNeeds`

DO-IP-ACTIVATION-LINE-NEEDS

`DoIpGidNeeds`

DO-IP-GID-NEEDS

`DoIpGidSynchronizationNeeds`

DO-IP-GID-SYNCHRONIZATION-NEEDS

`DoIpInstantiation`

DO-IP-INSTANTIATION

`DoIpInterface`

DO-IP-INTERFACE

`DoIpLogicAddress`

DO-IP-LOGIC-ADDRESS

`DoIpLogicTargetAddressProps`

DO-IP-LOGIC-TARGET-ADDRESS-PROPS

`DoIpLogicTesterAddressProps`

DO-IP-LOGIC-TESTER-ADDRESS-PROPS

`DoIpPowerModeStatusNeeds`

DO-IP-POWER-MODE-STATUS-NEEDS

`DoIpRoutingActivation`

DO-IP-ROUTING-ACTIVATION

`DoIpRoutingActivationAuthenticationNeeds`

DO-IP-ROUTING-ACTIVATION-AUTHENTICATION-NEEDS

`DoIpRoutingActivationConfirmationNeeds`

DO-IP-ROUTING-ACTIVATION-CONFIRMATION-NEEDS

`DoIpServiceNeeds`

DO-IP-SERVICE-NEEDS

`DoIpTpConfig`

DO-IP-TP-CONFIG

`DocumentElementScope`

DOCUMENT-ELEMENT-SCOPE

`Documentation`

DOCUMENTATION

`DocumentationContext`

DOCUMENTATION-CONTEXT

`DoesNotReportExecutionState`

DOES-NOT-REPORT-EXECUTION-STATE

`DoesNotSupportBufferLocking`

DOES-NOT-SUPPORT-BUFFER-LOCKING

`DoesNotUseLogging`

DOES-NOT-USE-LOGGING

`DomainParticipantUserDataQos`

DOMAIN-PARTICIPANT-USER-DATA-QOS

`DontInvalidate`

DONT-INVALIDATE

`Drop`

DROP

`DropFrame`

DROP-FRAME

`DropUntagged`

DROP-UNTAGGED

`Dsa`

DSA

`DtcStatusChangeNotificationNeeds`

DTC-STATUS-CHANGE-NOTIFICATION-NEEDS

`DynamicPartTrigger`

DYNAMIC-PART-TRIGGER

`Dz`

DZ

`E2EProfileCompatibilityProps`

E-2-E-PROFILE-COMPATIBILITY-PROPS

`E2EProfileConfiguration`

E-2-E-PROFILE-CONFIGURATION

`E2EProfileConfigurationSet`

E-2-E-PROFILE-CONFIGURATION-SET

`Ecc`

ECC

`Ecu`

ECU

`EcuAbstractionSwComponentType`

ECU-ABSTRACTION-SW-COMPONENT-TYPE

`EcuInstance`

ECU-INSTANCE

`EcuManager`

ECU-MANAGER

`EcuMapping`

ECU-MAPPING

`EcuPartition`

ECU-PARTITION

`EcuStateMgrUserNeeds`

ECU-STATE-MGR-USER-NEEDS

`EcuTiming`

ECU-TIMING

`EcucAbstractExternalReferenceDef`

ECUC-ABSTRACT-EXTERNAL-REFERENCE-DEF

`EcucAbstractInternalReferenceDef`

ECUC-ABSTRACT-INTERNAL-REFERENCE-DEF

`EcucAbstractReferenceDef`

ECUC-ABSTRACT-REFERENCE-DEF

`EcucAbstractStringParamDef`

ECUC-ABSTRACT-STRING-PARAM-DEF

`EcucAddInfoParamDef`

ECUC-ADD-INFO-PARAM-DEF

`EcucBooleanParamDef`

ECUC-BOOLEAN-PARAM-DEF

`EcucChoiceContainerDef`

ECUC-CHOICE-CONTAINER-DEF

`EcucChoiceReferenceDef`

ECUC-CHOICE-REFERENCE-DEF

`EcucCommonAttributes`

ECUC-COMMON-ATTRIBUTES

`EcucContainerDef`

ECUC-CONTAINER-DEF

`EcucContainerValue`

ECUC-CONTAINER-VALUE

`EcucDefinitionCollection`

ECUC-DEFINITION-COLLECTION

`EcucDefinitionElement`

ECUC-DEFINITION-ELEMENT

`EcucDestinationUriDef`

ECUC-DESTINATION-URI-DEF

`EcucDestinationUriDefSet`

ECUC-DESTINATION-URI-DEF-SET

`EcucEnumerationLiteralDef`

ECUC-ENUMERATION-LITERAL-DEF

`EcucEnumerationParamDef`

ECUC-ENUMERATION-PARAM-DEF

`EcucFloatParamDef`

ECUC-FLOAT-PARAM-DEF

`EcucForeignReferenceDef`

ECUC-FOREIGN-REFERENCE-DEF

`EcucFunctionNameDef`

ECUC-FUNCTION-NAME-DEF

`EcucInstanceReferenceDef`

ECUC-INSTANCE-REFERENCE-DEF

`EcucIntegerParamDef`

ECUC-INTEGER-PARAM-DEF

`EcucLinkerSymbolDef`

ECUC-LINKER-SYMBOL-DEF

`EcucModuleConfigurationValues`

ECUC-MODULE-CONFIGURATION-VALUES

`EcucModuleDef`

ECUC-MODULE-DEF

`EcucMultilineStringParamDef`

ECUC-MULTILINE-STRING-PARAM-DEF

`EcucParamConfContainerDef`

ECUC-PARAM-CONF-CONTAINER-DEF

`EcucParameterDef`

ECUC-PARAMETER-DEF

`EcucQuery`

ECUC-QUERY

`EcucQueryExpression`

ECUC-QUERY-EXPRESSION

`EcucReferenceDef`

ECUC-REFERENCE-DEF

`EcucStringParamDef`

ECUC-STRING-PARAM-DEF

`EcucSymbolicNameReferenceDef`

ECUC-SYMBOLIC-NAME-REFERENCE-DEF

`EcucUriReferenceDef`

ECUC-URI-REFERENCE-DEF

`EcucValidationCondition`

ECUC-VALIDATION-CONDITION

`EcucValueCollection`

ECUC-VALUE-COLLECTION

`EdgeNode`

EDGE-NODE

`El`

EL

`EmissionRelatedDtc`

EMISSION-RELATED-DTC

`En`

EN

`Enable`

ENABLE

`Enabled`

ENABLED

`EncryptAndSign`

ENCRYPT-AND-SIGN

`EncryptAndSignWithOriginAuthentication`

ENCRYPT-AND-SIGN-WITH-ORIGIN-AUTHENTICATION

`Encryption`

ENCRYPTION

`End2EndEventProtectionProps`

END-2-END-EVENT-PROTECTION-PROPS

`End2EndMethodProtectionProps`

END-2-END-METHOD-PROTECTION-PROPS

`EndToEndProtection`

END-TO-END-PROTECTION

`EndToEndProtectionISignalIPdu`

END-TO-END-PROTECTION-I-SIGNAL-I-PDU

`EndToEndProtectionSet`

END-TO-END-PROTECTION-SET

`EndToEndProtectionVariablePrototype`

END-TO-END-PROTECTION-VARIABLE-PROTOTYPE

`Enhanced`

ENHANCED

`EnumerationMappingTable`

ENUMERATION-MAPPING-TABLE

`Eo`

EO

`EocEventRef`

EOC-EVENT-REF

`EocExecutableEntityRef`

EOC-EXECUTABLE-ENTITY-REF

`EocExecutableEntityRefAbstract`

EOC-EXECUTABLE-ENTITY-REF-ABSTRACT

`EocExecutableEntityRefGroup`

EOC-EXECUTABLE-ENTITY-REF-GROUP

`Eps`

EPS

`Equal`

EQUAL

`Error`

ERROR

`ErrorCorrection`

ERROR-CORRECTION

`ErrorDetection`

ERROR-DETECTION

`ErrorTracer`

ERROR-TRACER

`ErrorTracerNeeds`

ERROR-TRACER-NEEDS

`Es`

ES

`Esp`

ESP

`Et`

ET

`EthIpProps`

ETH-IP-PROPS

`EthTcpIpIcmpProps`

ETH-TCP-IP-ICMP-PROPS

`EthTcpIpProps`

ETH-TCP-IP-PROPS

`EthTpConfig`

ETH-TP-CONFIG

`EthernetCluster`

ETHERNET-CLUSTER

`EthernetCommunicationConnector`

ETHERNET-COMMUNICATION-CONNECTOR

`EthernetCommunicationController`

ETHERNET-COMMUNICATION-CONTROLLER

`EthernetFrame`

ETHERNET-FRAME

`EthernetFrameTriggering`

ETHERNET-FRAME-TRIGGERING

`EthernetNetworkConfiguration`

ETHERNET-NETWORK-CONFIGURATION

`EthernetPhysicalChannel`

ETHERNET-PHYSICAL-CHANNEL

`EthernetPriorityRegeneration`

ETHERNET-PRIORITY-REGENERATION

`EthernetRawDataStreamClientMapping`

ETHERNET-RAW-DATA-STREAM-CLIENT-MAPPING

`EthernetRawDataStreamGrant`

ETHERNET-RAW-DATA-STREAM-GRANT

`EthernetRawDataStreamMapping`

ETHERNET-RAW-DATA-STREAM-MAPPING

`EthernetRawDataStreamServerMapping`

ETHERNET-RAW-DATA-STREAM-SERVER-MAPPING

`EthernetWakeupSleepOnDatalineConfig`

ETHERNET-WAKEUP-SLEEP-ON-DATALINE-CONFIG

`EthernetWakeupSleepOnDatalineConfigSet`

ETHERNET-WAKEUP-SLEEP-ON-DATALINE-CONFIG-SET

`Eu`

EU

`EvaluatedVariantSet`

EVALUATED-VARIANT-SET

`Evap`

EVAP

`EventAcceptanceDisabled`

EVENT-ACCEPTANCE-DISABLED

`EventAcceptanceEnabled`

EVENT-ACCEPTANCE-ENABLED

`EventCombinationOnRetrieval`

EVENT-COMBINATION-ON-RETRIEVAL

`EventCombinationOnStorage`

EVENT-COMBINATION-ON-STORAGE

`EventHandler`

EVENT-HANDLER

`EventMapping`

EVENT-MAPPING

`EventStorageDisabled`

EVENT-STORAGE-DISABLED

`EventStorageEnabled`

EVENT-STORAGE-ENABLED

`EventTriggeringConstraint`

EVENT-TRIGGERING-CONSTRAINT

`EventWindowCurrentAndFollowingCycle`

EVENT-WINDOW-CURRENT-AND-FOLLOWING-CYCLE

`EventWindowCurrentCycle`

EVENT-WINDOW-CURRENT-CYCLE

`EventWindowInfinite`

EVENT-WINDOW-INFINITE

`ExactOrAnyMinorVersion`

EXACT-OR-ANY-MINOR-VERSION

`Example`

EXAMPLE

`ExcludeFromFlash`

EXCLUDE-FROM-FLASH

`Exclusive`

EXCLUSIVE

`ExclusiveArea`

EXCLUSIVE-AREA

`ExclusiveAreaNestingOrder`

EXCLUSIVE-AREA-NESTING-ORDER

`Executable`

EXECUTABLE

`ExecutableEntity`

EXECUTABLE-ENTITY

`ExecutableEntityActivationReason`

EXECUTABLE-ENTITY-ACTIVATION-REASON

`ExecutableGroup`

EXECUTABLE-GROUP

`ExecutableTiming`

EXECUTABLE-TIMING

`Execute`

EXECUTE

`ExecutionOrderConstraint`

EXECUTION-ORDER-CONSTRAINT

`ExecutionTime`

EXECUTION-TIME

`ExecutionTimeConstraint`

EXECUTION-TIME-CONSTRAINT

`Exercise`

EXERCISE

`Explicit`

EXPLICIT

`Extended`

EXTENDED

`ExternalReplacement`

EXTERNAL-REPLACEMENT

`ExternalTriggerOccurredEvent`

EXTERNAL-TRIGGER-OCCURRED-EVENT

`ExternalTriggeringPointIdent`

EXTERNAL-TRIGGERING-POINT-IDENT

`Fa`

FA

`FailureAndSuccess`

FAILURE-AND-SUCCESS

`FailureOnly`

FAILURE-ONLY

`False`

FALSE

`FastFlashingMode`

FAST-FLASHING-MODE

`Fatal`

FATAL

`Fault`

FAULT

`FdcThreshold`

FDC-THRESHOLD

`Fi`

FI

`FibexElement`

FIBEX-ELEMENT

`Field`

FIELD

`FieldMapping`

FIELD-MAPPING

`File`

FILE

`Filtered`

FILTERED

`Finish`

FINISH

`FireAndForgetMapping`

FIRE-AND-FORGET-MAPPING

`FirstContainedTrigger`

FIRST-CONTAINED-TRIGGER

`FirstToSecond`

FIRST-TO-SECOND

`FitToPage`

FIT-TO-PAGE

`FitToText`

FIT-TO-TEXT

`FixAxis`

FIX-AXIS

`Fixed`

FIXED

`FixedSize`

FIXED-SIZE

`Fixaxis`

FIX_AXIS

`Fj`

FJ

`FlatInstanceDescriptor`

FLAT-INSTANCE-DESCRIPTOR

`FlatMap`

FLAT-MAP

`FlexrayArTpConfig`

FLEXRAY-AR-TP-CONFIG

`FlexrayArTpNode`

FLEXRAY-AR-TP-NODE

`FlexrayCluster`

FLEXRAY-CLUSTER

`FlexrayCommunicationConnector`

FLEXRAY-COMMUNICATION-CONNECTOR

`FlexrayCommunicationController`

FLEXRAY-COMMUNICATION-CONTROLLER

`FlexrayFrame`

FLEXRAY-FRAME

`FlexrayFrameTriggering`

FLEXRAY-FRAME-TRIGGERING

`FlexrayNmCluster`

FLEXRAY-NM-CLUSTER

`FlexrayNmNode`

FLEXRAY-NM-NODE

`FlexrayPhysicalChannel`

FLEXRAY-PHYSICAL-CHANNEL

`FlexrayTpConfig`

FLEXRAY-TP-CONFIG

`FlexrayTpConnectionControl`

FLEXRAY-TP-CONNECTION-CONTROL

`FlexrayTpNode`

FLEXRAY-TP-NODE

`FlexrayTpPduPool`

FLEXRAY-TP-PDU-POOL

`Float`

FLOAT

`FmAttributeDef`

FM-ATTRIBUTE-DEF

`FmFeature`

FM-FEATURE

`FmFeatureMap`

FM-FEATURE-MAP

`FmFeatureMapAssertion`

FM-FEATURE-MAP-ASSERTION

`FmFeatureMapCondition`

FM-FEATURE-MAP-CONDITION

`FmFeatureMapElement`

FM-FEATURE-MAP-ELEMENT

`FmFeatureModel`

FM-FEATURE-MODEL

`FmFeatureRelation`

FM-FEATURE-RELATION

`FmFeatureRestriction`

FM-FEATURE-RESTRICTION

`FmFeatureSelection`

FM-FEATURE-SELECTION

`FmFeatureSelectionSet`

FM-FEATURE-SELECTION-SET

`Fo`

FO

`ForAll`

FOR-ALL

`Forget`

FORGET

`ForwardAsIs`

FORWARD-AS-IS

`Fr`

FR

`Frame`

FRAME

`FrameEthernetQueuedForTransmission`

FRAME-ETHERNET-QUEUED-FOR-TRANSMISSION

`FrameEthernetReceivedByIf`

FRAME-ETHERNET-RECEIVED-BY-IF

`FrameEthernetReceivedOnBus`

FRAME-ETHERNET-RECEIVED-ON-BUS

`FrameEthernetSentOnBus`

FRAME-ETHERNET-SENT-ON-BUS

`FramePort`

FRAME-PORT

`FrameQueuedForTransmission`

FRAME-QUEUED-FOR-TRANSMISSION

`FrameReceivedByIf`

FRAME-RECEIVED-BY-IF

`FrameTransmittedOnBus`

FRAME-TRANSMITTED-ON-BUS

`FrameTriggering`

FRAME-TRIGGERING

`Full`

FULL

`FullDuplexMode`

FULL-DUPLEX-MODE

`FunctionGroupModeRequestPhmActionItem`

FUNCTION-GROUP-MODE-REQUEST-PHM-ACTION-ITEM

`FunctionGroupSet`

FUNCTION-GROUP-SET

`FunctionInhibitionAvailabilityNeeds`

FUNCTION-INHIBITION-AVAILABILITY-NEEDS

`FunctionInhibitionManager`

FUNCTION-INHIBITION-MANAGER

`FunctionInhibitionNeeds`

FUNCTION-INHIBITION-NEEDS

`Functional`

FUNCTIONAL

`FunctionalAddress`

FUNCTIONAL-ADDRESS

`FunctionalCanFd`

FUNCTIONAL-CAN-FD

`FunctionalClusterInteractsWithFunctionalClusterMapping`

FUNCTIONAL-CLUSTER-INTERACTS-WITH-FUNCTIONAL-CLUSTER-MAPPING

`FurtherActionByteNeeds`

FURTHER-ACTION-BYTE-NEEDS

`Fy`

FY

`Ga`

GA

`Gateway`

GATEWAY

`Gd`

GD

`GeneralParameter`

GENERAL-PARAMETER

`GeneralPurposeConnection`

GENERAL-PURPOSE-CONNECTION

`GeneralPurposeIPdu`

GENERAL-PURPOSE-I-PDU

`GeneralPurposePdu`

GENERAL-PURPOSE-PDU

`GenericEthernetFrame`

GENERIC-ETHERNET-FRAME

`GenericModuleInstantiation`

GENERIC-MODULE-INSTANTIATION

`Get`

GET

`Getter`

GETTER

`GetterSetter`

GETTER-SETTER

`Gif`

GIF

`Gl`

GL

`GlobalSupervision`

GLOBAL-SUPERVISION

`GlobalSupervisionEntity`

GLOBAL-SUPERVISION-ENTITY

`GlobalSupervisionNeeds`

GLOBAL-SUPERVISION-NEEDS

`GlobalTimeCanMaster`

GLOBAL-TIME-CAN-MASTER

`GlobalTimeCanSlave`

GLOBAL-TIME-CAN-SLAVE

`GlobalTimeDomain`

GLOBAL-TIME-DOMAIN

`GlobalTimeEthMaster`

GLOBAL-TIME-ETH-MASTER

`GlobalTimeEthSlave`

GLOBAL-TIME-ETH-SLAVE

`GlobalTimeFrMaster`

GLOBAL-TIME-FR-MASTER

`GlobalTimeFrSlave`

GLOBAL-TIME-FR-SLAVE

`GlobalTimeGateway`

GLOBAL-TIME-GATEWAY

`GlobalTimeMaster`

GLOBAL-TIME-MASTER

`GlobalTimeSlave`

GLOBAL-TIME-SLAVE

`Gn`

GN

`Grant`

GRANT

`GrantDesign`

GRANT-DESIGN

`Gross`

GROSS

`Gu`

GU

`Gzip`

GZIP

`Ha`

HA

`HalfDuplexMode`

HALF-DUPLEX-MODE

`HardwareTestManager`

HARDWARE-TEST-MANAGER

`HardwareTestNeeds`

HARDWARE-TEST-NEEDS

`Head`

HEAD

`HealthChannel`

HEALTH-CHANNEL

`HealthChannelExternalMode`

HEALTH-CHANNEL-EXTERNAL-MODE

`HealthChannelExternalStatus`

HEALTH-CHANNEL-EXTERNAL-STATUS

`HealthChannelSupervision`

HEALTH-CHANNEL-SUPERVISION

`HeapUsage`

HEAP-USAGE

`Hi`

HI

`HierarchicalEoc`

HIERARCHICAL-EOC

`High`

HIGH

`Hint`

HINT

`Hook`

HOOK

`HostPort`

HOST-PORT

`Hr`

HR

`Hu`

HU

`Hub`

HUB

`HwAttributeDef`

HW-ATTRIBUTE-DEF

`HwAttributeLiteralDef`

HW-ATTRIBUTE-LITERAL-DEF

`HwCategory`

HW-CATEGORY

`HwDescriptionEntity`

HW-DESCRIPTION-ENTITY

`HwElement`

HW-ELEMENT

`HwPin`

HW-PIN

`HwPinGroup`

HW-PIN-GROUP

`HwType`

HW-TYPE

`Hy`

HY

`I4G`

I-4-G

`IPdu`

I-PDU

`IPduPort`

I-PDU-PORT

`IPduReceivedByCom`

I-PDU-RECEIVED-BY-COM

`IPduSentToIf`

I-PDU-SENT-TO-IF

`IPduTriggering`

I-PDU-TRIGGERING

`IPv6ExtHeaderFilterList`

I-PV-6-EXT-HEADER-FILTER-LIST

`IPv6ExtHeaderFilterSet`

I-PV-6-EXT-HEADER-FILTER-SET

`ISignal`

I-SIGNAL

`ISignalAvailableForRte`

I-SIGNAL-AVAILABLE-FOR-RTE

`ISignalGroup`

I-SIGNAL-GROUP

`ISignalIPdu`

I-SIGNAL-I-PDU

`ISignalIPduGroup`

I-SIGNAL-I-PDU-GROUP

`ISignalPort`

I-SIGNAL-PORT

`ISignalSentToCom`

I-SIGNAL-SENT-TO-COM

`ISignalToIPduMapping`

I-SIGNAL-TO-I-PDU-MAPPING

`ISignalTriggering`

I-SIGNAL-TRIGGERING

`Ia`

IA

`IamModuleInstantiation`

IAM-MODULE-INSTANTIATION

`Icmp`

ICMP

`IdentCaption`

IDENT-CAPTION

`Identifiable`

IDENTIFIABLE

`IdsCommonElement`

IDS-COMMON-ELEMENT

`IdsDesign`

IDS-DESIGN

`IdsMapping`

IDS-MAPPING

`IdsMgrCustomTimestampNeeds`

IDS-MGR-CUSTOM-TIMESTAMP-NEEDS

`IdsMgrNeeds`

IDS-MGR-NEEDS

`IdsPlatformInstantiation`

IDS-PLATFORM-INSTANTIATION

`IdsmInstance`

IDSM-INSTANCE

`IdsmModuleInstantiation`

IDSM-MODULE-INSTANTIATION

`IdsmProperties`

IDSM-PROPERTIES

`IdsmRateLimitation`

IDSM-RATE-LIMITATION

`IdsmTrafficLimitation`

IDSM-TRAFFIC-LIMITATION

`Ie`

IE

`Ieee1722TpEthernetFrame`

IEEE-1722-TP-ETHERNET-FRAME

`Ieee80211p`

IEEE802-11P

`Ieee8021as`

IEEE802-1AS

`Ieee8021asAutosar`

IEEE802-1AS-AUTOSAR

`Ignition`

IGNITION

`Ignore`

IGNORE

`Ik`

IK

`Immediate`

IMMEDIATE

`Immediately`

IMMEDIATELY

`Implementation`

IMPLEMENTATION

`ImplementationDataType`

IMPLEMENTATION-DATA-TYPE

`ImplementationDataTypeElement`

IMPLEMENTATION-DATA-TYPE-ELEMENT

`ImplementationDataTypeElementExtension`

IMPLEMENTATION-DATA-TYPE-ELEMENT-EXTENSION

`ImplementationDataTypeExtension`

IMPLEMENTATION-DATA-TYPE-EXTENSION

`ImplementationProps`

IMPLEMENTATION-PROPS

`In`

IN

`Increasing`

INCREASING

`Indicate`

INDICATE

`IndicatorStatusNeeds`

INDICATOR-STATUS-NEEDS

`Individual`

INDIVIDUAL

`Infinite`

INFINITE

`InfiniteTimeToResponse`

INFINITE-TIME-TO-RESPONSE

`Info`

INFO

`InheritedFromArrayElementTypeSize`

INHERITED-FROM-ARRAY-ELEMENT-TYPE-SIZE

`InitEvent`

INIT-EVENT

`Inline`

INLINE

`InlineConditional`

INLINE-CONDITIONAL

`Inout`

INOUT

`Install`

INSTALL

`InstanceId`

INSTANCE-ID

`Instruction`

INSTRUCTION

`InterPartitionIntraEcu`

INTER-PARTITION-INTRA-ECU

`InterfaceMapping`

INTERFACE-MAPPING

`InterfaceMappingSet`

INTERFACE-MAPPING-SET

`InternalBehavior`

INTERNAL-BEHAVIOR

`InternalTriggerOccurredEvent`

INTERNAL-TRIGGER-OCCURRED-EVENT

`InternalTriggeringPoint`

INTERNAL-TRIGGERING-POINT

`InterpolationRoutineMappingSet`

INTERPOLATION-ROUTINE-MAPPING-SET

`Interrupt`

INTERRUPT

`InterruptCat1`

INTERRUPT-CAT-1

`InterruptCat2`

INTERRUPT-CAT-2

`IntrusionDetectionSecurityManagement`

INTRUSION-DETECTION-SECURITY-MANAGEMENT

`Invalid`

INVALID

`IpIamRemoteSubject`

IP-IAM-REMOTE-SUBJECT

`IpSecConfigProps`

IP-SEC-CONFIG-PROPS

`IpSecIamRemoteSubject`

IP-SEC-IAM-REMOTE-SUBJECT

`IpSecRule`

IP-SEC-RULE

`Ipsec`

IPSEC

`Is`

IS

`IsEqual`

IS-EQUAL

`IsExpired`

IS-EXPIRED

`IsFailed`

IS-FAILED

`IsGreaterOrEqual`

IS-GREATER-OR-EQUAL

`IsGreaterThan`

IS-GREATER-THAN

`IsGreaterThanOrEqual`

IS-GREATER-THAN-OR-EQUAL

`IsLessOrEqual`

IS-LESS-OR-EQUAL

`IsLessThan`

IS-LESS-THAN

`IsLessThanOrEqual`

IS-LESS-THAN-OR-EQUAL

`IsNotEqual`

IS-NOT-EQUAL

`IsNotRelevant`

IS-NOT-RELEVANT

`IsOk`

IS-OK

`IsRelevant`

IS-RELEVANT

`IsStopped`

IS-STOPPED

`Iso`

ISO

`Iso119924`

ISO-11992–4

`Iso142291`

ISO-14229–1

`Iso150316`

ISO-15031–6

`Iso6`

ISO-6

`It`

IT

`Italic`

ITALIC

`Iw`

IW

`J1939`

J-1939

`J1939Cluster`

J-1939-CLUSTER

`J1939ControllerApplication`

J-1939-CONTROLLER-APPLICATION

`J1939Dcm`

J-1939-DCM

`J1939DcmDm19Support`

J-1939-DCM-DM-19-SUPPORT

`J1939DcmIPdu`

J-1939-DCM-I-PDU

`J1939NmCluster`

J-1939-NM-CLUSTER

`J1939NmNode`

J-1939-NM-NODE

`J1939RequestManager`

J-1939-REQUEST-MANAGER

`J1939RmIncomingRequestServiceNeeds`

J-1939-RM-INCOMING-REQUEST-SERVICE-NEEDS

`J1939RmOutgoingRequestServiceNeeds`

J-1939-RM-OUTGOING-REQUEST-SERVICE-NEEDS

`J1939SharedAddressCluster`

J-1939-SHARED-ADDRESS-CLUSTER

`J1939TpConfig`

J-1939-TP-CONFIG

`J1939TpNode`

J-1939-TP-NODE

`Ja`

JA

`Java`

JAVA

`Ji`

JI

`Jpg`

JPG

`Justify`

JUSTIFY

`Jw`

JW

`Ka`

KA

`Keep`

KEEP

`KeepExisting`

KEEP-EXISTING

`KeyDerivation`

KEY-DERIVATION

`KeyStorage`

KEY-STORAGE

`Keyword`

KEYWORD

`KeywordSet`

KEYWORD-SET

`Kk`

KK

`Kl`

KL

`Km`

KM

`Kn`

KN

`Ko`

KO

`Ks`

KS

`Ku`

KU

`Ky`

KY

`La`

LA

`Land`

LAND

`LastFailed`

LAST-FAILED

`LastIsBest`

LAST-IS-BEST

`LastMode`

LAST-MODE

`LatencyTimingConstraint`

LATENCY-TIMING-CONSTRAINT

`LeafOfTargetContainer`

LEAF-OF-TARGET-CONTAINER

`Left`

LEFT

`Legacy`

LEGACY

`LifeCycleInfoSet`

LIFE-CYCLE-INFO-SET

`LifeCycleState`

LIFE-CYCLE-STATE

`LifeCycleStateDefinitionGroup`

LIFE-CYCLE-STATE-DEFINITION-GROUP

`LimitToPage`

LIMIT-TO-PAGE

`LimitToText`

LIMIT-TO-TEXT

`LinCluster`

LIN-CLUSTER

`LinCommunicationConnector`

LIN-COMMUNICATION-CONNECTOR

`LinCommunicationController`

LIN-COMMUNICATION-CONTROLLER

`LinEventTriggeredFrame`

LIN-EVENT-TRIGGERED-FRAME

`LinFrame`

LIN-FRAME

`LinFrameTriggering`

LIN-FRAME-TRIGGERING

`LinMaster`

LIN-MASTER

`LinNmCluster`

LIN-NM-CLUSTER

`LinPhysicalChannel`

LIN-PHYSICAL-CHANNEL

`LinScheduleTable`

LIN-SCHEDULE-TABLE

`LinSlave`

LIN-SLAVE

`LinSlaveConfigIdent`

LIN-SLAVE-CONFIG-IDENT

`LinSporadicFrame`

LIN-SPORADIC-FRAME

`LinTpConfig`

LIN-TP-CONFIG

`LinTpNode`

LIN-TP-NODE

`LinUnconditionalFrame`

LIN-UNCONDITIONAL-FRAME

`Link`

LINK

`LinkLocal`

LINK-LOCAL

`LinkLocalDoip`

LINK-LOCAL–DOIP

`LinkTime`

LINK-TIME

`Linker`

LINKER

`Listen`

LISTEN

`Ln`

LN

`Lo`

LO

`Local`

LOCAL

`LocalSupervision`

LOCAL-SUPERVISION

`LogAndTraceInstantiation`

LOG-AND-TRACE-INSTANTIATION

`LogAndTraceInterface`

LOG-AND-TRACE-INTERFACE

`LogAndTraceMessageCollectionSet`

LOG-AND-TRACE-MESSAGE-COLLECTION-SET

`LogicAddress`

LOGIC-ADDRESS

`LogicalAnd`

LOGICAL-AND

`LogicalExpression`

LOGICAL-EXPRESSION

`LogicalOr`

LOGICAL-OR

`LogicalSupervision`

LOGICAL-SUPERVISION

`LongHeader`

LONG-HEADER

`Low`

LOW

`Lower12Bit`

LOWER-12-BIT

`Lower8Bit`

LOWER-8-BIT

`Lt`

LT

`LtAffectsPb`

LT-AFFECTS-PB

`Lts13`

LTS-13

`Lv`

LV

`MacMulticastGroup`

MAC-MULTICAST-GROUP

`Machine`

MACHINE

`MachineDesign`

MACHINE-DESIGN

`MachineModeRequestPhmActionItem`

MACHINE-MODE-REQUEST-PHM-ACTION-ITEM

`MachineTiming`

MACHINE-TIMING

`Macro`

MACRO

`MaintenanceOnly`

MAINTENANCE-ONLY

`Malfunction`

MALFUNCTION

`Manufacturing`

MANUFACTURING

`MappingScopeCore`

MAPPING-SCOPE-CORE

`MappingScopeEcu`

MAPPING-SCOPE-ECU

`MappingScopePartition`

MAPPING-SCOPE-PARTITION

`MasekdNewEqualsMaskedOld`

MASEKD-NEW-EQUALS-MASKED-OLD

`MasekdNewEqualsX`

MASEKD-NEW-EQUALS-X

`MaskedNewDiffersMaskedOld`

MASKED-NEW-DIFFERS-MASKED-OLD

`MaskedNewDiffersX`

MASKED-NEW-DIFFERS-X

`MaskedNewEqualsMaskedOld`

MASKED-NEW-EQUALS-MASKED-OLD

`MaskedNewEqualsX`

MASKED-NEW-EQUALS-X

`Master`

MASTER

`MasterEcu`

MASTER-ECU

`Max`

MAX

`McDataInstance`

MC-DATA-INSTANCE

`McFunction`

MC-FUNCTION

`McGroup`

MC-GROUP

`MeasuredExecutionTime`

MEASURED-EXECUTION-TIME

`MeasuredHeapUsage`

MEASURED-HEAP-USAGE

`MeasuredStackUsage`

MEASURED-STACK-USAGE

`MeasurementPoint`

MEASUREMENT-POINT

`Medium`

MEDIUM

`MemorySection`

MEMORY-SECTION

`MethodMapping`

METHOD-MAPPING

`Mg`

MG

`Mi`

MI

`Middle`

MIDDLE

`Min`

MIN

`MinimumMinorVersion`

MINIMUM-MINOR-VERSION

`Mixed`

MIXED

`Mixed29Bit`

MIXED-29-BIT

`Mk`

MK

`Ml`

ML

`Mn`

MN

`Mo`

MO

`ModeAccessPointIdent`

MODE-ACCESS-POINT-IDENT

`ModeDeclaration`

MODE-DECLARATION

`ModeDeclarationGroup`

MODE-DECLARATION-GROUP

`ModeDeclarationGroupPrototype`

MODE-DECLARATION-GROUP-PROTOTYPE

`ModeDeclarationMapping`

MODE-DECLARATION-MAPPING

`ModeDeclarationMappingSet`

MODE-DECLARATION-MAPPING-SET

`ModeDeclarationRequested`

MODE-DECLARATION-REQUESTED

`ModeDeclarationSwitchCompleted`

MODE-DECLARATION-SWITCH-COMPLETED

`ModeDeclarationSwitchInitiated`

MODE-DECLARATION-SWITCH-INITIATED

`ModeInterfaceMapping`

MODE-INTERFACE-MAPPING

`ModeSwitchInterface`

MODE-SWITCH-INTERFACE

`ModeSwitchPoint`

MODE-SWITCH-POINT

`ModeSwitchedAckEvent`

MODE-SWITCHED-ACK-EVENT

`ModeTransition`

MODE-TRANSITION

`Modeled`

MODELED

`MonitorMode`

MONITOR-MODE

`Mono`

MONO

`Monotonous`

MONOTONOUS

`MostSignificantByteFirst`

MOST-SIGNIFICANT-BYTE-FIRST

`MostSignificantByteLast`

MOST-SIGNIFICANT-BYTE-LAST

`Mr`

MR

`Ms`

MS

`Mt`

MT

`MulticoreReentrant`

MULTICORE-REENTRANT

`MultilanguageReferrable`

MULTILANGUAGE-REFERRABLE

`Multiple`

MULTIPLE

`MultipleOccurrences`

MULTIPLE-OCCURRENCES

`MultiplexedIPdu`

MULTIPLEXED-I-PDU

`My`

MY

`NPdu`

N-PDU

`Na`

NA

`Nand`

NAND

`Ne`

NE

`Net`

NET

`Network`

NETWORK

`NetworkConfiguration`

NETWORK-CONFIGURATION

`NetworkEndpoint`

NETWORK-ENDPOINT

`NetworkRepresentationFromComSpec`

NETWORK-REPRESENTATION-FROM-COM-SPEC

`Never`

NEVER

`NewIsDifferent`

NEW-IS-DIFFERENT

`NewIsEqual`

NEW-IS-EQUAL

`NewIsGreater`

NEW-IS-GREATER

`NewIsGreaterOrEqual`

NEW-IS-GREATER-OR-EQUAL

`NewIsLess`

NEW-IS-LESS

`NewIsLessOrEqual`

NEW-IS-LESS-OR-EQUAL

`NewIsOutside`

NEW-IS-OUTSIDE

`NewIsWithin`

NEW-IS-WITHIN

`Newline`

NEWLINE

`NewlineIfNecessary`

NEWLINE-IF-NECESSARY

`Nfold`

NFOLD

`Nl`

NL

`NmCluster`

NM-CLUSTER

`NmConfig`

NM-CONFIG

`NmEcu`

NM-ECU

`NmHandleToFunctionGroupStateMapping`

NM-HANDLE-TO-FUNCTION-GROUP-STATE-MAPPING

`NmInstantiation`

NM-INSTANTIATION

`NmNetworkHandle`

NM-NETWORK-HANDLE

`NmNode`

NM-NODE

`NmPdu`

NM-PDU

`No`

NO

`NoAck`

NO-ACK

`NoAffect`

NO-AFFECT

`NoBoot`

NO-BOOT

`NoBreak`

NO-BREAK

`NoDefault`

NO-DEFAULT

`NoFloat`

NO-FLOAT

`NoHeader`

NO-HEADER

`NoKeep`

NO-KEEP

`NoMonotony`

NO-MONOTONY

`NoNewline`

NO-NEWLINE

`NoObdSupport`

NO-OBD-SUPPORT

`NoPgwide`

NO-PGWIDE

`NoProtection`

NO-PROTECTION

`NoReturnValueProvided`

NO-RETURN-VALUE-PROVIDED

`NoSeverity`

NO-SEVERITY

`NoShowAliasName`

NO-SHOW-ALIAS-NAME

`NoShowCategory`

NO-SHOW-CATEGORY

`NoShowContent`

NO-SHOW-CONTENT

`NoShowLongName`

NO-SHOW-LONG-NAME

`NoShowNumber`

NO-SHOW-NUMBER

`NoShowPage`

NO-SHOW-PAGE

`NoShowSee`

NO-SHOW-SEE

`NoShowShortName`

NO-SHOW-SHORT-NAME

`NoShowType`

NO-SHOW-TYPE

`NoSloppy`

NO-SLOPPY

`NoStatusByteChange`

NO-STATUS-BYTE-CHANGE

`NoStoreEvent`

NO-STORE-EVENT

`NoSupervision`

NO-SUPERVISION

`NoSupport`

NO-SUPPORT

`NoTransformerErrorHandling`

NO-TRANSFORMER-ERROR-HANDLING

`NoTransformerStatusForwarding`

NO-TRANSFORMER-STATUS-FORWARDING

`NoTrustedPlatformSupport`

NO-TRUSTED-PLATFORM-SUPPORT

`Node`

NODE

`Nohref`

NOHREF

`NonEmmissionRelatedDtc`

NON-EMMISSION-RELATED-DTC

`NonOsModuleInstantiation`

NON-OS-MODULE-INSTANTIATION

`NonReentrant`

NON-REENTRANT

`NonVolatile`

NON-VOLATILE

`NonVolatileRamManager`

NON-VOLATILE-RAM-MANAGER

`None`

NONE

`Normalfixed`

NORMALFIXED

`Not`

NOT

`NotAccessible`

NOT-ACCESSIBLE

`NotAvailable`

NOT-AVAILABLE

`NotDefined`

NOT-DEFINED

`NotEqual`

NOT-EQUAL

`NotSent`

NOT-SENT

`NotTested`

NOT-TESTED

`NotValid`

NOT-VALID

`Nothing`

NOTHING

`Notification`

NOTIFICATION

`NtpRfc958`

NTP–RFC-958

`Number`

NUMBER

`NvBlockDescriptor`

NV-BLOCK-DESCRIPTOR

`NvBlockNeeds`

NV-BLOCK-NEEDS

`NvBlockSwComponentType`

NV-BLOCK-SW-COMPONENT-TYPE

`NvDataInterface`

NV-DATA-INTERFACE

`NvRamManager`

NV-RAM-MANAGER

`Obd`

OBD

`ObdControlServiceNeeds`

OBD-CONTROL-SERVICE-NEEDS

`ObdDcy`

OBD-DCY

`ObdDrivingCycle`

OBD-DRIVING-CYCLE

`ObdInfoServiceNeeds`

OBD-INFO-SERVICE-NEEDS

`ObdMonitorServiceNeeds`

OBD-MONITOR-SERVICE-NEEDS

`ObdPidServiceNeeds`

OBD-PID-SERVICE-NEEDS

`ObdRatioDenominatorNeeds`

OBD-RATIO-DENOMINATOR-NEEDS

`ObdRatioServiceNeeds`

OBD-RATIO-SERVICE-NEEDS

`Observer`

OBSERVER

`ObserverBased`

OBSERVER-BASED

`Oc`

OC

`Occurence`

OCCURENCE

`OemBoot`

OEM-BOOT

`OemBootRespApp`

OEM-BOOT-RESP-APP

`Off`

OFF

`Offset`

OFFSET

`OffsetTimingConstraint`

OFFSET-TIMING-CONSTRAINT

`Om`

OM

`OnChangeOfDataIdentifier`

ON-CHANGE-OF-DATA-IDENTIFIER

`OnComparisonOfValues`

ON-COMPARISON-OF-VALUES

`OnDtcStatusChange`

ON-DTC-STATUS-CHANGE

`OnEntry`

ON-ENTRY

`OnExit`

ON-EXIT

`OnTransition`

ON-TRANSITION

`OneEveryN`

ONE-EVERY-N

`OnlyThisCycleAndReadiness`

ONLY-THIS-CYCLE-AND-READINESS

`Opaque`

OPAQUE

`Open`

OPEN

`OperatingSystem`

OPERATING-SYSTEM

`OperationCallReceived`

OPERATION-CALL-RECEIVED

`OperationCallResponseReceived`

OPERATION-CALL-RESPONSE-RECEIVED

`OperationCallResponseSent`

OPERATION-CALL-RESPONSE-SENT

`OperationCalled`

OPERATION-CALLED

`OperationInvokedEvent`

OPERATION-INVOKED-EVENT

`Options`

OPTIONS

`Or`

OR

`OrdinaryEoc`

ORDINARY-EOC

`OsModuleInstantiation`

OS-MODULE-INSTANTIATION

`OsTaskExecutionEvent`

OS-TASK-EXECUTION-EVENT

`OsTaskProxy`

OS-TASK-PROXY

`Other`

OTHER

`Out`

OUT

`Override`

OVERRIDE

`Overwrite`

OVERWRITE

`PPortPrototype`

P-PORT-PROTOTYPE

`Pa`

PA

`PackageableElement`

PACKAGEABLE-ELEMENT

`ParameterAccess`

PARAMETER-ACCESS

`ParameterDataPrototype`

PARAMETER-DATA-PROTOTYPE

`ParameterInterface`

PARAMETER-INTERFACE

`ParameterSwComponentType`

PARAMETER-SW-COMPONENT-TYPE

`PartialNetwork`

PARTIAL-NETWORK

`Partition`

PARTITION

`PassThroughSwConnector`

PASS-THROUGH-SW-CONNECTOR

`Passive`

PASSIVE

`Passthrough`

PASSTHROUGH

`PayloadAsArray`

PAYLOAD-AS-ARRAY

`PayloadAsPointerToArray`

PAYLOAD-AS-POINTER-TO-ARRAY

`PcAffectsLt`

PC-AFFECTS-LT

`PcAffectsLtAndPb`

PC-AFFECTS-LT-AND-PB

`PcAffectsPb`

PC-AFFECTS-PB

`Pdf`

PDF

`Pdu`

PDU

`PduActivationRoutingGroup`

PDU-ACTIVATION-ROUTING-GROUP

`PduR`

PDU-R

`PduToFrameMapping`

PDU-TO-FRAME-MAPPING

`PduTriggering`

PDU-TRIGGERING

`PdurIPduGroup`

PDUR-I-PDU-GROUP

`Pending`

PENDING

`PerExecutable`

PER-EXECUTABLE

`PerInstanceMemory`

PER-INSTANCE-MEMORY

`PeriodicEventTriggering`

PERIODIC-EVENT-TRIGGERING

`PeriodicRateFast`

PERIODIC-RATE-FAST

`PeriodicRateMedium`

PERIODIC-RATE-MEDIUM

`PeriodicRateSlow`

PERIODIC-RATE-SLOW

`PersistencyDataElement`

PERSISTENCY-DATA-ELEMENT

`PersistencyDeployment`

PERSISTENCY-DEPLOYMENT

`PersistencyDeploymentElement`

PERSISTENCY-DEPLOYMENT-ELEMENT

`PersistencyDeploymentElementToCryptoKeySlotMapping`

PERSISTENCY-DEPLOYMENT-ELEMENT-TO-CRYPTO-KEY-SLOT-MAPPING

`PersistencyDeploymentToCryptoKeySlotMapping`

PERSISTENCY-DEPLOYMENT-TO-CRYPTO-KEY-SLOT-MAPPING

`PersistencyDeploymentToDltLogChannelMapping`

PERSISTENCY-DEPLOYMENT-TO-DLT-LOG-CHANNEL-MAPPING

`PersistencyDeploymentToDltLogSinkMapping`

PERSISTENCY-DEPLOYMENT-TO-DLT-LOG-SINK-MAPPING

`PersistencyFile`

PERSISTENCY-FILE

`PersistencyFileArray`

PERSISTENCY-FILE-ARRAY

`PersistencyFileElement`

PERSISTENCY-FILE-ELEMENT

`PersistencyFileProxy`

PERSISTENCY-FILE-PROXY

`PersistencyFileProxyInterface`

PERSISTENCY-FILE-PROXY-INTERFACE

`PersistencyFileProxyToFileMapping`

PERSISTENCY-FILE-PROXY-TO-FILE-MAPPING

`PersistencyFileStorage`

PERSISTENCY-FILE-STORAGE

`PersistencyFileStorageInterface`

PERSISTENCY-FILE-STORAGE-INTERFACE

`PersistencyInterface`

PERSISTENCY-INTERFACE

`PersistencyInterfaceElement`

PERSISTENCY-INTERFACE-ELEMENT

`PersistencyKeyValueDatabase`

PERSISTENCY-KEY-VALUE-DATABASE

`PersistencyKeyValueDatabaseInterface`

PERSISTENCY-KEY-VALUE-DATABASE-INTERFACE

`PersistencyKeyValuePair`

PERSISTENCY-KEY-VALUE-PAIR

`PersistencyKeyValueStorage`

PERSISTENCY-KEY-VALUE-STORAGE

`PersistencyKeyValueStorageInterface`

PERSISTENCY-KEY-VALUE-STORAGE-INTERFACE

`PersistencyPortPrototypeToDeploymentMapping`

PERSISTENCY-PORT-PROTOTYPE-TO-DEPLOYMENT-MAPPING

`PersistencyPortPrototypeToFileArrayMapping`

PERSISTENCY-PORT-PROTOTYPE-TO-FILE-ARRAY-MAPPING

`PersistencyPortPrototypeToFileStorageMapping`

PERSISTENCY-PORT-PROTOTYPE-TO-FILE-STORAGE-MAPPING

`PersistencyPortPrototypeToKeyValueDatabaseMapping`

PERSISTENCY-PORT-PROTOTYPE-TO-KEY-VALUE-DATABASE-MAPPING

`PersistencyPortPrototypeToKeyValueStorageMapping`

PERSISTENCY-PORT-PROTOTYPE-TO-KEY-VALUE-STORAGE-MAPPING

`PersistencyRedundancyHandlingScopeDatabase`

PERSISTENCY-REDUNDANCY-HANDLING-SCOPE-DATABASE

`PersistencyRedundancyHandlingScopeElement`

PERSISTENCY-REDUNDANCY-HANDLING-SCOPE-ELEMENT

`PersistencyRedundancyHandlingScopeFile`

PERSISTENCY-REDUNDANCY-HANDLING-SCOPE-FILE

`PersistencyRedundancyHandlingScopeKey`

PERSISTENCY-REDUNDANCY-HANDLING-SCOPE-KEY

`PersistencyRedundancyHandlingScopeStorage`

PERSISTENCY-REDUNDANCY-HANDLING-SCOPE-STORAGE

`Pgwide`

PGWIDE

`PhmAbstractRecoveryNotificationInterface`

PHM-ABSTRACT-RECOVERY-NOTIFICATION-INTERFACE

`PhmAction`

PHM-ACTION

`PhmActionItem`

PHM-ACTION-ITEM

`PhmActionList`

PHM-ACTION-LIST

`PhmArbitration`

PHM-ARBITRATION

`PhmCheckpoint`

PHM-CHECKPOINT

`PhmContributionToMachineMapping`

PHM-CONTRIBUTION-TO-MACHINE-MAPPING

`PhmHealthChannelInterface`

PHM-HEALTH-CHANNEL-INTERFACE

`PhmHealthChannelRecoveryNotificationInterface`

PHM-HEALTH-CHANNEL-RECOVERY-NOTIFICATION-INTERFACE

`PhmHealthChannelStatus`

PHM-HEALTH-CHANNEL-STATUS

`PhmLogicalExpression`

PHM-LOGICAL-EXPRESSION

`PhmRecoveryActionInterface`

PHM-RECOVERY-ACTION-INTERFACE

`PhmRule`

PHM-RULE

`PhmSupervisedEntityInterface`

PHM-SUPERVISED-ENTITY-INTERFACE

`PhmSupervision`

PHM-SUPERVISION

`PhmSupervisionRecoveryNotificationInterface`

PHM-SUPERVISION-RECOVERY-NOTIFICATION-INTERFACE

`Physical`

PHYSICAL

`PhysicalAddress`

PHYSICAL-ADDRESS

`PhysicalCanFd`

PHYSICAL-CAN-FD

`PhysicalChannel`

PHYSICAL-CHANNEL

`PhysicalDimension`

PHYSICAL-DIMENSION

`PhysicalDimensionMappingSet`

PHYSICAL-DIMENSION-MAPPING-SET

`Pl`

PL

`Plain`

PLAIN

`PlatformActionItem`

PLATFORM-ACTION-ITEM

`PlatformHealthManagementContribution`

PLATFORM-HEALTH-MANAGEMENT-CONTRIBUTION

`PlatformHealthManagementInterface`

PLATFORM-HEALTH-MANAGEMENT-INTERFACE

`PlatformModuleEndpointConfiguration`

PLATFORM-MODULE-ENDPOINT-CONFIGURATION

`PlatformModuleEthernetEndpointConfiguration`

PLATFORM-MODULE-ETHERNET-ENDPOINT-CONFIGURATION

`PlatformPhmActionItem`

PLATFORM-PHM-ACTION-ITEM

`PncMappingIdent`

PNC-MAPPING-IDENT

`Png`

PNG

`Poly`

POLY

`Port`

PORT

`PortBlueprint`

PORT-BLUEPRINT

`PortElementToCommunicationResourceMapping`

PORT-ELEMENT-TO-COMMUNICATION-RESOURCE-MAPPING

`PortGroup`

PORT-GROUP

`PortInterface`

PORT-INTERFACE

`PortInterfaceDefinition`

PORT-INTERFACE-DEFINITION

`PortInterfaceMapping`

PORT-INTERFACE-MAPPING

`PortInterfaceMappingSet`

PORT-INTERFACE-MAPPING-SET

`PortInterfaceToDataTypeMapping`

PORT-INTERFACE-TO-DATA-TYPE-MAPPING

`PortPrototype`

PORT-PROTOTYPE

`PortPrototypeBlueprint`

PORT-PROTOTYPE-BLUEPRINT

`PossibleErrorReaction`

POSSIBLE-ERROR-REACTION

`Post`

POST

`PostBuild`

POST-BUILD

`PostBuildVariantCriterion`

POST-BUILD-VARIANT-CRITERION

`PostBuildVariantCriterionValueSet`

POST-BUILD-VARIANT-CRITERION-VALUE-SET

`Power`

POWER

`PowerWindowTime`

POWER-WINDOW-TIME

`PrPortPrototype`

PR-PORT-PROTOTYPE

`PreR42`

PRE–R-4–2

`PreCompile`

PRE-COMPILE

`PreCompileTime`

PRE-COMPILE-TIME

`PreconfiguredConfiguration`

PRECONFIGURED-CONFIGURATION

`PredefinedVariant`

PREDEFINED-VARIANT

`PresentationContinuous`

PRESENTATION-CONTINUOUS

`PresentationDiscrete`

PRESENTATION-DISCRETE

`PresharedKeyIdentity`

PRESHARED-KEY-IDENTITY

`PrimaryEcu`

PRIMARY-ECU

`Primitive`

PRIMITIVE

`PrimitiveAttributeTailoring`

PRIMITIVE-ATTRIBUTE-TAILORING

`PrioOcc`

PRIO-OCC

`PrivateKey`

PRIVATE-KEY

`Process`

PROCESS

`ProcessDesign`

PROCESS-DESIGN

`ProcessDesignToMachineDesignMapping`

PROCESS-DESIGN-TO-MACHINE-DESIGN-MAPPING

`ProcessDesignToMachineDesignMappingSet`

PROCESS-DESIGN-TO-MACHINE-DESIGN-MAPPING-SET

`ProcessExecutionError`

PROCESS-EXECUTION-ERROR

`ProcessIsNotSelfTerminating`

PROCESS-IS-NOT-SELF-TERMINATING

`ProcessIsSelfTerminating`

PROCESS-IS-SELF-TERMINATING

`ProcessPhmActionItem`

PROCESS-PHM-ACTION-ITEM

`ProcessToMachineMapping`

PROCESS-TO-MACHINE-MAPPING

`ProcessToMachineMappingSet`

PROCESS-TO-MACHINE-MAPPING-SET

`ProcessingStyleAsynchronous`

PROCESSING-STYLE-ASYNCHRONOUS

`ProcessingStyleAsynchronousWithError`

PROCESSING-STYLE-ASYNCHRONOUS-WITH-ERROR

`ProcessingStyleSynchronous`

PROCESSING-STYLE-SYNCHRONOUS

`Processor`

PROCESSOR

`ProcessorCore`

PROCESSOR-CORE

`Producer`

PRODUCER

`ProtectLamp`

PROTECT-LAMP

`Protected`

PROTECTED

`ProvidedApServiceInstance`

PROVIDED-AP-SERVICE-INSTANCE

`ProvidedDdsServiceInstance`

PROVIDED-DDS-SERVICE-INSTANCE

`ProvidedServiceInstance`

PROVIDED-SERVICE-INSTANCE

`ProvidedServiceInstanceToSwClusterDesignPPortPrototypeMapping`

PROVIDED-SERVICE-INSTANCE-TO-SW-CLUSTER-DESIGN-P-PORT-PROTOTYPE-MAPPING

`ProvidedSomeipServiceInstance`

PROVIDED-SOMEIP-SERVICE-INSTANCE

`ProvidedUserDefinedServiceInstance`

PROVIDED-USER-DEFINED-SERVICE-INSTANCE

`Ps`

PS

`Psk`

PSK

`PskIdentityToKeySlotMapping`

PSK-IDENTITY-TO-KEY-SLOT-MAPPING

`Pt`

PT

`PtpIeee15882002`

PTP–IEEE-1588–2002

`PtpIeee15882008`

PTP–IEEE-1588–2008

`PublicKey`

PUBLIC-KEY

`PublishedInformation`

PUBLISHED-INFORMATION

`PureLocalTimeBase`

PURE-LOCAL-TIME-BASE

`Put`

PUT

`Qu`

QU

`Queued`

QUEUED

`R42`

R-4–2

`RPortPrototype`

R-PORT-PROTOTYPE

`RapidPrototypingScenario`

RAPID-PROTOTYPING-SCENARIO

`Raw`

RAW

`RawData`

RAW-DATA

`RawDataStreamClientInterface`

RAW-DATA-STREAM-CLIENT-INTERFACE

`RawDataStreamDeployment`

RAW-DATA-STREAM-DEPLOYMENT

`RawDataStreamGrant`

RAW-DATA-STREAM-GRANT

`RawDataStreamGrantDesign`

RAW-DATA-STREAM-GRANT-DESIGN

`RawDataStreamInterface`

RAW-DATA-STREAM-INTERFACE

`RawDataStreamMapping`

RAW-DATA-STREAM-MAPPING

`RawDataStreamMethodDeployment`

RAW-DATA-STREAM-METHOD-DEPLOYMENT

`RawDataStreamServerInterface`

RAW-DATA-STREAM-SERVER-INTERFACE

`Reaction`

REACTION

`ReadOnly`

READ-ONLY

`ReadWrite`

READ-WRITE

`Reboot`

REBOOT

`RecommendedConfiguration`

RECOMMENDED-CONFIGURATION

`RecordValueField`

RECORD-VALUE-FIELD

`RecoveryNotification`

RECOVERY-NOTIFICATION

`RecoveryNotificationToPPortPrototypeMapping`

RECOVERY-NOTIFICATION-TO-P-PORT-PROTOTYPE-MAPPING

`RecoveryViaApplicationAction`

RECOVERY-VIA-APPLICATION-ACTION

`RecoveryViaApplicationActionToClientServerOperationMapping`

RECOVERY-VIA-APPLICATION-ACTION-TO-CLIENT-SERVER-OPERATION-MAPPING

`Rect`

RECT

`RedStopLamp`

RED-STOP-LAMP

`Redundant`

REDUNDANT

`RedundantPerElement`

REDUNDANT-PER-ELEMENT

`RedundantPerKey`

REDUNDANT-PER-KEY

`RefAll`

REF-ALL

`RefNonStandard`

REF-NON-STANDARD

`RefNone`

REF-NONE

`ReferenceTailoring`

REFERENCE-TAILORING

`Referrable`

REFERRABLE

`Regular`

REGULAR

`Reject`

REJECT

`Remove`

REMOVE

`RepetitiveEoc`

REPETITIVE-EOC

`Replace`

REPLACE

`ReplaceByTimeoutSubstitutionValue`

REPLACE-BY-TIMEOUT-SUBSTITUTION-VALUE

`Report`

REPORT

`ReportAfterInit`

REPORT-AFTER-INIT

`ReportBeforeInit`

REPORT-BEFORE-INIT

`ReportDtcRecordInformationOnDtcStatusChange`

REPORT-DTC-RECORD-INFORMATION-ON-DTC-STATUS-CHANGE

`ReportMostRecentDtcOnStatusChange`

REPORT-MOST-RECENT-DTC-ON-STATUS-CHANGE

`ReportingInChronlogicalOrderOldestFirst`

REPORTING-IN-CHRONLOGICAL-ORDER-OLDEST-FIRST

`ReportsExecutionState`

REPORTS-EXECUTION-STATE

`Request`

REQUEST

`RequestCallbackTypeManufacturer`

REQUEST-CALLBACK-TYPE-MANUFACTURER

`RequestCallbackTypeSupplier`

REQUEST-CALLBACK-TYPE-SUPPLIER

`RequestNoReturn`

REQUEST-NO-RETURN

`RequiredApServiceInstance`

REQUIRED-AP-SERVICE-INSTANCE

`RequiredDdsServiceInstance`

REQUIRED-DDS-SERVICE-INSTANCE

`RequiredServiceInstanceToSwClusterDesignRPortPrototypeMapping`

REQUIRED-SERVICE-INSTANCE-TO-SW-CLUSTER-DESIGN-R-PORT-PROTOTYPE-MAPPING

`RequiredSomeipServiceInstance`

REQUIRED-SOMEIP-SERVICE-INSTANCE

`RequiredUserDefinedServiceInstance`

REQUIRED-USER-DEFINED-SERVICE-INSTANCE

`RequiresCallbackExecution`

REQUIRES-CALLBACK-EXECUTION

`ResAxis`

RES-AXIS

`ResetEcu`

RESET-ECU

`ResetMachine`

RESET-MACHINE

`ResetMcu`

RESET-MCU

`ResetVm`

RESET-VM

`ResourceConsumption`

RESOURCE-CONSUMPTION

`ResourceGroup`

RESOURCE-GROUP

`RespondAfterReset`

RESPOND-AFTER-RESET

`RespondBeforeReset`

RESPOND-BEFORE-RESET

`Response`

RESPONSE

`ResponseSynchronization`

RESPONSE-SYNCHRONIZATION

`RestAbstractEndpoint`

REST-ABSTRACT-ENDPOINT

`RestAbstractNumericalPropertyDef`

REST-ABSTRACT-NUMERICAL-PROPERTY-DEF

`RestAbstractPropertyDef`

REST-ABSTRACT-PROPERTY-DEF

`RestArrayPropertyDef`

REST-ARRAY-PROPERTY-DEF

`RestBooleanPropertyDef`

REST-BOOLEAN-PROPERTY-DEF

`RestElementDef`

REST-ELEMENT-DEF

`RestEndpointDelete`

REST-ENDPOINT-DELETE

`RestEndpointGet`

REST-ENDPOINT-GET

`RestEndpointPost`

REST-ENDPOINT-POST

`RestEndpointPut`

REST-ENDPOINT-PUT

`RestHttpPortPrototypeMapping`

REST-HTTP-PORT-PROTOTYPE-MAPPING

`RestIntegerPropertyDef`

REST-INTEGER-PROPERTY-DEF

`RestNumberPropertyDef`

REST-NUMBER-PROPERTY-DEF

`RestObjectRef`

REST-OBJECT-REF

`RestPrimitivePropertyDef`

REST-PRIMITIVE-PROPERTY-DEF

`RestResourceDef`

REST-RESOURCE-DEF

`RestServiceInterface`

REST-SERVICE-INTERFACE

`RestStringPropertyDef`

REST-STRING-PROPERTY-DEF

`Restart`

RESTART

`RestartApplication`

RESTART-APPLICATION

`Resaxis`

RES_AXIS

`ReturnOnEventCleared`

RETURN-ON-EVENT-CLEARED

`ReturnOnEventStopped`

RETURN-ON-EVENT-STOPPED

`ReturnValueProvided`

RETURN-VALUE-PROVIDED

`Right`

RIGHT

`Rm`

RM

`Rn`

RN

`Ro`

RO

`RollBack`

ROLL-BACK

`RootSwClusterDesignComponentPrototype`

ROOT-SW-CLUSTER-DESIGN-COMPONENT-PROTOTYPE

`RootSwComponentPrototype`

ROOT-SW-COMPONENT-PROTOTYPE

`RootSwCompositionPrototype`

ROOT-SW-COMPOSITION-PROTOTYPE

`Rotate180`

ROTATE-180

`Rotate180LimitToText`

ROTATE-180-LIMIT-TO-TEXT

`Rotate90Ccw`

ROTATE-90-CCW

`Rotate90CcwFitToText`

ROTATE-90-CCW-FIT-TO-TEXT

`Rotate90CcwLimitToText`

ROTATE-90-CCW-LIMIT-TO-TEXT

`Rotate90Cw`

ROTATE-90-CW

`Rotate90CwFitToText`

ROTATE-90-CW-FIT-TO-TEXT

`Rotate90CwLimitToText`

ROTATE-90-CW-LIMIT-TO-TEXT

`RoughEstimateHeapUsage`

ROUGH-ESTIMATE-HEAP-USAGE

`RoughEstimateOfExecutionTime`

ROUGH-ESTIMATE-OF-EXECUTION-TIME

`RoughEstimateStackUsage`

ROUGH-ESTIMATE-STACK-USAGE

`Router`

ROUTER

`RouterAdvertisement`

ROUTER-ADVERTISEMENT

`RptComponent`

RPT-COMPONENT

`RptContainer`

RPT-CONTAINER

`RptEnablerRam`

RPT-ENABLER-RAM

`RptEnablerRamAndRom`

RPT-ENABLER-RAM-AND-ROM

`RptEnablerRom`

RPT-ENABLER-ROM

`RptExecutableEntity`

RPT-EXECUTABLE-ENTITY

`RptExecutableEntityEvent`

RPT-EXECUTABLE-ENTITY-EVENT

`RptExecutionContext`

RPT-EXECUTION-CONTEXT

`RptLevel1`

RPT-LEVEL-1

`RptLevel2`

RPT-LEVEL-2

`RptLevel3`

RPT-LEVEL-3

`RptProfile`

RPT-PROFILE

`RptServicePoint`

RPT-SERVICE-POINT

`Rsa`

RSA

`RteEvent`

RTE-EVENT

`RteEventInCompositionSeparation`

RTE-EVENT-IN-COMPOSITION-SEPARATION

`RteEventInCompositionToOsTaskProxyMapping`

RTE-EVENT-IN-COMPOSITION-TO-OS-TASK-PROXY-MAPPING

`RteEventInSystemSeparation`

RTE-EVENT-IN-SYSTEM-SEPARATION

`RteEventInSystemToOsTaskProxyMapping`

RTE-EVENT-IN-SYSTEM-TO-OS-TASK-PROXY-MAPPING

`Rtpge`

RTPGE

`Ru`

RU

`Rule`

RULE

`RunContinuous`

RUN-CONTINUOUS

`RunOnce`

RUN-ONCE

`RunnableEntity`

RUNNABLE-ENTITY

`RunnableEntityActivated`

RUNNABLE-ENTITY-ACTIVATED

`RunnableEntityGroup`

RUNNABLE-ENTITY-GROUP

`RunnableEntityStarted`

RUNNABLE-ENTITY-STARTED

`RunnableEntityTerminated`

RUNNABLE-ENTITY-TERMINATED

`RunnableEntityVariableAccess`

RUNNABLE-ENTITY-VARIABLE-ACCESS

`RuntimeError`

RUNTIME-ERROR

`Rw`

RW

`RxTrigger`

RX-TRIGGER

`Sa`

SA

`SaeJ193973`

SAE-J-1939–73

`SaeJ2012Da`

SAE-J-2012–DA

`Safety`

SAFETY

`Saturate`

SATURATE

`ScheduleVariant1`

SCHEDULE-VARIANT-1

`ScheduleVariant2`

SCHEDULE-VARIANT-2

`ScheduleVariant3`

SCHEDULE-VARIANT-3

`ScheduleVariant4`

SCHEDULE-VARIANT-4

`ScheduleVariant5`

SCHEDULE-VARIANT-5

`ScheduleVariant6`

SCHEDULE-VARIANT-6

`ScheduleVariant7`

SCHEDULE-VARIANT-7

`Scheduled`

SCHEDULED

`Sd`

SD

`SdgAbstractForeignReference`

SDG-ABSTRACT-FOREIGN-REFERENCE

`SdgAbstractPrimitiveAttribute`

SDG-ABSTRACT-PRIMITIVE-ATTRIBUTE

`SdgAggregationWithVariation`

SDG-AGGREGATION-WITH-VARIATION

`SdgAttribute`

SDG-ATTRIBUTE

`SdgCaption`

SDG-CAPTION

`SdgClass`

SDG-CLASS

`SdgDef`

SDG-DEF

`SdgForeignReference`

SDG-FOREIGN-REFERENCE

`SdgForeignReferenceWithVariation`

SDG-FOREIGN-REFERENCE-WITH-VARIATION

`SdgPrimitiveAttribute`

SDG-PRIMITIVE-ATTRIBUTE

`SdgPrimitiveAttributeWithVariation`

SDG-PRIMITIVE-ATTRIBUTE-WITH-VARIATION

`SdgReference`

SDG-REFERENCE

`SdgTailoring`

SDG-TAILORING

`SearchForAll`

SEARCH-FOR-ALL

`SearchForAllInstances`

SEARCH-FOR-ALL-INSTANCES

`SearchForAny`

SEARCH-FOR-ANY

`SearchForId`

SEARCH-FOR-ID

`SearchForSpecificInstance`

SEARCH-FOR-SPECIFIC-INSTANCE

`SecOcCryptoServiceMapping`

SEC-OC-CRYPTO-SERVICE-MAPPING

`SecOcDeployment`

SEC-OC-DEPLOYMENT

`SecOcJobMapping`

SEC-OC-JOB-MAPPING

`SecOcJobRequirement`

SEC-OC-JOB-REQUIREMENT

`SecOcSecureComProps`

SEC-OC-SECURE-COM-PROPS

`SecondToFirst`

SECOND-TO-FIRST

`SecondaryEcu`

SECONDARY-ECU

`SecretSeed`

SECRET-SEED

`SectionNamePrefix`

SECTION-NAME-PREFIX

`SecureComProps`

SECURE-COM-PROPS

`SecureComPropsSet`

SECURE-COM-PROPS-SET

`SecureCommunicationAuthenticationProps`

SECURE-COMMUNICATION-AUTHENTICATION-PROPS

`SecureCommunicationDeployment`

SECURE-COMMUNICATION-DEPLOYMENT

`SecureCommunicationFreshnessProps`

SECURE-COMMUNICATION-FRESHNESS-PROPS

`SecureCommunicationPropsSet`

SECURE-COMMUNICATION-PROPS-SET

`SecureOnBoardCommunication`

SECURE-ON-BOARD-COMMUNICATION

`SecureOnBoardCommunicationNeeds`

SECURE-ON-BOARD-COMMUNICATION-NEEDS

`SecuredIPdu`

SECURED-I-PDU

`SecuredPduHeader08Bit`

SECURED-PDU-HEADER-08-BIT

`SecuredPduHeader16Bit`

SECURED-PDU-HEADER-16-BIT

`SecuredPduHeader32Bit`

SECURED-PDU-HEADER-32-BIT

`Security`

SECURITY

`SecurityEventAggregationFilter`

SECURITY-EVENT-AGGREGATION-FILTER

`SecurityEventContextMapping`

SECURITY-EVENT-CONTEXT-MAPPING

`SecurityEventContextMappingApplication`

SECURITY-EVENT-CONTEXT-MAPPING-APPLICATION

`SecurityEventContextMappingBswModule`

SECURITY-EVENT-CONTEXT-MAPPING-BSW-MODULE

`SecurityEventContextMappingCommConnector`

SECURITY-EVENT-CONTEXT-MAPPING-COMM-CONNECTOR

`SecurityEventContextMappingFunctionalCluster`

SECURITY-EVENT-CONTEXT-MAPPING-FUNCTIONAL-CLUSTER

`SecurityEventContextProps`

SECURITY-EVENT-CONTEXT-PROPS

`SecurityEventDefinition`

SECURITY-EVENT-DEFINITION

`SecurityEventFilterChain`

SECURITY-EVENT-FILTER-CHAIN

`SecurityEventMapping`

SECURITY-EVENT-MAPPING

`SecurityEventOneEveryNFilter`

SECURITY-EVENT-ONE-EVERY-N-FILTER

`SecurityEventReportInterface`

SECURITY-EVENT-REPORT-INTERFACE

`SecurityEventReportToSecurityEventDefinitionMapping`

SECURITY-EVENT-REPORT-TO-SECURITY-EVENT-DEFINITION-MAPPING

`SecurityEventStateFilter`

SECURITY-EVENT-STATE-FILTER

`SecurityEventThresholdFilter`

SECURITY-EVENT-THRESHOLD-FILTER

`Selected`

SELECTED

`SenderReceiverInterface`

SENDER-RECEIVER-INTERFACE

`SensorActuatorSwComponentType`

SENSOR-ACTUATOR-SW-COMPONENT-TYPE

`SentTagged`

SENT-TAGGED

`SentUntagged`

SENT-UNTAGGED

`SerializationTechnology`

SERIALIZATION-TECHNOLOGY

`Serializer`

SERIALIZER

`ServerAuthenticate`

SERVER-AUTHENTICATE

`ServerCallPoint`

SERVER-CALL-POINT

`ServerDecrypt`

SERVER-DECRYPT

`ServerEncrypt`

SERVER-ENCRYPT

`ServerMacGenerate`

SERVER-MAC-GENERATE

`ServerMacVerify`

SERVER-MAC-VERIFY

`ServerVerify`

SERVER-VERIFY

`ServiceDiscovery`

SERVICE-DISCOVERY

`ServiceEventDeployment`

SERVICE-EVENT-DEPLOYMENT

`ServiceFieldDeployment`

SERVICE-FIELD-DEPLOYMENT

`ServiceInstanceCollectionSet`

SERVICE-INSTANCE-COLLECTION-SET

`ServiceInstanceToApplicationEndpointMapping`

SERVICE-INSTANCE-TO-APPLICATION-ENDPOINT-MAPPING

`ServiceInstanceToMachineMapping`

SERVICE-INSTANCE-TO-MACHINE-MAPPING

`ServiceInstanceToPortPrototypeMapping`

SERVICE-INSTANCE-TO-PORT-PROTOTYPE-MAPPING

`ServiceInstanceToSignalMapping`

SERVICE-INSTANCE-TO-SIGNAL-MAPPING

`ServiceInstanceToSignalMappingSet`

SERVICE-INSTANCE-TO-SIGNAL-MAPPING-SET

`ServiceInstanceToSwClusterDesignPortPrototypeMapping`

SERVICE-INSTANCE-TO-SW-CLUSTER-DESIGN-PORT-PROTOTYPE-MAPPING

`ServiceInterface`

SERVICE-INTERFACE

`ServiceInterfaceApplicationErrorMapping`

SERVICE-INTERFACE-APPLICATION-ERROR-MAPPING

`ServiceInterfaceDeployment`

SERVICE-INTERFACE-DEPLOYMENT

`ServiceInterfaceElementMapping`

SERVICE-INTERFACE-ELEMENT-MAPPING

`ServiceInterfaceElementSecureComConfig`

SERVICE-INTERFACE-ELEMENT-SECURE-COM-CONFIG

`ServiceInterfaceEventMapping`

SERVICE-INTERFACE-EVENT-MAPPING

`ServiceInterfaceFieldMapping`

SERVICE-INTERFACE-FIELD-MAPPING

`ServiceInterfaceMapping`

SERVICE-INTERFACE-MAPPING

`ServiceInterfaceMappingSet`

SERVICE-INTERFACE-MAPPING-SET

`ServiceInterfaceMethodMapping`

SERVICE-INTERFACE-METHOD-MAPPING

`ServiceInterfacePedigree`

SERVICE-INTERFACE-PEDIGREE

`ServiceInterfaceTriggerMapping`

SERVICE-INTERFACE-TRIGGER-MAPPING

`ServiceMethodDeployment`

SERVICE-METHOD-DEPLOYMENT

`ServiceNeeds`

SERVICE-NEEDS

`ServiceOnly`

SERVICE-ONLY

`ServiceProxySwComponentType`

SERVICE-PROXY-SW-COMPONENT-TYPE

`ServiceSwComponentType`

SERVICE-SW-COMPONENT-TYPE

`ServiceTiming`

SERVICE-TIMING

`SessionHandlingActive`

SESSION-HANDLING-ACTIVE

`SessionHandlingInactive`

SESSION-HANDLING-INACTIVE

`Setter`

SETTER

`Sg`

SG

`Sh`

SH

`ShortHeader`

SHORT-HEADER

`ShowAliasName`

SHOW-ALIAS-NAME

`ShowCategory`

SHOW-CATEGORY

`ShowContent`

SHOW-CONTENT

`ShowLongName`

SHOW-LONG-NAME

`ShowNumber`

SHOW-NUMBER

`ShowPage`

SHOW-PAGE

`ShowSee`

SHOW-SEE

`ShowShortName`

SHOW-SHORT-NAME

`ShowType`

SHOW-TYPE

`Si`

SI

`Sides`

SIDES

`Sign`

SIGN

`SignWithOriginAuthentication`

SIGN-WITH-ORIGIN-AUTHENTICATION

`SignalBased`

SIGNAL-BASED

`SignalBasedEventDeployment`

SIGNAL-BASED-EVENT-DEPLOYMENT

`SignalBasedEventElementToISignalTriggeringMapping`

SIGNAL-BASED-EVENT-ELEMENT-TO-I-SIGNAL-TRIGGERING-MAPPING

`SignalBasedFieldDeployment`

SIGNAL-BASED-FIELD-DEPLOYMENT

`SignalBasedFieldToISignalTriggeringMapping`

SIGNAL-BASED-FIELD-TO-I-SIGNAL-TRIGGERING-MAPPING

`SignalBasedMethodDeployment`

SIGNAL-BASED-METHOD-DEPLOYMENT

`SignalBasedMethodToISignalTriggeringMapping`

SIGNAL-BASED-METHOD-TO-I-SIGNAL-TRIGGERING-MAPPING

`SignalBasedServiceInterfaceDeployment`

SIGNAL-BASED-SERVICE-INTERFACE-DEPLOYMENT

`SignalBasedTriggerToISignalTriggeringMapping`

SIGNAL-BASED-TRIGGER-TO-I-SIGNAL-TRIGGERING-MAPPING

`SignalServiceTranslationElementProps`

SIGNAL-SERVICE-TRANSLATION-ELEMENT-PROPS

`SignalServiceTranslationEventProps`

SIGNAL-SERVICE-TRANSLATION-EVENT-PROPS

`SignalServiceTranslationProps`

SIGNAL-SERVICE-TRANSLATION-PROPS

`SignalServiceTranslationPropsSet`

SIGNAL-SERVICE-TRANSLATION-PROPS-SET

`Signature`

SIGNATURE

`Silent`

SILENT

`SimulatedExecutionTime`

SIMULATED-EXECUTION-TIME

`Single`

SINGLE

`SingleCoreReentrant`

SINGLE-CORE-REENTRANT

`SingleLanguageReferrable`

SINGLE-LANGUAGE-REFERRABLE

`SingleOccurrence`

SINGLE-OCCURRENCE

`Sk`

SK

`Sl`

SL

`Slave`

SLAVE

`Sloppy`

SLOPPY

`SlowFlashingMode`

SLOW-FLASHING-MODE

`Slp`

SLP

`Sm`

SM

`Sn`

SN

`So`

SO

`SoAdRoutingGroup`

SO-AD-ROUTING-GROUP

`SoConIPduIdentifier`

SO-CON-I-PDU-IDENTIFIER

`SocketAddress`

SOCKET-ADDRESS

`SocketConnectionBundle`

SOCKET-CONNECTION-BUNDLE

`SocketConnectionIpduIdentifierSet`

SOCKET-CONNECTION-IPDU-IDENTIFIER-SET

`SoftwareActivationDependency`

SOFTWARE-ACTIVATION-DEPENDENCY

`SoftwareCluster`

SOFTWARE-CLUSTER

`SoftwareClusterDesign`

SOFTWARE-CLUSTER-DESIGN

`SoftwareClusterRequirement`

SOFTWARE-CLUSTER-REQUIREMENT

`SoftwarePackage`

SOFTWARE-PACKAGE

`SoftwarePackageStep`

SOFTWARE-PACKAGE-STEP

`Someip`

SOMEIP

`SomeipDataPrototypeTransformationProps`

SOMEIP-DATA-PROTOTYPE-TRANSFORMATION-PROPS

`SomeipEvent`

SOMEIP-EVENT

`SomeipEventDeployment`

SOMEIP-EVENT-DEPLOYMENT

`SomeipEventGroup`

SOMEIP-EVENT-GROUP

`SomeipField`

SOMEIP-FIELD

`SomeipFieldDeployment`

SOMEIP-FIELD-DEPLOYMENT

`SomeipMethod`

SOMEIP-METHOD

`SomeipMethodDeployment`

SOMEIP-METHOD-DEPLOYMENT

`SomeipProvidedEventGroup`

SOMEIP-PROVIDED-EVENT-GROUP

`SomeipRequiredEventGroup`

SOMEIP-REQUIRED-EVENT-GROUP

`SomeipSdClientEventGroupTimingConfig`

SOMEIP-SD-CLIENT-EVENT-GROUP-TIMING-CONFIG

`SomeipSdClientServiceInstanceConfig`

SOMEIP-SD-CLIENT-SERVICE-INSTANCE-CONFIG

`SomeipSdServerEventGroupTimingConfig`

SOMEIP-SD-SERVER-EVENT-GROUP-TIMING-CONFIG

`SomeipSdServerServiceInstanceConfig`

SOMEIP-SD-SERVER-SERVICE-INSTANCE-CONFIG

`SomeipServiceInstanceToMachineMapping`

SOMEIP-SERVICE-INSTANCE-TO-MACHINE-MAPPING

`SomeipServiceInterface`

SOMEIP-SERVICE-INTERFACE

`SomeipServiceInterfaceDeployment`

SOMEIP-SERVICE-INTERFACE-DEPLOYMENT

`SomeipTpChannel`

SOMEIP-TP-CHANNEL

`SomeipTpConfig`

SOMEIP-TP-CONFIG

`SomeipTransformationProps`

SOMEIP-TRANSFORMATION-PROPS

`SpecElementReference`

SPEC-ELEMENT-REFERENCE

`SpecElementScope`

SPEC-ELEMENT-SCOPE

`SpecificationDocumentScope`

SPECIFICATION-DOCUMENT-SCOPE

`SporadicEventTriggering`

SPORADIC-EVENT-TRIGGERING

`Sq`

SQ

`Sr`

SR

`Ss`

SS

`Ssdp`

SSDP

`St`

ST

`StackUsage`

STACK-USAGE

`Standard`

STANDARD

`StandardPort`

STANDARD-PORT

`Start`

START

`StartFromBeginning`

START-FROM-BEGINNING

`StartupConfig`

STARTUP-CONFIG

`StartupConfigSet`

STARTUP-CONFIG-SET

`StaticOrDynamicPartTrigger`

STATIC-OR-DYNAMIC-PART-TRIGGER

`StaticPartTrigger`

STATIC-PART-TRIGGER

`StaticSocketConnection`

STATIC-SOCKET-CONNECTION

`StatusBitAgingAndDisplacement`

STATUS-BIT-AGING-AND-DISPLACEMENT

`StatusBitNormal`

STATUS-BIT-NORMAL

`Std`

STD

`StdAxis`

STD-AXIS

`StdCppImplementationDataType`

STD-CPP-IMPLEMENTATION-DATA-TYPE

`Stdaxis`

STD_AXIS

`Steady`

STEADY

`StimulusSynchronization`

STIMULUS-SYNCHRONIZATION

`Stop`

STOP

`StopTrigger`

STOP-TRIGGER

`StoreEvent`

STORE-EVENT

`StorePersistently`

STORE-PERSISTENTLY

`StrictMode`

STRICT-MODE

`StrictMonotonous`

STRICT-MONOTONOUS

`StrictPriority`

STRICT-PRIORITY

`StrictlyDecreasing`

STRICTLY-DECREASING

`StrictlyIncreasing`

STRICTLY-INCREASING

`StructuredReq`

STRUCTURED-REQ

`Su`

SU

`SupervisedEntityCheckpointNeeds`

SUPERVISED-ENTITY-CHECKPOINT-NEEDS

`SupervisedEntityNeeds`

SUPERVISED-ENTITY-NEEDS

`SupervisionCheckpoint`

SUPERVISION-CHECKPOINT

`SupervisionEntity`

SUPERVISION-ENTITY

`SupervisionMode`

SUPERVISION-MODE

`SupervisionModeCondition`

SUPERVISION-MODE-CONDITION

`Supplier`

SUPPLIER

`SupportsBufferLocking`

SUPPORTS-BUFFER-LOCKING

`Sv`

SV

`Svg`

SVG

`Sw`

SW

`SwAddrMethod`

SW-ADDR-METHOD

`SwAxisType`

SW-AXIS-TYPE

`SwBaseType`

SW-BASE-TYPE

`SwCalibrationMethod`

SW-CALIBRATION-METHOD

`SwCalprmPrototype`

SW-CALPRM-PROTOTYPE

`SwClassAttrImpl`

SW-CLASS-ATTR-IMPL

`SwClassInstance`

SW-CLASS-INSTANCE

`SwClassPrototype`

SW-CLASS-PROTOTYPE

`SwCodeSyntax`

SW-CODE-SYNTAX

`SwComponentMappingConstraints`

SW-COMPONENT-MAPPING-CONSTRAINTS

`SwComponentPrototype`

SW-COMPONENT-PROTOTYPE

`SwComponentType`

SW-COMPONENT-TYPE

`SwConnector`

SW-CONNECTOR

`SwGenericAxisParamType`

SW-GENERIC-AXIS-PARAM-TYPE

`SwInstance`

SW-INSTANCE

`SwMcBaseType`

SW-MC-BASE-TYPE

`SwMcFrame`

SW-MC-FRAME

`SwMcInterface`

SW-MC-INTERFACE

`SwMcInterfaceSource`

SW-MC-INTERFACE-SOURCE

`SwRecordLayout`

SW-RECORD-LAYOUT

`SwServiceArg`

SW-SERVICE-ARG

`SwServicePrototype`

SW-SERVICE-PROTOTYPE

`SwSystemconst`

SW-SYSTEMCONST

`SwSystemconstantValueSet`

SW-SYSTEMCONSTANT-VALUE-SET

`SwVariablePrototype`

SW-VARIABLE-PROTOTYPE

`Swc`

SWC

`SwcBswMapping`

SWC-BSW-MAPPING

`SwcImplementation`

SWC-IMPLEMENTATION

`SwcInternalBehavior`

SWC-INTERNAL-BEHAVIOR

`SwcModeManagerErrorEvent`

SWC-MODE-MANAGER-ERROR-EVENT

`SwcModeSwitchEvent`

SWC-MODE-SWITCH-EVENT

`SwcServiceDependency`

SWC-SERVICE-DEPENDENCY

`SwcTiming`

SWC-TIMING

`SwcToApplicationPartitionMapping`

SWC-TO-APPLICATION-PARTITION-MAPPING

`SwcToEcuMapping`

SWC-TO-ECU-MAPPING

`SwcToImplMapping`

SWC-TO-IMPL-MAPPING

`Switch`

SWITCH

`SymbolProps`

SYMBOL-PROPS

`SymbolicNameProps`

SYMBOLIC-NAME-PROPS

`Symmetric`

SYMMETRIC

`SymmetricKey`

SYMMETRIC-KEY

`SyncBaseTimeManager`

SYNC-BASE-TIME-MANAGER

`SyncTimeBaseMgrUserNeeds`

SYNC-TIME-BASE-MGR-USER-NEEDS

`SynchronizationPointConstraint`

SYNCHRONIZATION-POINT-CONSTRAINT

`SynchronizationTimingConstraint`

SYNCHRONIZATION-TIMING-CONSTRAINT

`Synchronized`

SYNCHRONIZED

`SynchronizedMasterTimeBase`

SYNCHRONIZED-MASTER-TIME-BASE

`SynchronizedSlaveTimeBase`

SYNCHRONIZED-SLAVE-TIME-BASE

`SynchronizedTimeBaseConsumer`

SYNCHRONIZED-TIME-BASE-CONSUMER

`SynchronizedTimeBaseConsumerInterface`

SYNCHRONIZED-TIME-BASE-CONSUMER-INTERFACE

`SynchronizedTimeBaseProvider`

SYNCHRONIZED-TIME-BASE-PROVIDER

`SynchronizedTimeBaseProviderInterface`

SYNCHRONIZED-TIME-BASE-PROVIDER-INTERFACE

`Synchronous`

SYNCHRONOUS

`SynchronousServerCallPoint`

SYNCHRONOUS-SERVER-CALL-POINT

`System`

SYSTEM

`SystemDesignTime`

SYSTEM-DESIGN-TIME

`SystemMapping`

SYSTEM-MAPPING

`SystemMemoryUsage`

SYSTEM-MEMORY-USAGE

`SystemSignal`

SYSTEM-SIGNAL

`SystemSignalGroup`

SYSTEM-SIGNAL-GROUP

`SystemSupplierBoot`

SYSTEM-SUPPLIER-BOOT

`SystemSupplierBootRespApp`

SYSTEM-SUPPLIER-BOOT-RESP-APP

`SystemTiming`

SYSTEM-TIMING

`Ta`

TA

`TargetContainer`

TARGET-CONTAINER

`Task`

TASK

`Tc`

TC

`Tcp`

TCP

`TcpOptionFilterList`

TCP-OPTION-FILTER-LIST

`TcpOptionFilterSet`

TCP-OPTION-FILTER-SET

`TdCpSoftwareClusterMapping`

TD-CP-SOFTWARE-CLUSTER-MAPPING

`TdCpSoftwareClusterMappingSet`

TD-CP-SOFTWARE-CLUSTER-MAPPING-SET

`TdCpSoftwareClusterResourceMapping`

TD-CP-SOFTWARE-CLUSTER-RESOURCE-MAPPING

`TdEventBsw`

TD-EVENT-BSW

`TdEventBswInternalBehavior`

TD-EVENT-BSW-INTERNAL-BEHAVIOR

`TdEventBswModeDeclaration`

TD-EVENT-BSW-MODE-DECLARATION

`TdEventBswModule`

TD-EVENT-BSW-MODULE

`TdEventCom`

TD-EVENT-COM

`TdEventComplex`

TD-EVENT-COMPLEX

`TdEventCycleStart`

TD-EVENT-CYCLE-START

`TdEventFrClusterCycleStart`

TD-EVENT-FR-CLUSTER-CYCLE-START

`TdEventFrame`

TD-EVENT-FRAME

`TdEventFrameEthernet`

TD-EVENT-FRAME-ETHERNET

`TdEventIPdu`

TD-EVENT-I-PDU

`TdEventISignal`

TD-EVENT-I-SIGNAL

`TdEventModeDeclaration`

TD-EVENT-MODE-DECLARATION

`TdEventOperation`

TD-EVENT-OPERATION

`TdEventServiceInstance`

TD-EVENT-SERVICE-INSTANCE

`TdEventServiceInstanceDiscovery`

TD-EVENT-SERVICE-INSTANCE-DISCOVERY

`TdEventServiceInstanceEvent`

TD-EVENT-SERVICE-INSTANCE-EVENT

`TdEventServiceInstanceField`

TD-EVENT-SERVICE-INSTANCE-FIELD

`TdEventServiceInstanceMethod`

TD-EVENT-SERVICE-INSTANCE-METHOD

`TdEventSwc`

TD-EVENT-SWC

`TdEventSwcInternalBehavior`

TD-EVENT-SWC-INTERNAL-BEHAVIOR

`TdEventSwcInternalBehaviorReference`

TD-EVENT-SWC-INTERNAL-BEHAVIOR-REFERENCE

`TdEventTrigger`

TD-EVENT-TRIGGER

`TdEventTtCanCycleStart`

TD-EVENT-TT-CAN-CYCLE-START

`TdEventVariableDataPrototype`

TD-EVENT-VARIABLE-DATA-PROTOTYPE

`TdEventVfb`

TD-EVENT-VFB

`TdEventVfbPort`

TD-EVENT-VFB-PORT

`TdEventVfbReference`

TD-EVENT-VFB-REFERENCE

`Te`

TE

`Terminate`

TERMINATE

`TestFailed`

TEST-FAILED

`TestFailedBit`

TEST-FAILED-BIT

`TestFailedThisOperationCycle`

TEST-FAILED-THIS-OPERATION-CYCLE

`Tested`

TESTED

`TestedAndFailed`

TESTED-AND-FAILED

`Tg`

TG

`Th`

TH

`Ti`

TI

`Tiff`

TIFF

`Time`

TIME

`TimeBaseProviderToPersistencyMapping`

TIME-BASE-PROVIDER-TO-PERSISTENCY-MAPPING

`TimeBaseResource`

TIME-BASE-RESOURCE

`TimeSyncModuleInstantiation`

TIME-SYNC-MODULE-INSTANTIATION

`TimeSyncPortPrototypeToTimeBaseMapping`

TIME-SYNC-PORT-PROTOTYPE-TO-TIME-BASE-MAPPING

`TimeSyncServerConfiguration`

TIME-SYNC-SERVER-CONFIGURATION

`TimeSynchronizationInterface`

TIME-SYNCHRONIZATION-INTERFACE

`TimeSynchronizationMasterInterface`

TIME-SYNCHRONIZATION-MASTER-INTERFACE

`TimeSynchronizationPureLocalInterface`

TIME-SYNCHRONIZATION-PURE-LOCAL-INTERFACE

`TimeSynchronizationSlaveInterface`

TIME-SYNCHRONIZATION-SLAVE-INTERFACE

`TimingCondition`

TIMING-CONDITION

`TimingConstraint`

TIMING-CONSTRAINT

`TimingDescription`

TIMING-DESCRIPTION

`TimingDescriptionEvent`

TIMING-DESCRIPTION-EVENT

`TimingDescriptionEventChain`

TIMING-DESCRIPTION-EVENT-CHAIN

`TimingEvent`

TIMING-EVENT

`TimingExtension`

TIMING-EXTENSION

`TimingExtensionResource`

TIMING-EXTENSION-RESOURCE

`TimingModeInstance`

TIMING-MODE-INSTANCE

`Tip`

TIP

`Tk`

TK

`Tl`

TL

`Tls12`

TLS-12

`Tls13`

TLS-13

`TlsConnectionGroup`

TLS-CONNECTION-GROUP

`TlsCryptoCipherSuite`

TLS-CRYPTO-CIPHER-SUITE

`TlsCryptoCipherSuiteProps`

TLS-CRYPTO-CIPHER-SUITE-PROPS

`TlsCryptoServiceMapping`

TLS-CRYPTO-SERVICE-MAPPING

`TlsDeployment`

TLS-DEPLOYMENT

`TlsIamRemoteSubject`

TLS-IAM-REMOTE-SUBJECT

`TlsJobMapping`

TLS-JOB-MAPPING

`TlsJobRequirement`

TLS-JOB-REQUIREMENT

`TlsSecureComProps`

TLS-SECURE-COM-PROPS

`TlvDataIdDefinitionSet`

TLV-DATA-ID-DEFINITION-SET

`Tn`

TN

`To`

TO

`Top`

TOP

`Topbot`

TOPBOT

`Topic`

TOPIC

`Topic1`

TOPIC-1

`TopicPrefix`

TOPIC-PREFIX

`TpAddress`

TP-ADDRESS

`TpConfig`

TP-CONFIG

`TpConnectionIdent`

TP-CONNECTION-IDENT

`Tr`

TR

`Trace`

TRACE

`TraceReferrable`

TRACE-REFERRABLE

`Traceable`

TRACEABLE

`TraceableTable`

TRACEABLE-TABLE

`TraceableText`

TRACEABLE-TEXT

`TracedFailure`

TRACED-FAILURE

`Transfer`

TRANSFER

`TransformationProps`

TRANSFORMATION-PROPS

`TransformationPropsSet`

TRANSFORMATION-PROPS-SET

`TransformationPropsToServiceInterfaceElementMapping`

TRANSFORMATION-PROPS-TO-SERVICE-INTERFACE-ELEMENT-MAPPING

`TransformationPropsToServiceInterfaceElementMappingSet`

TRANSFORMATION-PROPS-TO-SERVICE-INTERFACE-ELEMENT-MAPPING-SET

`TransformationPropsToServiceInterfaceMappingSet`

TRANSFORMATION-PROPS-TO-SERVICE-INTERFACE-MAPPING-SET

`TransformationTechnology`

TRANSFORMATION-TECHNOLOGY

`TransformerErrorHandling`

TRANSFORMER-ERROR-HANDLING

`TransformerHardErrorEvent`

TRANSFORMER-HARD-ERROR-EVENT

`TransformerStatusForwarding`

TRANSFORMER-STATUS-FORWARDING

`TransformingISignal`

TRANSFORMING-I-SIGNAL

`TransientFault`

TRANSIENT-FAULT

`TranslationStart`

TRANSLATION-START

`Transport`

TRANSPORT

`TransportLayerIndependentIdCollectionSet`

TRANSPORT-LAYER-INDEPENDENT-ID-COLLECTION-SET

`TransportLayerIndependentInstanceId`

TRANSPORT-LAYER-INDEPENDENT-INSTANCE-ID

`Trap`

TRAP

`Trigger`

TRIGGER

`TriggerActivated`

TRIGGER-ACTIVATED

`TriggerInterface`

TRIGGER-INTERFACE

`TriggerInterfaceMapping`

TRIGGER-INTERFACE-MAPPING

`TriggerReleased`

TRIGGER-RELEASED

`TriggerUnicast`

TRIGGER-UNICAST

`Triggered`

TRIGGERED

`TriggeredOnChange`

TRIGGERED-ON-CHANGE

`TriggeredOnChangeWithoutRepetition`

TRIGGERED-ON-CHANGE-WITHOUT-REPETITION

`TriggeredOnEvaluation`

TRIGGERED-ON-EVALUATION

`TriggeredWithoutRepetition`

TRIGGERED-WITHOUT-REPETITION

`True`

TRUE

`Ts`

TS

`Tt`

TT

`TtcanCluster`

TTCAN-CLUSTER

`TtcanCommunicationConnector`

TTCAN-COMMUNICATION-CONNECTOR

`TtcanCommunicationController`

TTCAN-COMMUNICATION-CONTROLLER

`TtcanPhysicalChannel`

TTCAN-PHYSICAL-CHANNEL

`Tunnel`

TUNNEL

`Tw`

TW

`TxRefTrigger`

TX-REF-TRIGGER

`TxRefTriggerGap`

TX-REF-TRIGGER-GAP

`TxTriggerMerged`

TX-TRIGGER-MERGED

`TxTriggerSingle`

TX-TRIGGER-SINGLE

`Ucm`

UCM

`UcmDescription`

UCM-DESCRIPTION

`UcmMaster`

UCM-MASTER

`UcmModuleInstantiation`

UCM-MODULE-INSTANTIATION

`UcmStep`

UCM-STEP

`Udp`

UDP

`UdpChecksumDisabled`

UDP-CHECKSUM-DISABLED

`UdpChecksumEnabled`

UDP-CHECKSUM-ENABLED

`UdpNm`

UDP-NM

`UdpNmCluster`

UDP-NM-CLUSTER

`UdpNmNode`

UDP-NM-NODE

`Uds`

UDS

`Uk`

UK

`Undecided`

UNDECIDED

`Undefined`

UNDEFINED

`Unit`

UNIT

`UnitGroup`

UNIT-GROUP

`Unnumber`

UNNUMBER

`Unspecified`

UNSPECIFIED

`UpLinkPort`

UP-LINK-PORT

`Update`

UPDATE

`UploadableExclusivePackageElement`

UPLOADABLE-EXCLUSIVE-PACKAGE-ELEMENT

`UploadablePackageElement`

UPLOADABLE-PACKAGE-ELEMENT

`Ur`

UR

`UseArgumentType`

USE-ARGUMENT-TYPE

`UseArrayBaseType`

USE-ARRAY-BASE-TYPE

`UseFirstContextData`

USE-FIRST-CONTEXT-DATA

`UseLastContextData`

USE-LAST-CONTEXT-DATA

`UseVoid`

USE-VOID

`UserDefined`

USER-DEFINED

`UserDefinedCluster`

USER-DEFINED-CLUSTER

`UserDefinedCommunicationConnector`

USER-DEFINED-COMMUNICATION-CONNECTOR

`UserDefinedCommunicationController`

USER-DEFINED-COMMUNICATION-CONTROLLER

`UserDefinedEthernetFrame`

USER-DEFINED-ETHERNET-FRAME

`UserDefinedEventDeployment`

USER-DEFINED-EVENT-DEPLOYMENT

`UserDefinedFieldDeployment`

USER-DEFINED-FIELD-DEPLOYMENT

`UserDefinedGlobalTimeMaster`

USER-DEFINED-GLOBAL-TIME-MASTER

`UserDefinedGlobalTimeSlave`

USER-DEFINED-GLOBAL-TIME-SLAVE

`UserDefinedIPdu`

USER-DEFINED-I-PDU

`UserDefinedMethodDeployment`

USER-DEFINED-METHOD-DEPLOYMENT

`UserDefinedPdu`

USER-DEFINED-PDU

`UserDefinedPhysicalChannel`

USER-DEFINED-PHYSICAL-CHANNEL

`UserDefinedServiceInstanceToMachineMapping`

USER-DEFINED-SERVICE-INSTANCE-TO-MACHINE-MAPPING

`UserDefinedServiceInterfaceDeployment`

USER-DEFINED-SERVICE-INTERFACE-DEPLOYMENT

`UserDefinedTransformationProps`

USER-DEFINED-TRANSFORMATION-PROPS

`UsesLogging`

USES-LOGGING

`Uz`

UZ

`V2XActiveSupported`

V-2-X-ACTIVE-SUPPORTED

`V2XFacUserNeeds`

V-2-X-FAC-USER-NEEDS

`V2XFacilities`

V-2-X-FACILITIES

`V2XMUserNeeds`

V-2-X-M-USER-NEEDS

`V2XManagement`

V-2-X-MANAGEMENT

`V2XNotSupported`

V-2-X-NOT-SUPPORTED

`Valid`

VALID

`Var`

VAR

`VarFast`

VAR-FAST

`VarNoInit`

VAR-NO-INIT

`VarPowerOnInit`

VAR-POWER-ON-INIT

`VariableAccess`

VARIABLE-ACCESS

`VariableAndParameterInterfaceMapping`

VARIABLE-AND-PARAMETER-INTERFACE-MAPPING

`VariableDataPrototype`

VARIABLE-DATA-PROTOTYPE

`VariableDataPrototypeReceived`

VARIABLE-DATA-PROTOTYPE-RECEIVED

`VariableDataPrototypeSent`

VARIABLE-DATA-PROTOTYPE-SENT

`VariableSize`

VARIABLE-SIZE

`VariantLinkTime`

VARIANT-LINK-TIME

`VariantPostBuild`

VARIANT-POST-BUILD

`VariantPostBuildLoadable`

VARIANT-POST-BUILD-LOADABLE

`VariantPostBuildSelectable`

VARIANT-POST-BUILD-SELECTABLE

`VariantPreCompile`

VARIANT-PRE-COMPILE

`VariationPointProxy`

VARIATION-POINT-PROXY

`VehiclePackage`

VEHICLE-PACKAGE

`VehicleRolloutStep`

VEHICLE-ROLLOUT-STEP

`VendorSpecific`

VENDOR-SPECIFIC

`VendorSpecificServiceNeeds`

VENDOR-SPECIFIC-SERVICE-NEEDS

`Verbose`

VERBOSE

`Verification`

VERIFICATION

`Verify`

VERIFY

`VertexOfTargetContainer`

VERTEX-OF-TARGET-CONTAINER

`VfbTiming`

VFB-TIMING

`Vi`

VI

`ViewMap`

VIEW-MAP

`ViewMapSet`

VIEW-MAP-SET

`VlanConfig`

VLAN-CONFIG

`Vo`

VO

`Volatile`

VOLATILE

`WaitPoint`

WAIT-POINT

`WaitTimeDate`

WAIT-TIME-DATE

`Warmup`

WARMUP

`Warn`

WARN

`Warning`

WARNING

`WarningIndicatorRequestedBitNeeds`

WARNING-INDICATOR-REQUESTED-BIT-NEEDS

`WatchDogManager`

WATCH-DOG-MANAGER

`WatchTrigger`

WATCH-TRIGGER

`WatchTriggerGap`

WATCH-TRIGGER-GAP

`WatchdogActionItem`

WATCHDOG-ACTION-ITEM

`WatchdogPhmActionItem`

WATCHDOG-PHM-ACTION-ITEM

`WeightedRoundRobin`

WEIGHTED-ROUND-ROBIN

`WillCall`

WILL-CALL

`WillReceive`

WILL-RECEIVE

`WillSend`

WILL-SEND

`Wo`

WO

`WontCall`

WONT-CALL

`WontReceive`

WONT-RECEIVE

`WontSend`

WONT-SEND

`WorstCaseHeapUsage`

WORST-CASE-HEAP-USAGE

`WorstCaseStackUsage`

WORST-CASE-STACK-USAGE

`WriteOnly`

WRITE-ONLY

`WrongTrigger`

WRONG-TRIGGER

`X509`

X-509

`XMii`

X-MII

`XMmi`

X-MMI

`Xcp`

XCP

`XcpPdu`

XCP-PDU

`Xdoc`

XDOC

`Xfile`

XFILE

`XgMii`

XG-MII

`Xh`

XH

`Xor`

XOR

`XrefTarget`

XREF-TARGET

`XxgMii`

XXG-MII

`Yo`

YO

`Zh`

ZH

`Zu`

ZU

`default`

default

`preserve`

preserve

Implementations

source

impl EnumItem

source

pub fn from_bytes(input: &[u8]) -> Result<Self, ParseEnumItemError>

derive an enum entry from an input string using a perfect hash function

source

pub fn to_str(&self) -> &'static str

get the str corresponding to an item

The returned &str has static lifetime, becasue it is a reference to an entry in a list of constants

Trait Implementations

source

impl Clone for EnumItem

source

fn clone(&self) -> EnumItem

Returns a copy of the value. Read more

impl RefUnwindSafe for EnumItem

impl Send for EnumItem

impl Sync for EnumItem

impl Unpin for EnumItem

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source

impl<T> ToOwned for Twhere
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

source

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

impl<T> ToString for Twhere
T: Display + ?Sized,

source

default fn to_string(&self) -> String

Converts the given value to a String. Read more

source

impl<T, U> TryFrom for Twhere
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<T, U> TryInto for Twhere
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.