primitives.0.8.1.cdm.json

{
    "$schema": "./schema.cdm.json",
    "jsonSchemaSemanticVersion": "0.7.0",
    "definitions": [
        {
            "traitName": "is",
            "explanation": "the root 'trait' from which all others derive."
        },
        {
            "traitName": "does",
            "extendsTrait": "is",
            "explanation": "a root with a more meaningful base name for certain exhibited traits"
        },
        {
            "traitName": "means",
            "extendsTrait": "is",
            "explanation": "a root with a more meaningful base name for certain semantic meaning traits"
        },
        {
            "dataTypeName": "any",
            "explanation": "the root dataType"
        },


        {
            "traitName": "is.dataFormat",
            "extendsTrait": "is",
            "associatedProperties": [
                "dataFormat"
            ]
        },
        {
            "traitName": "is.dataFormat.integer",
            "extendsTrait": "is.dataFormat"
        },
        {
            "traitName": "is.dataFormat.big",
            "extendsTrait": "is.dataFormat"
        },
        {
            "traitName": "is.dataFormat.small",
            "extendsTrait": "is.dataFormat"
        },
        {
            "traitName": "is.dataFormat.floatingPoint",
            "extendsTrait": "is.dataFormat"
        },
        {
            "traitName": "is.dataFormat.array",
            "extendsTrait": "is.dataFormat"
        },
        {
            "traitName": "is.dataFormat.character",
            "extendsTrait": "is.dataFormat"
        },
        {
            "traitName": "is.dataFormat.byte",
            "extendsTrait": "is.dataFormat"
        },
        {
            "traitName": "is.dataFormat.numeric",
            "extendsTrait": "is.dataFormat"
        },
        {
            "traitName": "is.dataFormat.date",
            "extendsTrait": "is.dataFormat"
        },
        {
            "traitName": "is.dataFormat.time",
            "extendsTrait": "is.dataFormat"
        },
        {
            "traitName": "is.dataFormat.boolean",
            "extendsTrait": "is.dataFormat"
        },
        {
            "traitName": "is.dataFormat.guid",
            "extendsTrait": "is.dataFormat"
        },
        {
            "dataTypeName": "integer",
            "extendsDataType": "any",
            "exhibitsTraits": [
                "is.dataFormat.integer"
            ]
        },
        {
            "dataTypeName": "float",
            "extendsDataType": "any",
            "exhibitsTraits": [
                "is.dataFormat.floatingPoint"
            ]
        },
        {
            "traitName": "is.dataFormat.numeric.shaped",
            "extendsTrait": "is.dataFormat.numeric",
            "explanation": "for setting the exact precision and scale of numeric values",
            "hasParameters": [
                {
                    "name": "precision",
                    "explanation": "the total number of significant digits",
                    "dataType": "integer",
                    "direction": "both"
                },
                {
                    "name": "scale",
                    "explanation": "the number of digits to the right of the decimal place",
                    "dataType": "integer",
                    "direction": "both"
                }
            ]
        },
        {
            "dataTypeName": "decimal",
            "extendsDataType": "any",
            "exhibitsTraits": [
                "is.dataFormat.numeric.shaped"
            ]
        },
        {
            "dataTypeName": "boolean",
            "extendsDataType": "any",
            "exhibitsTraits": [
                "is.dataFormat.boolean"
            ]
        },
        {
            "dataTypeName": "char",
            "extendsDataType": "any",
            "exhibitsTraits": [
                "is.dataFormat.character",
                "is.dataFormat.big"
            ]
        },
        {
            "dataTypeName": "string",
            "extendsDataType": "char",
            "exhibitsTraits": [
                "is.dataFormat.array"
            ]
        },
        {
            "dataTypeName": "byte",
            "extendsDataType": "any",
            "exhibitsTraits": [
                "is.dataFormat.byte"
            ]
        },
        {
            "dataTypeName": "binary",
            "extendsDataType": "byte",
            "exhibitsTraits": [
                "is.dataFormat.array"
            ]
        },
        {
            "dataTypeName": "smallInteger",
            "extendsDataType": "integer",
            "exhibitsTraits": [
                "is.dataFormat.small"
            ]
        },
        {
            "dataTypeName": "bigInteger",
            "extendsDataType": "integer",
            "exhibitsTraits": [
                "is.dataFormat.big"
            ]
        },
        {
            "dataTypeName": "double",
            "extendsDataType": "float",
            "exhibitsTraits": [
                "is.dataFormat.big"
            ]
        },
        {
            "dataTypeName": "guid",
            "extendsDataType": "string",
            "exhibitsTraits": [
                "is.dataFormat.guid"
            ]
        },

        {
            "traitName": "means.identity",
            "extendsTrait": "means"
        },
        {
            "traitName": "means.identity.entityId",
            "extendsTrait": "means.identity"
        },
        {
            "dataTypeName": "entityId",
            "extendsDataType": "guid",
            "explanation": "a unique identier for entity instances",
            "exhibitsTraits": [
                "means.identity.entityId"
            ]
        },



        {
            "dataTypeName": "cdmObject",
            "extendsDataType": "any",
            "explanation": "types for trait parameters that take objects as values"
        },
        {
            "dataTypeName": "trait",
            "extendsDataType": "cdmObject",
            "explanation": "types for trait parameters that take objects as values"
        },
        {
            "dataTypeName": "dataType",
            "extendsDataType": "cdmObject",
            "explanation": "types for trait parameters that take objects as values"
        },
        {
            "dataTypeName": "relationship",
            "extendsDataType": "cdmObject",
            "explanation": "types for trait parameters that take objects as values"
        },
        {
            "dataTypeName": "entity",
            "extendsDataType": "cdmObject",
            "explanation": "types for trait parameters that take objects as values"
        },
        {
            "dataTypeName": "entityName",
            "extendsDataType": "string",
            "explanation": "type for trait parameters that take attribute names as values",
            "exhibitsTraits": [
                {
                    "traitReference": {
                        "traitName": "means.entityName",
                        "extendsTrait": "means"
                    }
                }
            ]
        },
        {
            "dataTypeName": "attribute",
            "extendsDataType": "cdmObject",
            "explanation": "types for trait parameters that take objects as values"
        },
        {
            "dataTypeName": "attributeGroup",
            "extendsDataType": "cdmObject",
            "explanation": "types for trait parameters that take objects as values"
        },
        {
            "dataTypeName": "attributeName",
            "extendsDataType": "string",
            "explanation": "type for trait parameters that take attribute names as values",
            "exhibitsTraits": [
                {
                    "traitReference": {
                        "traitName": "means.attributeName",
                        "extendsTrait": "means"
                    }
                }
            ]
        },



        {
            "traitName": "means.content",
            "extendsTrait": "means"
        },
        {
            "traitName": "means.content.text",
            "extendsTrait": "means.content"
        },
        {
            "traitName": "means.content.text.HTML",
            "extendsTrait": "means.content.text"
        },
        {
            "traitName": "means.content.text.JSON",
            "extendsTrait": "means.content.text"
        },
        {
            "traitName": "means.content.text.XML",
            "extendsTrait": "means.content.text"
        },
        {
            "traitName": "means.content.text.CSV",
            "extendsTrait": "means.content.text"
        },
        {
            "traitName": "means.content.binary",
            "extendsTrait": "means.content"
        },
        {
            "traitName": "means.content.binary.image",
            "extendsTrait": "means.content.binary"
        },
        {
            "traitName": "means.content.binary.image.BMP",
            "extendsTrait": "means.content.binary.image"
        },
        {
            "traitName": "means.content.binary.image.GIF",
            "extendsTrait": "means.content.binary.image"
        },
        {
            "traitName": "means.content.binary.image.JPG",
            "extendsTrait": "means.content.binary.image"
        },
        {
            "traitName": "means.content.binary.image.PNG",
            "extendsTrait": "means.content.binary.image"
        },
        {
            "traitName": "means.content.binary.image.TIFF",
            "extendsTrait": "means.content.binary.image"
        },
        {
            "dataTypeName": "list",
            "extendsDataType": "string",
            "explanation": "a CSV contained within one string value",
            "exhibitsTraits": [
                "means.content.text.CSV"
            ]
        },



        {
            "entityName": "object",
            "explanation": "a root entity for things"
        },
        {
            "entityName": "reference",
            "explanation": "a root entity for constant reference tables"
        },
        {
            "relationshipName": "hasA",
            "explanation": "The root relationship for associating attributes with entities."
        },
        {
            "traitName": "is.hidden",
            "explanation": "All attributes with this trait should be hidden from view of the entity consumer."
        },
        {
            "traitName": "is.secret",
            "extendsTrait": "is"
        },
        {
            "traitName": "is.required",
            "extendsTrait": "is"
        },
        {
            "traitName": "is.sensitive",
            "extendsTrait": "is"
        },


        {
            "traitName": "does.elevateAttribute",
            "explanation": "elevates (up to a entity) a trait that describes a specific attribute",
            "extendsTrait": "does",
            "elevated": true,
            "hasParameters": [
                {
                    "name": "attribute",
                    "dataType": "attribute",
                    "defaultValue": "this.attribute",
                    "required": true,
                    "direction": "both"
                }
            ]
        },
        {
            "traitName": "is.identifiedBy",
            "explanation": "names a specifc identity attribute to use with an entity",
            "extendsTrait": "does.elevateAttribute",
            "associatedProperties": [
                "primaryKey",
                "isPrimaryKey"
            ]
        },
        {
            "relationshipName": "identifiedBy",
            "extendsRelationship": "hasA",
            "exhibitsTraits": [
                "is.identifiedBy"
            ],
            "explanation": "The attribute which supplies the unique identifier for the entity. Used by default in refereneces unless a different attribute is supplied with 'is.identifiedBy' trait."
        },
        {
            "traitName": "is.named",
            "extendsTrait": "does.elevateAttribute"
        },
        {
            "relationshipName": "namedBy",
            "extendsRelationship": "hasA",
            "explanation": "The attribute which supplies the name for the entity.",
            "exhibitsTraits": [
                "is.named"
            ]
        },
        {
            "traitName": "is.ordered",
            "extendsTrait": "does.elevateAttribute"
        },
        {
            "relationshipName": "orderedBy",
            "extendsRelationship": "hasA",
            "explanation": "An attribute which determines the ordering of entity records",
            "exhibitsTraits": [
                "is.ordered"
            ]
        },
        {
            "traitName": "is.locatable",
            "extendsTrait": "does.elevateAttribute"
        },
        {
            "relationshipName": "locatedAt",
            "extendsRelationship": "hasA",
            "explanation": "An attribute which identifies the location of an entity",
            "exhibitsTraits": [
                "is.locatable"
            ]
        },


        {
            "traitName": "is.removed",
            "extendsTrait": "is",
            "modifiesAttributes": true,
            "explanation": "All attributes with this trait will be removed from the final resolved attribute list of an entity."
        },
        {
            "traitName": "does.addAttribute",
            "extendsTrait": "is",
            "modifiesAttributes": true,
            "hasParameters": [
                {
                    "name": "addedAttribute",
                    "dataType": "attribute",
                    "explanation": "an attribute definition should be passed for this argument. the attribute will be added to the entity instead of the default one.",
                    "required": true,
                    "direction": "in"
                },
                {
                    "name": "appliedTrait",
                    "dataType": "trait",
                    "explanation": "a trait definition should be passed for this argument. the attribute will be have this trait applied.",
                    "direction": "in"
                }
            ]
        },
        {
            "traitName": "is.addedInSupportOf",
            "extendsTrait": "is",
            "modifiesAttributes": true,
            "hasParameters": [
                {
                    "name": "inSupportOf",
                    "dataType": "attributeName",
                    "direction": "both",
                    "explanation": "output parameter naming the attribute that is being supported"
                }
            ]
        },
        {
            "traitName": "does.addSupportingAttribute",
            "extendsTrait": {
                "traitReference": "does.addAttribute",
                "arguments": [
                    {
                        "name": "appliedTrait",
                        "value": {
                            "traitReference": "is.addedInSupportOf"
                        }
                    }
                ]
            },
            "ugly": true
        },
        
        {
            "relationshipName": "referencesA",
            "extendsRelationship": "hasA",
            "explanation": "Indicates that an entity used as an attribute of another entity is done so by reference instead of by containment.",
            "exhibitsTraits": [
                {
                    "traitReference": {
                        "traitName": "does.referenceEntity",
                        "explanation": "turns all attributes from an entity into one key valued attribute",
                        "extendsTrait": "does.addAttribute"
                    }
                }
            ]
        },



        {
            "traitName": "is.for.attributeResolution",
            "explanation": "Base trait for traits that modify the names, inclusion, structure of the resolved attributes for an entity",
            "extendsTrait": "is",
            "modifiesAttributes": true,
            "ugly": true
        },
        {
            "traitName": "does.imposeDirectives",
            "explanation": "injects directives that control trait behavior.",
            "extendsTrait": "is.for.attributeResolution",
            "hasParameters": [
                {
                    "name": "directives",
                    "dataType": "list",
                    "explanation": "a comma separated list of directive tags to add"
                }
            ]
        },
        {
            "traitName": "does.removeDirectives",
            "explanation": "removes directives that control trait behavior.",
            "extendsTrait": "is.for.attributeResolution",
            "hasParameters": [
                {
                    "name": "directives",
                    "dataType": "list",
                    "explanation": "a comma separated list of directive tags to remove"
                }
            ]
        },
        {
            "traitName": "does.renameWithFormat",
            "explanation": "When applied, changes the name of an attribute by using a format specifier and optionally an ordinal",
            "extendsTrait": "is.for.attributeResolution",
            "ugly": false,
            "hasParameters": [
                {
                    "name": "renameFormat",
                    "dataType": "string",
                    "defaultValue": "{n}{o}",
                    "explanation": "format specifier for generated attribute names. May contain a single occurence of '{n}' and '{o}' for the base name and ordinal. examples: 'address{x}_{n}' could produce 'address2_city', '{n}{x}' gives 'city1'. Using '{N}' will uppercase the first letter of the name portion.",
                    "direction": "in"
                },
                {
                    "name": "ordinal",
                    "dataType": "integer",
                    "explanation": "if an integer value is set here, the renameFormat is applied with the value {o}=ordinal.",
                    "direction": "in"
                }
            ]
        },
        {
            "traitName": "does.disambiguateNames",
            "explanation": "renames nested entity attributes when a format is supplied and when 'structured' directive is not given",
            "extendsTrait": "does.renameWithFormat",
            "ugly": true
        },
        {
            "traitName": "does.explainArray",
            "explanation": "Used to describe the existence of and behavior for resolving an entity that is the prototype for an array of similar attributes",
            "extendsTrait": "is.for.attributeResolution",
            "hasParameters": [
                {
                    "name": "isArray",
                    "dataType": "boolean",
                    "explanation": "true if the attribute should be considered the prototype for an array of similar attributes",
                    "defaultValue": "false",
                    "direction": "in"
                },
                {
                    "name": "maximumExpansion",
                    "dataType": "integer",
                    "explanation": "the greatest number of time that the attribute pattern should be repeated if inline expansion is needed.",
                    "defaultValue": "5",
                    "direction": "in"
                },
                {
                    "name": "storeCountInAttribute",
                    "dataType": "attribute",
                    "explanation": "If an array count is needed in the entity, specifies the attribute to hold the count",
                    "defaultValue" : {
                        "name" : "arrayMemberCount",
                        "dataType" : "integer"
                    }
                },
                {
                    "name": "startingIndex",
                    "dataType": "integer",
                    "explanation": "The starting point for indexes used to expand the array",
                    "defaultValue" : "0"
                }

            ]
        },
        {
            "traitName": "does.selectAttributes",
            "explanation": "used to select either 'one' or 'all' of the attributes from an entity when it is being used as an attribute of another entity. If the 'structured' directive is set, this trait causes resolved attributes to end up in groups rather than a flattend list",
            "extendsTrait": "is.for.attributeResolution",
            "hasParameters": [
                {
                    "name": "selects",
                    "dataType": "string",
                    "explanation": "used to select either 'one' or 'all' of the attributes",
                    "defaultValue": "all",
                    "direction": "in"
                },
                {
                    "name": "storeSelectionInAttribute",
                    "dataType": "attribute",
                    "explanation": "If 'one' sub-attribute is selected per record, then the name of the selected attribute is placed in this given attribute",
                    "defaultValue" : {
                        "name" : "selectedEntity",
                        "dataType" : "entityName"
                    }
                }
            ]
        },
        {
            "traitName": "does.referenceEntityVia",
            "explanation": "If a reference is needed, this trait turns all attributes from an entity into one key valued attribute",
            "extendsTrait": "is.for.attributeResolution",
            "hasParameters": [
                {
                    "name": "foreignKeyAttribute",
                    "dataType": "attribute",
                    "explanation": "The attribute which will be added to hold a foreign key value for the referenced entity.",
                    "defaultValue" : {
                        "name" : "foreignKey",
                        "dataType" : "entityId"
                    }
                },
                {
                    "name": "alwaysAddForeignKey",
                    "dataType": "boolean",
                    "explanation": "If true, the foreign key attribute will be added to the entity even in the case where the entity is not referenced only by key.",
                    "defaultValue" : "false"
                },
                {
                    "name": "referencesOnlyAfterDepth",
                    "dataType": "integer",
                    "explanation": "After a given depth of non-reference nesting using flexible entity relationships, the 'referenceOnly' directive will be imposed",
                    "defaultValue" : "2"
                }

            ]
        },
        {
            "relationshipName": "hasFlexibleRelationshipWithEntity",
            "extendsRelationship": "hasA",
            "explanation": "Indicates that an entity used as an attribute of another entity is being done so in a way that can resolve to different attribute structures based on directives",
            "exhibitsTraits": [
                "does.disambiguateNames",
                "does.explainArray",
                "does.selectAttributes",
                "does.referenceEntityVia"
            ]
        },
        {
            "traitName": "is.linkedEntity",
            "explanation": "base for traits that are used to decorate the attributes and artifacts created by the traits on the hasFlexibleRelationshipWithEntity relationship."
        },
        {
            "traitName": "is.linkedEntity.identifier",
            "extendsTrait": "is.linkedEntity",
            "explanation": "Marks the attribute(s) that hold foreign key references to a linked (used as an attribute) entity"
        },
        {
            "traitName": "is.linkedEntity.name",
            "extendsTrait": "is.linkedEntity",
            "explanation": "Marks an attribute that contains the entity name or 'class' for the situation where one entity links to (uses as an attribute) a set of possible entities."
        },
        {
            "traitName": "is.linkedEntity.array",
            "explanation": "Identifies the case when one entity links to (uses as an attribute) an array of other entities."
        },
        {
            "traitName": "is.linkedEntity.array.count",
            "explanation": "Marks an attribute that contains the count of items in the array of linked (used as an attribute) entities"
        }

    ]
}