/*
 * Copyright (C) 2017-2024 Adrien Gesta-Fline
 *
 * This file is part of libAAF.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

/**
 * @brief AAF core functions.
 * @author Adrien Gesta-Fline
 * @version 0.1
 * @date 04 october 2017
 */

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "aaf/AAFCore.h"
#include "aaf/AAFToText.h"
#include "aaf/AAFTypes.h"

#include "aaf/AAFDefs/AAFClassDefUIDs.h"
#include "aaf/AAFDefs/AAFPropertyIDs.h"
#include "aaf/AAFDefs/AAFTypeDefUIDs.h"

#include "aaf/log.h"

#include "aaf/AAFClass.h"

#define debug(...) \
	AAF_LOG (aafd->log, aafd, LOG_SRC_ID_AAF_CORE, VERB_DEBUG, __VA_ARGS__)

#define warning(...) \
	AAF_LOG (aafd->log, aafd, LOG_SRC_ID_AAF_CORE, VERB_WARNING, __VA_ARGS__)

#define error(...) \
	AAF_LOG (aafd->log, aafd, LOG_SRC_ID_AAF_CORE, VERB_ERROR, __VA_ARGS__)

#define attachNewProperty(aafd, Class, Prop, Pid, IsReq) \
	Prop = calloc (1, sizeof (aafPropertyDef));      \
	if (!Prop) {                                     \
		error ("Out of memory");                 \
		return -1;                               \
	}                                                \
	Prop->pid   = Pid;                               \
	Prop->name  = NULL;                              \
	Prop->isReq = IsReq;                             \
	Prop->meta  = 0;                                 \
	Prop->next  = Class->Properties;                 \
	memset (&Prop->type, 0x00, sizeof (aafUID_t));   \
	Class->Properties = Prop;

int
aafclass_classExists (AAF_Data* aafd, aafUID_t* ClassID)
{
	aafClass* Class = NULL;

	foreachClass (Class, aafd->Classes) if (aafUIDCmp (Class->ID, ClassID)) break;

	if (!Class)
		return 0;

	return 1;
}

/**
 * Allocates and initializes a new aafClass structure, adds it
 * to the aafd->class  list and returns a pointer to the newly
 * allocated Class.
 *
 * @param  aafd       pointer to the AAF_Data structure.
 * @param  id         pointer to the ClassID.
 * @param  isConcrete boolean to set the Class as either an ABSTRACT or a CONCRETE Class.
 * @param  parent     pointer to the parent Class.
 * @return            pointer to the newly allocated aafClass.
 */

aafClass*
aafclass_defineNewClass (AAF_Data* aafd, const aafUID_t* id, uint8_t isConcrete, aafClass* parent)
{
	aafClass* Class = malloc (sizeof (aafClass));

	if (!Class) {
		error ("Out of memory");
		return NULL;
	}

	Class->ID         = id;
	Class->Parent     = parent;
	Class->Properties = NULL;
	Class->isConcrete = isConcrete;

	Class->meta = 0;
	Class->name = NULL;

	Class->next   = aafd->Classes;
	aafd->Classes = Class;

	return Class;
}

/**
 * Retrieve an aafClass for a given ClassID.
 *
 * @param  aafd pointer to the AAF_Data structure.
 * @param  id   pointer to the ClassID to search for.
 * @return      pointer to the retrieved aafClass structure, or NULL if not found.
 */

aafClass*
aafclass_getClassByID (AAF_Data* aafd, const aafUID_t* id)
{
	aafClass* Class = NULL;

	for (Class = aafd->Classes; Class != NULL; Class = Class->next)
		if (aafUIDCmp (Class->ID, id))
			break;

	return Class;
}

aafPropertyDef*
aafclass_getPropertyDefinitionByID (aafClass* Classes, aafPID_t pid)
{
	aafClass*       Class = NULL;
	aafPropertyDef* PDef  = NULL;

	foreachClassInheritance (Class, Classes)
	    foreachPropertyDefinition (PDef, Class->Properties) if (PDef->pid == pid) return PDef;

	return NULL;
}

/**
 * Defines each Class with its properties according to
 * the standard. All the Classes are then hold by the
 * AAF_Data.Class list.
 *
 * We define the Classes at runtime, so we can later
 * add any custom class defined in the MetaDictionary.
 * This is not yet implemented though.
 *
 * @param aafd The AAF_Data struct pointer.
 */
