CIM Metaschema

// version 2.0
 
Qualifier    Abstract : boolean = false, Scope(class, Association, Indication), 
                 Flavor(DisableOverride, Restricted);

Qualifier    Aggregate : boolean = false, Scope(reference), 
                 Flavor (DisableOverride);

Qualifier    Aggregation : boolean = false, Scope(association)
                 Flavor (DisableOverride);

Qualifier    Alias : string = null, Scope(property, reference, method), 
                 Flavor(Translatable);

Qualifier    ArrayType : string = "Bag", Scope(property);

Qualifier    Association : boolean = false, Scope(class, association), 
                 Flavor(DisableOverride);

Qualifier    Delete : boolean = false, Scope(association, reference);

Qualifier    Description : string = null, Scope(any), Flavor(Translatable);

Qualifier    Expensive : boolean = false, 
                 Scope(property, reference, method, class, association);

Qualifier    Ifdeleted : boolean = false, Scope(association, reference);

Qualifier    In : boolean = true, Scope(parameter);

Qualifier    Indication : boolean = false, Scope(class, indication), 
                 Flavor(DisableOverride);

Qualifier    Invisible : boolean = false,
                 Scope(reference, association, class, property, method);

Qualifier    Key : boolean = false, Scope(property, reference), 
                 Flavor(DisableOverride);

Qualifier    Large : boolean = false, Scope(property, class);

Qualifier    MappingStrings : string[],
                 Scope(class, property, association, indication, reference);

Qualifier    Max : uint32 = null, Scope(reference);

Qualifier    MaxLen : uint32 = null, Scope(property);

Qualifier    Min : uint32 = 0, Scope(reference);

Qualifier    ModelCorrespondence : string[], Scope(property);

Qualifier    Nonlocal : string = null, Scope(reference);

Qualifier    Out : boolean = false, Scope(parameter);

Qualifier    Override : string = null, Scope(property, method, reference);

Qualifier    Propagated : string = null, Scope(property),
                 Flavor(DisableOverride);

Qualifier    Read : boolean = true, Scope(property);

Qualifier    Required : boolean = false, Scope(property);

Qualifier    Revision : string = null, Scope(schema, class, association, 
                 indication ), Flavor(Translatable);

Qualifier    Schema : string = null, Scope (property, method),
                 Flavor(DisableOverride, Translatable);

Qualifier    Source : string = null, Scope(class, association, indication);

Qualifier    Syntax : string = null, Scope(property, reference);

Qualifier    SyntaxType : string = null, Scope(property, reference);

Qualifier    TriggerType : string = null,
                 Scope(class, property, reference, method, association, 
                 indication);

Qualifier    Units : string = null, Scope(property), Flavor(Translatable);

Qualifier    ValueMap : string[], Scope(property);

Qualifier    Values : string[], Scope(property), Flavor(Translatable);

Qualifier    Version : string = null, Scope(schema, class, association, 
                 indication), Flavor(Translatable);

Qualifier    Weak : boolean = false, Scope(reference), 
                 Flavor (DisableOverride, ToSubclass);

Qualifier    Write : boolean = true, Scope(property);

class Meta_NamedElement
{
    string Name;
};
     
class Meta_QualifierFlavor: Meta_NamedElement
{
    string Type;
};
     
class Meta_Schema: Meta_NamedElement
{
};
     
class Meta_Trigger: Meta_NamedElement
{
};
     


class Meta_Qualifier: Meta_NamedElement
{
    string Value;
};
     
class Meta_Method: Meta_NamedElement
{
};
     
class Meta_Property: Meta_NamedElement
{
};
     
class Meta_Class: Meta_NamedElement
{
};
     
class Meta_Indication: Meta_Class
{
};
     
class Meta_Association: Meta_Class
{
};
     
class Meta_Reference: Meta_Property
{
};
     
        [Association] 
class Meta_Characteristics
{
    Meta_Qualifier REF Characteristic;
    Meta_NamedElement REF Characterized;
};
     
        [Association] 
class Meta_PropertyDomain
{
    Meta_Property REF Property;
    Meta_Class REF Domain;
};
     
        [Association] 
class Meta_MethodDomain
{
    Meta_Method REF Method;
    Meta_Class REF Domain;
};
     
        [Association] 
class Meta_ReferenceRange
{
    Meta_Reference REF Reference;
    Meta_Class REF Range;
};
     


        [Association] 
class Meta_QualifiersFlavor
{
    Meta_QualifierFlavor REF Flavor;
    Meta_Qualifier REF Qualifier;
};
     
        [Association] 
class Meta_SubTypeSuperType
{
    Meta_Class REF SuperClass;
    Meta_Class REF SubClass;
};
     
        [Association] 
class Meta_PropertyOverride
{
    Meta_Property REF OverridingProperty;
    Meta_Property REF OverriddenProperty;
};
     
        [Association] 
class Meta_MethodOverride
{
    Meta_Method REF OverridingMethod;
    Meta_Method REF OverriddenMethod;
};
     
        [Association] 
class Meta_ElementSchema
{
    Meta_NamedElement REF Element;
    Meta_Schema REF Schema;
};