int
aafclass_setDefaultClasses (AAF_Data* aafd)
{
	aafPropertyDef* prop = NULL;

	aafClass* IOC = aafclass_defineNewClass (aafd, &AAFClassID_InterchangeObject, ABSTRACT, NULL);

	if (IOC == NULL) {
		return -1;
	}

	attachNewProperty (aafd, IOC, prop, PID_InterchangeObject_ObjClass, PROP_REQ);
	attachNewProperty (aafd, IOC, prop, PID_InterchangeObject_Generation, PROP_OPT);

	aafClass* Root = aafclass_defineNewClass (aafd, &AAFClassID_Root, CONCRETE, IOC);

	if (Root == NULL) {
		return -1;
	}

	attachNewProperty (aafd, Root, prop, PID_Root_MetaDictionary, PROP_REQ);
	attachNewProperty (aafd, Root, prop, PID_Root_Header, PROP_REQ);

	aafClass* Header = aafclass_defineNewClass (aafd, &AAFClassID_Header, CONCRETE, IOC);

	if (Header == NULL) {
		return -1;
	}

	attachNewProperty (aafd, Header, prop, PID_Header_ByteOrder, PROP_REQ);
	attachNewProperty (aafd, Header, prop, PID_Header_LastModified, PROP_REQ);
	attachNewProperty (aafd, Header, prop, PID_Header_Version, PROP_REQ);
	attachNewProperty (aafd, Header, prop, PID_Header_Content, PROP_REQ);
	attachNewProperty (aafd, Header, prop, PID_Header_Dictionary, PROP_REQ);
	attachNewProperty (aafd, Header, prop, PID_Header_IdentificationList, PROP_REQ);
	attachNewProperty (aafd, Header, prop, PID_Header_ObjectModelVersion, PROP_OPT);
	attachNewProperty (aafd, Header, prop, PID_Header_OperationalPattern, PROP_OPT);
	attachNewProperty (aafd, Header, prop, PID_Header_EssenceContainers, PROP_OPT);
	attachNewProperty (aafd, Header, prop, PID_Header_DescriptiveSchemes, PROP_OPT);

	aafClass* Identif = aafclass_defineNewClass (aafd, &AAFClassID_Identification, CONCRETE, IOC);

	if (Identif == NULL) {
		return -1;
	}

	attachNewProperty (aafd, Identif, prop, PID_Identification_CompanyName, PROP_REQ);
	attachNewProperty (aafd, Identif, prop, PID_Identification_ProductName, PROP_REQ);
	attachNewProperty (aafd, Identif, prop, PID_Identification_ProductVersion, PROP_OPT);
	attachNewProperty (aafd, Identif, prop, PID_Identification_ProductVersionString, PROP_REQ);
	attachNewProperty (aafd, Identif, prop, PID_Identification_ProductID, PROP_REQ);
	attachNewProperty (aafd, Identif, prop, PID_Identification_Date, PROP_REQ);
	attachNewProperty (aafd, Identif, prop, PID_Identification_ToolkitVersion, PROP_OPT);
	attachNewProperty (aafd, Identif, prop, PID_Identification_Platform, PROP_OPT);
	attachNewProperty (aafd, Identif, prop, PID_Identification_GenerationAUID, PROP_REQ);

	aafClass* Dictionary = aafclass_defineNewClass (aafd, &AAFClassID_Dictionary, CONCRETE, IOC);

	if (Dictionary == NULL) {
		return -1;
	}

	attachNewProperty (aafd, Dictionary, prop, PID_Dictionary_OperationDefinitions, PROP_OPT);
	attachNewProperty (aafd, Dictionary, prop, PID_Dictionary_ParameterDefinitions, PROP_OPT);
	attachNewProperty (aafd, Dictionary, prop, PID_Dictionary_DataDefinitions, PROP_OPT);
	attachNewProperty (aafd, Dictionary, prop, PID_Dictionary_PluginDefinitions, PROP_OPT);
	attachNewProperty (aafd, Dictionary, prop, PID_Dictionary_CodecDefinitions, PROP_OPT);
	attachNewProperty (aafd, Dictionary, prop, PID_Dictionary_ContainerDefinitions, PROP_OPT);
	attachNewProperty (aafd, Dictionary, prop, PID_Dictionary_InterpolationDefinitions, PROP_OPT);
	attachNewProperty (aafd, Dictionary, prop, PID_Dictionary_KLVDataDefinitions, PROP_OPT);
	attachNewProperty (aafd, Dictionary, prop, PID_Dictionary_TaggedValueDefinitions, PROP_OPT);

	aafClass* Content = aafclass_defineNewClass (aafd, &AAFClassID_ContentStorage, CONCRETE, IOC);

	if (Content == NULL) {
		return -1;
	}

	attachNewProperty (aafd, Content, prop, PID_ContentStorage_Mobs, PROP_REQ);
	attachNewProperty (aafd, Content, prop, PID_ContentStorage_EssenceData, PROP_REQ);

	aafClass* Mob = aafclass_defineNewClass (aafd, &AAFClassID_Mob, ABSTRACT, IOC);

	if (Mob == NULL) {
		return -1;
	}

	attachNewProperty (aafd, Mob, prop, PID_Mob_MobID, PROP_REQ);
	attachNewProperty (aafd, Mob, prop, PID_Mob_Name, PROP_OPT);
	attachNewProperty (aafd, Mob, prop, PID_Mob_Slots, PROP_REQ);
	attachNewProperty (aafd, Mob, prop, PID_Mob_LastModified, PROP_REQ);
	attachNewProperty (aafd, Mob, prop, PID_Mob_CreationTime, PROP_REQ);
	attachNewProperty (aafd, Mob, prop, PID_Mob_UserComments, PROP_OPT);
	attachNewProperty (aafd, Mob, prop, PID_Mob_Attributes, PROP_OPT);
	attachNewProperty (aafd, Mob, prop, PID_Mob_KLVData, PROP_OPT);
	attachNewProperty (aafd, Mob, prop, PID_Mob_UsageCode, PROP_OPT);

	aafClass* CompoMob = aafclass_defineNewClass (aafd, &AAFClassID_CompositionMob, CONCRETE, Mob);

	if (CompoMob == NULL) {
		return -1;
	}

	attachNewProperty (aafd, CompoMob, prop, PID_CompositionMob_DefaultFadeLength, PROP_OPT);
	attachNewProperty (aafd, CompoMob, prop, PID_CompositionMob_DefFadeType, PROP_OPT);
	attachNewProperty (aafd, CompoMob, prop, PID_CompositionMob_DefFadeEditUnit, PROP_OPT);
	attachNewProperty (aafd, CompoMob, prop, PID_CompositionMob_Rendering, PROP_OPT);

	aafClass* MasterMob = aafclass_defineNewClass (aafd, &AAFClassID_MasterMob, CONCRETE, Mob);

	if (MasterMob == NULL) {
		return -1;
	}

	/* The MasterMob class does not define any additional properties. */

	aafClass* SourceMob = aafclass_defineNewClass (aafd, &AAFClassID_SourceMob, CONCRETE, Mob);

	if (SourceMob == NULL) {
		return -1;
	}

	attachNewProperty (aafd, SourceMob, prop, PID_SourceMob_EssenceDescription, PROP_REQ);

	aafClass* MobSlot = aafclass_defineNewClass (aafd, &AAFClassID_MobSlot, ABSTRACT, IOC);

	if (MobSlot == NULL) {
		return -1;
	}

	attachNewProperty (aafd, MobSlot, prop, PID_MobSlot_SlotID, PROP_REQ);
	attachNewProperty (aafd, MobSlot, prop, PID_MobSlot_SlotName, PROP_OPT);
	attachNewProperty (aafd, MobSlot, prop, PID_MobSlot_PhysicalTrackNumber, PROP_OPT);
	attachNewProperty (aafd, MobSlot, prop, PID_MobSlot_Segment, PROP_REQ);

	aafClass* TimelineMobSlot = aafclass_defineNewClass (aafd, &AAFClassID_TimelineMobSlot, CONCRETE, MobSlot);

	if (TimelineMobSlot == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TimelineMobSlot, prop, PID_TimelineMobSlot_EditRate, PROP_REQ);
	attachNewProperty (aafd, TimelineMobSlot, prop, PID_TimelineMobSlot_Origin, PROP_REQ);
	attachNewProperty (aafd, TimelineMobSlot, prop, PID_TimelineMobSlot_MarkIn, PROP_OPT);
	attachNewProperty (aafd, TimelineMobSlot, prop, PID_TimelineMobSlot_MarkOut, PROP_OPT);
	attachNewProperty (aafd, TimelineMobSlot, prop, PID_TimelineMobSlot_UserPos, PROP_OPT);

	aafClass* EventMobSlot = aafclass_defineNewClass (aafd, &AAFClassID_EventMobSlot, CONCRETE, MobSlot);

	if (EventMobSlot == NULL) {
		return -1;
	}

	attachNewProperty (aafd, EventMobSlot, prop, PID_EventMobSlot_EditRate, PROP_REQ);
	//	attachNewProperty( aafd, EventMobSlot,     prop, PID_EventMobSlot_EventSlotOrigin,                  ??? );

	aafClass* StaticMobSlot = aafclass_defineNewClass (aafd, &AAFClassID_StaticMobSlot, CONCRETE, MobSlot);

	if (StaticMobSlot == NULL) {
		return -1;
	}

	/* The StaticMobSlot class does not define any additional properties. */

	aafClass* KLVData = aafclass_defineNewClass (aafd, &AAFClassID_KLVData, CONCRETE, IOC);

	if (KLVData == NULL) {
		return -1;
	}

	attachNewProperty (aafd, KLVData, prop, PID_KLVData_Value, PROP_REQ);

	aafClass* TaggedValue = aafclass_defineNewClass (aafd, &AAFClassID_TaggedValue, CONCRETE, IOC);

	if (TaggedValue == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TaggedValue, prop, PID_TaggedValue_Name, PROP_REQ);
	attachNewProperty (aafd, TaggedValue, prop, PID_TaggedValue_Value, PROP_REQ);

	aafClass* Parameter = aafclass_defineNewClass (aafd, &AAFClassID_Parameter, ABSTRACT, IOC);

	if (Parameter == NULL) {
		return -1;
	}

	attachNewProperty (aafd, Parameter, prop, PID_Parameter_Definition, PROP_REQ);

	aafClass* ConstantValue = aafclass_defineNewClass (aafd, &AAFClassID_ConstantValue, CONCRETE, Parameter);

	if (ConstantValue == NULL) {
		return -1;
	}

	attachNewProperty (aafd, ConstantValue, prop, PID_ConstantValue_Value, PROP_REQ);

	aafClass* VaryingValue = aafclass_defineNewClass (aafd, &AAFClassID_VaryingValue, CONCRETE, Parameter);

	if (VaryingValue == NULL) {
		return -1;
	}

	attachNewProperty (aafd, VaryingValue, prop, PID_VaryingValue_Interpolation, PROP_REQ);
	attachNewProperty (aafd, VaryingValue, prop, PID_VaryingValue_PointList, PROP_REQ);

	aafClass* ControlPoint = aafclass_defineNewClass (aafd, &AAFClassID_ControlPoint, CONCRETE, IOC);

	if (ControlPoint == NULL) {
		return -1;
	}

	attachNewProperty (aafd, ControlPoint, prop, PID_ControlPoint_Value, PROP_REQ);
	attachNewProperty (aafd, ControlPoint, prop, PID_ControlPoint_Time, PROP_REQ);
	attachNewProperty (aafd, ControlPoint, prop, PID_ControlPoint_EditHint, PROP_OPT);

	aafClass* Locator = aafclass_defineNewClass (aafd, &AAFClassID_Locator, ABSTRACT, IOC);

	if (Locator == NULL) {
		return -1;
	}

	/* The Locator class does not define any additional properties. */

	aafClass* NetworkLocator = aafclass_defineNewClass (aafd, &AAFClassID_NetworkLocator, CONCRETE, Locator);

	if (NetworkLocator == NULL) {
		return -1;
	}

	attachNewProperty (aafd, NetworkLocator, prop, PID_NetworkLocator_URLString, PROP_REQ);

	aafClass* TextLocator = aafclass_defineNewClass (aafd, &AAFClassID_TextLocator, CONCRETE, Locator);

	if (TextLocator == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TextLocator, prop, PID_TextLocator_Name, PROP_REQ);

	aafClass* Component = aafclass_defineNewClass (aafd, &AAFClassID_Component, ABSTRACT, IOC);

	if (Component == NULL) {
		return -1;
	}

	attachNewProperty (aafd, Component, prop, PID_Component_DataDefinition, PROP_REQ);
	attachNewProperty (aafd, Component, prop, PID_Component_Length, PROP_OPT);
	attachNewProperty (aafd, Component, prop, PID_Component_KLVData, PROP_OPT);
	attachNewProperty (aafd, Component, prop, PID_Component_UserComments, PROP_OPT);
	attachNewProperty (aafd, Component, prop, PID_Component_Attributes, PROP_OPT);

	aafClass* Transition = aafclass_defineNewClass (aafd, &AAFClassID_Transition, CONCRETE, Component);

	if (Transition == NULL) {
		return -1;
	}

	attachNewProperty (aafd, Transition, prop, PID_Transition_OperationGroup, PROP_REQ);
	attachNewProperty (aafd, Transition, prop, PID_Transition_CutPoint, PROP_REQ);

	aafClass* Segment = aafclass_defineNewClass (aafd, &AAFClassID_Segment, ABSTRACT, Component);

	if (Segment == NULL) {
		return -1;
	}

	/* The Segment class does not define any additional properties. */

	aafClass* Sequence = aafclass_defineNewClass (aafd, &AAFClassID_Sequence, CONCRETE, Segment);

	if (Sequence == NULL) {
		return -1;
	}

	attachNewProperty (aafd, Sequence, prop, PID_Sequence_Components, PROP_REQ);

	aafClass* Filler = aafclass_defineNewClass (aafd, &AAFClassID_Filler, CONCRETE, Segment);

	if (Filler == NULL) {
		return -1;
	}

	/* The Filler class does not define any additional properties. */

	aafClass* SourceRef = aafclass_defineNewClass (aafd, &AAFClassID_SourceReference, ABSTRACT, Segment);

	if (SourceRef == NULL) {
		return -1;
	}

	attachNewProperty (aafd, SourceRef, prop, PID_SourceReference_SourceID, PROP_OPT);
	attachNewProperty (aafd, SourceRef, prop, PID_SourceReference_SourceMobSlotID, PROP_REQ);
	attachNewProperty (aafd, SourceRef, prop, PID_SourceReference_ChannelIDs, PROP_OPT);
	attachNewProperty (aafd, SourceRef, prop, PID_SourceReference_MonoSourceSlotIDs, PROP_OPT);

	aafClass* SourceClip = aafclass_defineNewClass (aafd, &AAFClassID_SourceClip, CONCRETE, SourceRef);

	if (SourceClip == NULL) {
		return -1;
	}

	attachNewProperty (aafd, SourceClip, prop, PID_SourceClip_StartTime, PROP_OPT);
	attachNewProperty (aafd, SourceClip, prop, PID_SourceClip_FadeInLength, PROP_OPT);
	attachNewProperty (aafd, SourceClip, prop, PID_SourceClip_FadeInType, PROP_OPT);
	attachNewProperty (aafd, SourceClip, prop, PID_SourceClip_FadeOutLength, PROP_OPT);
	attachNewProperty (aafd, SourceClip, prop, PID_SourceClip_FadeOutType, PROP_OPT);

	aafClass* Event = aafclass_defineNewClass (aafd, &AAFClassID_Event, ABSTRACT, Segment);

	if (Event == NULL) {
		return -1;
	}

	attachNewProperty (aafd, Event, prop, PID_Event_Position, PROP_REQ);
	attachNewProperty (aafd, Event, prop, PID_Event_Comment, PROP_OPT);

	aafClass* CommentMarker = aafclass_defineNewClass (aafd, &AAFClassID_CommentMarker, CONCRETE, Event);

	if (CommentMarker == NULL) {
		return -1;
	}

	attachNewProperty (aafd, CommentMarker, prop, PID_CommentMarker_Annotation, PROP_OPT);

	aafClass* DescriptiveMarker = aafclass_defineNewClass (aafd, &AAFClassID_DescriptiveMarker, CONCRETE, CommentMarker);

	if (DescriptiveMarker == NULL) {
		return -1;
	}

	attachNewProperty (aafd, DescriptiveMarker, prop, PID_DescriptiveMarker_DescribedSlots, PROP_OPT);
	attachNewProperty (aafd, DescriptiveMarker, prop, PID_DescriptiveMarker_Description, PROP_OPT);

	aafClass* GPITrigger = aafclass_defineNewClass (aafd, &AAFClassID_GPITrigger, CONCRETE, Event);

	if (GPITrigger == NULL) {
		return -1;
	}

	attachNewProperty (aafd, GPITrigger, prop, PID_GPITrigger_ActiveState, PROP_REQ);

	aafClass* Timecode = aafclass_defineNewClass (aafd, &AAFClassID_Timecode, CONCRETE, Segment);

	if (Timecode == NULL) {
		return -1;
	}

	attachNewProperty (aafd, Timecode, prop, PID_Timecode_Start, PROP_REQ);
	attachNewProperty (aafd, Timecode, prop, PID_Timecode_FPS, PROP_REQ);
	attachNewProperty (aafd, Timecode, prop, PID_Timecode_Drop, PROP_REQ);

	aafClass* TCStream = aafclass_defineNewClass (aafd, &AAFClassID_TimecodeStream, ABSTRACT, Segment);

	if (TCStream == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TCStream, prop, PID_TimecodeStream_SampleRate, PROP_REQ);
	attachNewProperty (aafd, TCStream, prop, PID_TimecodeStream_Source, PROP_REQ);
	attachNewProperty (aafd, TCStream, prop, PID_TimecodeStream_SourceType, PROP_REQ);

	aafClass* TCStream12M = aafclass_defineNewClass (aafd, &AAFClassID_TimecodeStream12M, CONCRETE, TCStream);

	if (TCStream12M == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TCStream12M, prop, PID_TimecodeStream12M_IncludeSync, PROP_OPT);

	aafClass* Edgecode = aafclass_defineNewClass (aafd, &AAFClassID_Edgecode, CONCRETE, Segment);

	if (Edgecode == NULL) {
		return -1;
	}

	attachNewProperty (aafd, Edgecode, prop, PID_EdgeCode_Start, PROP_REQ);
	attachNewProperty (aafd, Edgecode, prop, PID_EdgeCode_FilmKind, PROP_REQ);
	attachNewProperty (aafd, Edgecode, prop, PID_EdgeCode_CodeFormat, PROP_REQ);
	attachNewProperty (aafd, Edgecode, prop, PID_EdgeCode_Header, PROP_OPT);

	aafClass* Pulldown = aafclass_defineNewClass (aafd, &AAFClassID_Pulldown, CONCRETE, Segment);

	if (Pulldown == NULL) {
		return -1;
	}

	attachNewProperty (aafd, Pulldown, prop, PID_Pulldown_InputSegment, PROP_REQ);
	attachNewProperty (aafd, Pulldown, prop, PID_Pulldown_PulldownKind, PROP_REQ);
	attachNewProperty (aafd, Pulldown, prop, PID_Pulldown_PulldownDirection, PROP_REQ);
	attachNewProperty (aafd, Pulldown, prop, PID_Pulldown_PhaseFrame, PROP_REQ);

	aafClass* OperationGroup = aafclass_defineNewClass (aafd, &AAFClassID_OperationGroup, CONCRETE, Segment);

	if (OperationGroup == NULL) {
		return -1;
	}

	attachNewProperty (aafd, OperationGroup, prop, PID_OperationGroup_Operation, PROP_REQ);
	attachNewProperty (aafd, OperationGroup, prop, PID_OperationGroup_InputSegments, PROP_OPT);
	attachNewProperty (aafd, OperationGroup, prop, PID_OperationGroup_Parameters, PROP_OPT);
	attachNewProperty (aafd, OperationGroup, prop, PID_OperationGroup_Rendering, PROP_OPT);
	attachNewProperty (aafd, OperationGroup, prop, PID_OperationGroup_BypassOverride, PROP_OPT);

	aafClass* NestedScope = aafclass_defineNewClass (aafd, &AAFClassID_NestedScope, CONCRETE, Segment);

	if (NestedScope == NULL) {
		return -1;
	}

	attachNewProperty (aafd, NestedScope, prop, PID_NestedScope_Slots, PROP_REQ);

	aafClass* ScopeReference = aafclass_defineNewClass (aafd, &AAFClassID_ScopeReference, CONCRETE, Segment);

	if (ScopeReference == NULL) {
		return -1;
	}

	attachNewProperty (aafd, ScopeReference, prop, PID_ScopeReference_RelativeScope, PROP_REQ);
	attachNewProperty (aafd, ScopeReference, prop, PID_ScopeReference_RelativeSlot, PROP_REQ);

	aafClass* Selector = aafclass_defineNewClass (aafd, &AAFClassID_Selector, CONCRETE, Segment);

	if (Selector == NULL) {
		return -1;
	}

	attachNewProperty (aafd, Selector, prop, PID_Selector_Selected, PROP_REQ);
	attachNewProperty (aafd, Selector, prop, PID_Selector_Alternates, PROP_OPT);

	aafClass* EssenceGroup = aafclass_defineNewClass (aafd, &AAFClassID_EssenceGroup, CONCRETE, Segment);

	if (EssenceGroup == NULL) {
		return -1;
	}

	attachNewProperty (aafd, EssenceGroup, prop, PID_EssenceGroup_Choices, PROP_REQ);
	attachNewProperty (aafd, EssenceGroup, prop, PID_EssenceGroup_StillFrame, PROP_OPT);

	aafClass* DescriptiveFramework = aafclass_defineNewClass (aafd, &AAFClassID_DescriptiveFramework, ABSTRACT, IOC);

	if (DescriptiveFramework == NULL) {
		return -1;
	}

	aafClass* EssenceDesc = aafclass_defineNewClass (aafd, &AAFClassID_EssenceDescriptor, ABSTRACT, IOC);

	if (EssenceDesc == NULL) {
		return -1;
	}

	attachNewProperty (aafd, EssenceDesc, prop, PID_EssenceDescriptor_Locator, PROP_OPT);

	aafClass* FileDesc = aafclass_defineNewClass (aafd, &AAFClassID_FileDescriptor, ABSTRACT, EssenceDesc);

	if (FileDesc == NULL) {
		return -1;
	}

	attachNewProperty (aafd, FileDesc, prop, PID_FileDescriptor_SampleRate, PROP_REQ);
	attachNewProperty (aafd, FileDesc, prop, PID_FileDescriptor_Length, PROP_REQ);
	attachNewProperty (aafd, FileDesc, prop, PID_FileDescriptor_ContainerFormat, PROP_OPT);
	attachNewProperty (aafd, FileDesc, prop, PID_FileDescriptor_CodecDefinition, PROP_OPT);
	//	attachNewProperty( aafd, FileDesc,         prop, PID_FileDescriptor_LinkedSlotID,                           ??? );

	aafClass* DigitalImageDesc = aafclass_defineNewClass (aafd, &AAFClassID_DigitalImageDescriptor, ABSTRACT, FileDesc);

	if (DigitalImageDesc == NULL) {
		return -1;
	}

	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_Compression, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_StoredHeight, PROP_REQ);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_StoredWidth, PROP_REQ);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_StoredF2Offset, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_SampledHeight, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_SampledWidth, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_SampledXOffset, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_SampledYOffset, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_DisplayHeight, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_DisplayWidth, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_DisplayXOffset, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_DisplayYOffset, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_DisplayF2Offset, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_FrameLayout, PROP_REQ);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_VideoLineMap, PROP_REQ);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_ImageAspectRatio, PROP_REQ);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_ActiveFormatDescriptor, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_AlphaTransparency, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_ImageAlignmentFactor, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_FieldDominance, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_FieldStartOffset, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_FieldEndOffset, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_ColorPrimaries, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_CodingEquations, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_TransferCharacteristic, PROP_OPT);
	attachNewProperty (aafd, DigitalImageDesc, prop, PID_DigitalImageDescriptor_SignalStandard, PROP_OPT);

	aafClass* CDCIDesc = aafclass_defineNewClass (aafd, &AAFClassID_CDCIDescriptor, CONCRETE, DigitalImageDesc);

	if (CDCIDesc == NULL) {
		return -1;
	}

	attachNewProperty (aafd, CDCIDesc, prop, PID_CDCIDescriptor_HorizontalSubsampling, PROP_REQ);
	attachNewProperty (aafd, CDCIDesc, prop, PID_CDCIDescriptor_VerticalSubsampling, PROP_OPT);
	attachNewProperty (aafd, CDCIDesc, prop, PID_CDCIDescriptor_ComponentWidth, PROP_REQ);
	attachNewProperty (aafd, CDCIDesc, prop, PID_CDCIDescriptor_AlphaSamplingWidth, PROP_OPT);
	attachNewProperty (aafd, CDCIDesc, prop, PID_CDCIDescriptor_PaddingBits, PROP_OPT);
	attachNewProperty (aafd, CDCIDesc, prop, PID_CDCIDescriptor_ColorSiting, PROP_OPT);
	attachNewProperty (aafd, CDCIDesc, prop, PID_CDCIDescriptor_BlackReferenceLevel, PROP_OPT);
	attachNewProperty (aafd, CDCIDesc, prop, PID_CDCIDescriptor_WhiteReferenceLevel, PROP_OPT);
	attachNewProperty (aafd, CDCIDesc, prop, PID_CDCIDescriptor_ColorRange, PROP_OPT);
	attachNewProperty (aafd, CDCIDesc, prop, PID_CDCIDescriptor_ReversedByteOrder, PROP_OPT);

	aafClass* RGBADesc = aafclass_defineNewClass (aafd, &AAFClassID_RGBADescriptor, CONCRETE, DigitalImageDesc);

	if (RGBADesc == NULL) {
		return -1;
	}

	attachNewProperty (aafd, RGBADesc, prop, PID_RGBADescriptor_PixelLayout, PROP_REQ);
	attachNewProperty (aafd, RGBADesc, prop, PID_RGBADescriptor_Palette, PROP_OPT);
	attachNewProperty (aafd, RGBADesc, prop, PID_RGBADescriptor_PaletteLayout, PROP_OPT);
	attachNewProperty (aafd, RGBADesc, prop, PID_RGBADescriptor_ComponentMinRef, PROP_OPT);
	attachNewProperty (aafd, RGBADesc, prop, PID_RGBADescriptor_ComponentMaxRef, PROP_OPT);
	attachNewProperty (aafd, RGBADesc, prop, PID_RGBADescriptor_AlphaMinRef, PROP_OPT);
	attachNewProperty (aafd, RGBADesc, prop, PID_RGBADescriptor_AlphaMaxRef, PROP_OPT);
	attachNewProperty (aafd, RGBADesc, prop, PID_RGBADescriptor_ScanningDirection, PROP_OPT);

	aafClass* TapeDesc = aafclass_defineNewClass (aafd, &AAFClassID_TapeDescriptor, CONCRETE, EssenceDesc);

	if (TapeDesc == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TapeDesc, prop, PID_TapeDescriptor_FormFactor, PROP_OPT);
	attachNewProperty (aafd, TapeDesc, prop, PID_TapeDescriptor_VideoSignal, PROP_OPT);
	attachNewProperty (aafd, TapeDesc, prop, PID_TapeDescriptor_TapeFormat, PROP_OPT);
	attachNewProperty (aafd, TapeDesc, prop, PID_TapeDescriptor_Length, PROP_OPT);
	attachNewProperty (aafd, TapeDesc, prop, PID_TapeDescriptor_ManufacturerID, PROP_OPT);
	attachNewProperty (aafd, TapeDesc, prop, PID_TapeDescriptor_Model, PROP_OPT);
	attachNewProperty (aafd, TapeDesc, prop, PID_TapeDescriptor_TapeBatchNumber, PROP_OPT);
	attachNewProperty (aafd, TapeDesc, prop, PID_TapeDescriptor_TapeStock, PROP_OPT);

	aafClass* FilmDesc = aafclass_defineNewClass (aafd, &AAFClassID_FilmDescriptor, CONCRETE, EssenceDesc);

	if (FilmDesc == NULL) {
		return -1;
	}

	attachNewProperty (aafd, FilmDesc, prop, PID_FilmDescriptor_FilmFormat, PROP_OPT);
	attachNewProperty (aafd, FilmDesc, prop, PID_FilmDescriptor_FrameRate, PROP_OPT);
	attachNewProperty (aafd, FilmDesc, prop, PID_FilmDescriptor_PerforationsPerFrame, PROP_OPT);
	attachNewProperty (aafd, FilmDesc, prop, PID_FilmDescriptor_FilmAspectRatio, PROP_OPT);
	attachNewProperty (aafd, FilmDesc, prop, PID_FilmDescriptor_Manufacturer, PROP_OPT);
	attachNewProperty (aafd, FilmDesc, prop, PID_FilmDescriptor_Model, PROP_OPT);
	attachNewProperty (aafd, FilmDesc, prop, PID_FilmDescriptor_FilmGaugeFormat, PROP_OPT);
	attachNewProperty (aafd, FilmDesc, prop, PID_FilmDescriptor_FilmBatchNumber, PROP_OPT);

	aafClass* WAVEDesc = aafclass_defineNewClass (aafd, &AAFClassID_WAVEDescriptor, CONCRETE, FileDesc);

	if (WAVEDesc == NULL) {
		return -1;
	}

	attachNewProperty (aafd, WAVEDesc, prop, PID_WAVEDescriptor_Summary, PROP_REQ);

	aafClass* AIFCDesc = aafclass_defineNewClass (aafd, &AAFClassID_AIFCDescriptor, CONCRETE, FileDesc);

	if (AIFCDesc == NULL) {
		return -1;
	}

	attachNewProperty (aafd, AIFCDesc, prop, PID_AIFCDescriptor_Summary, PROP_REQ);

	aafClass* TIFFDesc = aafclass_defineNewClass (aafd, &AAFClassID_TIFFDescriptor, CONCRETE, FileDesc);

	if (TIFFDesc == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TIFFDesc, prop, PID_TIFFDescriptor_IsUniform, PROP_REQ);
	attachNewProperty (aafd, TIFFDesc, prop, PID_TIFFDescriptor_IsContiguous, PROP_REQ);
	attachNewProperty (aafd, TIFFDesc, prop, PID_TIFFDescriptor_LeadingLines, PROP_OPT);
	attachNewProperty (aafd, TIFFDesc, prop, PID_TIFFDescriptor_TrailingLines, PROP_OPT);
	attachNewProperty (aafd, TIFFDesc, prop, PID_TIFFDescriptor_JPEGTableID, PROP_OPT);
	attachNewProperty (aafd, TIFFDesc, prop, PID_TIFFDescriptor_Summary, PROP_REQ);

	aafClass* SoundDesc = aafclass_defineNewClass (aafd, &AAFClassID_SoundDescriptor, CONCRETE, FileDesc);

	if (SoundDesc == NULL) {
		return -1;
	}

	attachNewProperty (aafd, SoundDesc, prop, PID_SoundDescriptor_AudioSamplingRate, PROP_REQ);
	attachNewProperty (aafd, SoundDesc, prop, PID_SoundDescriptor_Locked, PROP_OPT);
	attachNewProperty (aafd, SoundDesc, prop, PID_SoundDescriptor_AudioRefLevel, PROP_OPT);
	attachNewProperty (aafd, SoundDesc, prop, PID_SoundDescriptor_ElectroSpatial, PROP_OPT);
	attachNewProperty (aafd, SoundDesc, prop, PID_SoundDescriptor_Channels, PROP_REQ);
	attachNewProperty (aafd, SoundDesc, prop, PID_SoundDescriptor_QuantizationBits, PROP_REQ);
	attachNewProperty (aafd, SoundDesc, prop, PID_SoundDescriptor_DialNorm, PROP_OPT);
	attachNewProperty (aafd, SoundDesc, prop, PID_SoundDescriptor_Compression, PROP_OPT);

	aafClass* PCMDesc = aafclass_defineNewClass (aafd, &AAFClassID_PCMDescriptor, CONCRETE, SoundDesc);

	if (PCMDesc == NULL) {
		return -1;
	}

	attachNewProperty (aafd, PCMDesc, prop, PID_PCMDescriptor_BlockAlign, PROP_REQ);
	attachNewProperty (aafd, PCMDesc, prop, PID_PCMDescriptor_SequenceOffset, PROP_OPT);
	attachNewProperty (aafd, PCMDesc, prop, PID_PCMDescriptor_AverageBPS, PROP_REQ);
	attachNewProperty (aafd, PCMDesc, prop, PID_PCMDescriptor_ChannelAssignment, PROP_OPT);
	attachNewProperty (aafd, PCMDesc, prop, PID_PCMDescriptor_PeakEnvelopeVersion, PROP_OPT);
	attachNewProperty (aafd, PCMDesc, prop, PID_PCMDescriptor_PeakEnvelopeFormat, PROP_OPT);
	attachNewProperty (aafd, PCMDesc, prop, PID_PCMDescriptor_PointsPerPeakValue, PROP_OPT);
	attachNewProperty (aafd, PCMDesc, prop, PID_PCMDescriptor_PeakEnvelopeBlockSize, PROP_OPT);
	attachNewProperty (aafd, PCMDesc, prop, PID_PCMDescriptor_PeakChannels, PROP_OPT);
	attachNewProperty (aafd, PCMDesc, prop, PID_PCMDescriptor_PeakFrames, PROP_OPT);
	attachNewProperty (aafd, PCMDesc, prop, PID_PCMDescriptor_PeakOfPeaksPosition, PROP_OPT);
	attachNewProperty (aafd, PCMDesc, prop, PID_PCMDescriptor_PeakEnvelopeTimestamp, PROP_OPT);
	attachNewProperty (aafd, PCMDesc, prop, PID_PCMDescriptor_PeakEnvelopeData, PROP_OPT);

	aafClass* PhysicalDesc = aafclass_defineNewClass (aafd, &AAFClassID_PhysicalDescriptor, ABSTRACT, EssenceDesc);

	if (PhysicalDesc == NULL) {
		return -1;
	}

	/* The PhysicalDescriptor class does not define any additional properties. */

	aafClass* ImportDesc = aafclass_defineNewClass (aafd, &AAFClassID_ImportDescriptor, CONCRETE, PhysicalDesc);

	if (ImportDesc == NULL) {
		return -1;
	}

	/* The ImportDescriptor class does not define any additional properties. */

	aafClass* RecordingDesc = aafclass_defineNewClass (aafd, &AAFClassID_RecordingDescriptor, CONCRETE, PhysicalDesc);

	if (RecordingDesc == NULL) {
		return -1;
	}

	/* The RecordingDescriptor class does not define any additional properties. */

	aafClass* AuxiliaryDesc = aafclass_defineNewClass (aafd, &AAFClassID_AuxiliaryDescriptor, CONCRETE, PhysicalDesc);

	if (AuxiliaryDesc == NULL) {
		return -1;
	}

	attachNewProperty (aafd, AuxiliaryDesc, prop, PID_AuxiliaryDescriptor_MimeType, PROP_REQ);
	attachNewProperty (aafd, AuxiliaryDesc, prop, PID_AuxiliaryDescriptor_CharSet, PROP_OPT);

	aafClass* DefObject = aafclass_defineNewClass (aafd, &AAFClassID_DefinitionObject, ABSTRACT, IOC);

	if (DefObject == NULL) {
		return -1;
	}

	attachNewProperty (aafd, DefObject, prop, PID_DefinitionObject_Identification, PROP_REQ);
	attachNewProperty (aafd, DefObject, prop, PID_DefinitionObject_Name, PROP_REQ);
	attachNewProperty (aafd, DefObject, prop, PID_DefinitionObject_Description, PROP_OPT);

	aafClass* DataDef = aafclass_defineNewClass (aafd, &AAFClassID_DataDefinition, CONCRETE, DefObject);

	if (DataDef == NULL) {
		return -1;
	}

	/* The DataDefinition class does not define any additional properties. */

	aafClass* ContainerDef = aafclass_defineNewClass (aafd, &AAFClassID_ContainerDefinition, CONCRETE, DefObject);

	if (ContainerDef == NULL) {
		return -1;
	}

	attachNewProperty (aafd, ContainerDef, prop, PID_ContainerDefinition_EssenceIsIdentified, PROP_OPT);

	aafClass* OperationDef = aafclass_defineNewClass (aafd, &AAFClassID_OperationDefinition, CONCRETE, DefObject);

	if (OperationDef == NULL) {
		return -1;
	}

	attachNewProperty (aafd, OperationDef, prop, PID_OperationDefinition_DataDefinition, PROP_REQ);
	attachNewProperty (aafd, OperationDef, prop, PID_OperationDefinition_IsTimeWarp, PROP_OPT);
	attachNewProperty (aafd, OperationDef, prop, PID_OperationDefinition_DegradeTo, PROP_OPT);
	attachNewProperty (aafd, OperationDef, prop, PID_OperationDefinition_OperationCategory, PROP_OPT);
	attachNewProperty (aafd, OperationDef, prop, PID_OperationDefinition_NumberInputs, PROP_REQ);
	attachNewProperty (aafd, OperationDef, prop, PID_OperationDefinition_Bypass, PROP_OPT);
	attachNewProperty (aafd, OperationDef, prop, PID_OperationDefinition_ParametersDefined, PROP_OPT);

	aafClass* ParameterDef = aafclass_defineNewClass (aafd, &AAFClassID_ParameterDefinition, CONCRETE, DefObject);

	if (ParameterDef == NULL) {
		return -1;
	}

	attachNewProperty (aafd, ParameterDef, prop, PID_ParameterDefinition_Type, PROP_REQ);
	attachNewProperty (aafd, ParameterDef, prop, PID_ParameterDefinition_DisplayUnits, PROP_OPT);

	aafClass* InterpolationDef = aafclass_defineNewClass (aafd, &AAFClassID_InterpolationDefinition, CONCRETE, DefObject);

	if (InterpolationDef == NULL) {
		return -1;
	}

	/* The InterpolationDefinition class does not define any additional properties. */

	aafClass* CodecDef = aafclass_defineNewClass (aafd, &AAFClassID_CodecDefinition, CONCRETE, DefObject);

	if (CodecDef == NULL) {
		return -1;
	}

	attachNewProperty (aafd, CodecDef, prop, PID_CodecDefinition_FileDescriptorClass, PROP_REQ);
	attachNewProperty (aafd, CodecDef, prop, PID_CodecDefinition_DataDefinitions, PROP_REQ);

	aafClass* PluginDef = aafclass_defineNewClass (aafd, &AAFClassID_PluginDefinition, CONCRETE, DefObject);

	if (PluginDef == NULL) {
		return -1;
	}

	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_PluginCategory, PROP_REQ);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_VersionNumber, PROP_REQ);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_VersionString, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_Manufacturer, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_ManufacturerInfo, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_ManufacturerID, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_Platform, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_MinPlatformVersion, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_MaxPlatformVersion, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_Engine, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_MinEngineVersion, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_MaxEngineVersion, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_PluginAPI, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_MinPluginAPI, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_MaxPluginAPI, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_SoftwareOnly, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_Accelerator, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_Locators, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_Authentication, PROP_OPT);
	attachNewProperty (aafd, PluginDef, prop, PID_PluginDefinition_DefinitionObject, PROP_OPT);

	aafClass* TaggedValueDef = aafclass_defineNewClass (aafd, &AAFClassID_TaggedValueDefinition, CONCRETE, DefObject);

	if (TaggedValueDef == NULL) {
		return -1;
	}

	/* The TaggedValueDefinition class does not define any additional properties. */

	aafClass* KLVDataDef = aafclass_defineNewClass (aafd, &AAFClassID_KLVDataDefinition, CONCRETE, DefObject);

	if (KLVDataDef == NULL) {
		return -1;
	}

	attachNewProperty (aafd, KLVDataDef, prop, PID_KLVDataDefinition_KLVDataType, PROP_OPT);

	aafClass* EssenceData = aafclass_defineNewClass (aafd, &AAFClassID_EssenceData, CONCRETE, IOC);

	if (EssenceData == NULL) {
		return -1;
	}

	attachNewProperty (aafd, EssenceData, prop, PID_EssenceData_MobID, PROP_REQ);
	attachNewProperty (aafd, EssenceData, prop, PID_EssenceData_Data, PROP_REQ);
	attachNewProperty (aafd, EssenceData, prop, PID_EssenceData_SampleIndex, PROP_OPT);

	aafClass* MetaDefinition = aafclass_defineNewClass (aafd, &AAFClassID_MetaDefinition, ABSTRACT, NULL);

	if (MetaDefinition == NULL) {
		return -1;
	}

	attachNewProperty (aafd, MetaDefinition, prop, PID_MetaDefinition_Identification, PROP_REQ);
	attachNewProperty (aafd, MetaDefinition, prop, PID_MetaDefinition_Name, PROP_REQ);
	attachNewProperty (aafd, MetaDefinition, prop, PID_MetaDefinition_Description, PROP_OPT);

	aafClass* ClassDefinition = aafclass_defineNewClass (aafd, &AAFClassID_ClassDefinition, CONCRETE, MetaDefinition);

	if (ClassDefinition == NULL) {
		return -1;
	}

	attachNewProperty (aafd, ClassDefinition, prop, PID_ClassDefinition_ParentClass, PROP_REQ);
	attachNewProperty (aafd, ClassDefinition, prop, PID_ClassDefinition_Properties, PROP_OPT);
	attachNewProperty (aafd, ClassDefinition, prop, PID_ClassDefinition_IsConcrete, PROP_REQ);

	aafClass* PropertyDefinition = aafclass_defineNewClass (aafd, &AAFClassID_PropertyDefinition, CONCRETE, MetaDefinition);

	if (PropertyDefinition == NULL) {
		return -1;
	}

	attachNewProperty (aafd, PropertyDefinition, prop, PID_PropertyDefinition_Type, PROP_REQ);
	attachNewProperty (aafd, PropertyDefinition, prop, PID_PropertyDefinition_IsOptional, PROP_REQ);
	attachNewProperty (aafd, PropertyDefinition, prop, PID_PropertyDefinition_LocalIdentification, PROP_REQ);
	attachNewProperty (aafd, PropertyDefinition, prop, PID_PropertyDefinition_IsUniqueIdentifier, PROP_OPT);

	aafClass* TypeDef = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinition, ABSTRACT, MetaDefinition);

	if (TypeDef == NULL) {
		return -1;
	}

	/* The TypeDefinition class does not define any additional properties. */

	aafClass* TypeDefCharacter = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinitionCharacter, CONCRETE, TypeDef);

	if (TypeDefCharacter == NULL) {
		return -1;
	}

	/* The TypeDefinitionCharacter class does not define any additional properties. */

	aafClass* TypeDefEnum = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinitionEnumeration, CONCRETE, TypeDef);

	if (TypeDefEnum == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TypeDefEnum, prop, PID_TypeDefinitionEnumeration_ElementType, PROP_REQ);
	attachNewProperty (aafd, TypeDefEnum, prop, PID_TypeDefinitionEnumeration_ElementNames, PROP_REQ);
	attachNewProperty (aafd, TypeDefEnum, prop, PID_TypeDefinitionEnumeration_ElementValues, PROP_REQ);

	aafClass* TypeDefExtEnum = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinitionExtendibleEnumeration, CONCRETE, TypeDef);

	if (TypeDefExtEnum == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TypeDefExtEnum, prop, PID_TypeDefinitionExtendibleEnumeration_ElementNames, PROP_REQ);
	attachNewProperty (aafd, TypeDefExtEnum, prop, PID_TypeDefinitionExtendibleEnumeration_ElementValues, PROP_REQ);

	aafClass* TypeDefFixedArray = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinitionFixedArray, CONCRETE, TypeDef);

	if (TypeDefFixedArray == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TypeDefFixedArray, prop, PID_TypeDefinitionFixedArray_ElementType, PROP_REQ);
	attachNewProperty (aafd, TypeDefFixedArray, prop, PID_TypeDefinitionFixedArray_ElementCount, PROP_REQ);

	aafClass* TypeDefIndirect = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinitionIndirect, CONCRETE, TypeDef);

	if (TypeDefIndirect == NULL) {
		return -1;
	}

	/* The TypeDefinitionIndirect class does not define any additional properties. */

	aafClass* TypeDefInt = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinitionInteger, CONCRETE, TypeDef);

	if (TypeDefInt == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TypeDefInt, prop, PID_TypeDefinitionInteger_Size, PROP_REQ);
	attachNewProperty (aafd, TypeDefInt, prop, PID_TypeDefinitionInteger_IsSigned, PROP_REQ);

	aafClass* TypeDefOpaque = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinitionOpaque, CONCRETE, TypeDef);

	if (TypeDefOpaque == NULL) {
		return -1;
	}

	/* The TypeDefinitionOpaque class does not define any additional properties. */

	aafClass* TypeDefRecord = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinitionRecord, CONCRETE, TypeDef);

	if (TypeDefRecord == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TypeDefRecord, prop, PID_TypeDefinitionRecord_MemberTypes, PROP_REQ);
	attachNewProperty (aafd, TypeDefRecord, prop, PID_TypeDefinitionRecord_MemberNames, PROP_REQ);

	aafClass* TypeDefRename = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinitionRename, CONCRETE, TypeDef);

	if (TypeDefRename == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TypeDefRename, prop, PID_TypeDefinitionRename_RenamedType, PROP_REQ);

	aafClass* TypeDefSet = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinitionSet, CONCRETE, TypeDef);

	if (TypeDefSet == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TypeDefSet, prop, PID_TypeDefinitionSet_ElementType, PROP_REQ);

	aafClass* TypeDefStream = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinitionStream, CONCRETE, TypeDef);

	if (TypeDefStream == NULL) {
		return -1;
	}

	/* The TypeDefinitionStream class does not define any additional properties. */

	aafClass* TypeDefString = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinitionString, CONCRETE, TypeDef);

	if (TypeDefString == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TypeDefString, prop, PID_TypeDefinitionString_ElementType, PROP_REQ);

	aafClass* TypeDefStrongObjRef = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinitionStrongObjectReference, CONCRETE, TypeDef);

	if (TypeDefStrongObjRef == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TypeDefStrongObjRef, prop, PID_TypeDefinitionStrongObjectReference_ReferencedType, PROP_REQ);

	aafClass* TypeDefVariableArray = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinitionVariableArray, CONCRETE, TypeDef);

	if (TypeDefVariableArray == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TypeDefVariableArray, prop, PID_TypeDefinitionVariableArray_ElementType, PROP_REQ);

	aafClass* TypeDefWeakObjRef = aafclass_defineNewClass (aafd, &AAFClassID_TypeDefinitionWeakObjectReference, CONCRETE, TypeDef);

	if (TypeDefWeakObjRef == NULL) {
		return -1;
	}

	attachNewProperty (aafd, TypeDefWeakObjRef, prop, PID_TypeDefinitionWeakObjectReference_ReferencedType, PROP_REQ);
	attachNewProperty (aafd, TypeDefWeakObjRef, prop, PID_TypeDefinitionWeakObjectReference_TargetSet, PROP_REQ);

	aafClass* MetaDictionary = aafclass_defineNewClass (aafd, &AAFClassID_MetaDictionary, CONCRETE, NULL);

	if (MetaDictionary == NULL) {
		return -1;
	}

	attachNewProperty (aafd, MetaDictionary, prop, PID_MetaDictionary_ClassDefinitions, PROP_OPT);
	attachNewProperty (aafd, MetaDictionary, prop, PID_MetaDictionary_TypeDefinitions, PROP_OPT);

	return 0;
}