Generated Entity code

Entities.generated.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Runtime.Serialization;
using EdFi.Ods.Common;
using EdFi.Ods.Api;
using EdFi.Ods.Api.Caching;
using EdFi.Ods.Entities.Common;
using EdFi.Ods.Entities.Common.Records;
using EdFi.Ods.Api.Validation;
using EdFi.Ods.Api.NHibernate.Architecture;
using EdFi.Ods.Api.NHibernate;
using Newtonsoft.Json;

// Aggregate: ABC

namespace EdFi.Ods.Entities.NHibernate.ABCAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the extension.ABC table of the ABC aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class ABC : AggregateRootWithCompositeKey, 
        IABC, IABCRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IABCSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault]
        public virtual int ABDId  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int EducationOrganizationId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("ABDId", ABDId);
            keyValues.Add("EducationOrganizationId", EducationOrganizationId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IABC>
        {
            return this.SynchronizeTo((IABC)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IABC) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 
}
// Aggregate: AcademicHonorCategoryType

namespace EdFi.Ods.Entities.NHibernate.AcademicHonorCategoryTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AcademicHonorCategoryType table of the AcademicHonorCategoryType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AcademicHonorCategoryType : AggregateRootWithCompositeKey, 
        IAcademicHonorCategoryType, IAcademicHonorCategoryTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAcademicHonorCategoryTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AcademicHonorCategoryTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AcademicHonorCategoryTypeId", AcademicHonorCategoryTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAcademicHonorCategoryType>
        {
            return this.SynchronizeTo((IAcademicHonorCategoryType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAcademicHonorCategoryType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IAcademicHonorCategoryTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAcademicHonorCategoryTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAcademicHonorCategoryTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AcademicSubjectDescriptor

namespace EdFi.Ods.Entities.NHibernate.AcademicSubjectDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AcademicSubjectDescriptor table of the AcademicSubjectDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AcademicSubjectDescriptor : DescriptorAggregate.Descriptor, 
        IAcademicSubjectDescriptor, IAcademicSubjectDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAcademicSubjectDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AcademicSubjectDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault]
        public virtual int AcademicSubjectTypeId 
        {
            get
            {
                if (_academicSubjectTypeId == default(int))
                    _academicSubjectTypeId = TypesAndDescriptorsCache.GetCache().GetId("AcademicSubjectType", _academicSubjectType);

                return _academicSubjectTypeId;
            } 
            set
            {
                _academicSubjectTypeId = value;
                _academicSubjectType = null;
            }
        }

        private int _academicSubjectTypeId;
        private string _academicSubjectType;

        public virtual string AcademicSubjectType
        {
            get
            {
                if (_academicSubjectType == null)
                    _academicSubjectType = TypesAndDescriptorsCache.GetCache().GetValue("AcademicSubjectType", _academicSubjectTypeId);
                    
                return _academicSubjectType;
            }
            set
            {
                _academicSubjectType = value;
                _academicSubjectTypeId = default(int);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectType", new LookupColumnDetails { PropertyName = "AcademicSubjectTypeId", LookupTypeName = "AcademicSubjectType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AcademicSubjectDescriptorId", AcademicSubjectDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAcademicSubjectDescriptor>
        {
            return this.SynchronizeTo((IAcademicSubjectDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAcademicSubjectDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAcademicSubjectTypeSupported = true;
        bool IAcademicSubjectDescriptorSynchronizationSourceSupport.IsAcademicSubjectTypeSupported 
        { 
            get { return _isAcademicSubjectTypeSupported; } 
            set { _isAcademicSubjectTypeSupported = value; }
        }

        private bool _isCodeValueSupported = true;
        bool IAcademicSubjectDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAcademicSubjectDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool IAcademicSubjectDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool IAcademicSubjectDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool IAcademicSubjectDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool IAcademicSubjectDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAcademicSubjectDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AcademicSubjectType

namespace EdFi.Ods.Entities.NHibernate.AcademicSubjectTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AcademicSubjectType table of the AcademicSubjectType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AcademicSubjectType : AggregateRootWithCompositeKey, 
        IAcademicSubjectType, IAcademicSubjectTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAcademicSubjectTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AcademicSubjectTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AcademicSubjectTypeId", AcademicSubjectTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAcademicSubjectType>
        {
            return this.SynchronizeTo((IAcademicSubjectType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAcademicSubjectType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IAcademicSubjectTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAcademicSubjectTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAcademicSubjectTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AcademicWeek

namespace EdFi.Ods.Entities.NHibernate.AcademicWeekAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AcademicWeek table of the AcademicWeek aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AcademicWeek : AggregateRootWithCompositeKey, 
        IAcademicWeek, IAcademicWeekRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAcademicWeekSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault, StringLength(80), NoDangerousText]
        public virtual string WeekIdentifier  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int SchoolId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, SqlServerDateTimeRange]
        public virtual DateTime BeginDate 
        {
            get { return _beginDate; }
            //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
            set { _beginDate = new DateTime(value.Year, value.Month, value.Day); }
        }

        private DateTime _beginDate;
        
        [RequiredWithNonDefault, SqlServerDateTimeRange]
        public virtual DateTime EndDate 
        {
            get { return _endDate; }
            //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
            set { _endDate = new DateTime(value.Year, value.Month, value.Day); }
        }

        private DateTime _endDate;
        
        public virtual int TotalInstructionalDays  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("SchoolId", SchoolId);
            keyValues.Add("WeekIdentifier", WeekIdentifier);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAcademicWeek>
        {
            return this.SynchronizeTo((IAcademicWeek)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAcademicWeek) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isBeginDateSupported = true;
        bool IAcademicWeekSynchronizationSourceSupport.IsBeginDateSupported 
        { 
            get { return _isBeginDateSupported; } 
            set { _isBeginDateSupported = value; }
        }

        private bool _isEndDateSupported = true;
        bool IAcademicWeekSynchronizationSourceSupport.IsEndDateSupported 
        { 
            get { return _isEndDateSupported; } 
            set { _isEndDateSupported = value; }
        }

        private bool _isTotalInstructionalDaysSupported = true;
        bool IAcademicWeekSynchronizationSourceSupport.IsTotalInstructionalDaysSupported 
        { 
            get { return _isTotalInstructionalDaysSupported; } 
            set { _isTotalInstructionalDaysSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AccommodationDescriptor

namespace EdFi.Ods.Entities.NHibernate.AccommodationDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AccommodationDescriptor table of the AccommodationDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AccommodationDescriptor : DescriptorAggregate.Descriptor, 
        IAccommodationDescriptor, IAccommodationDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAccommodationDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AccommodationDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        public virtual int? AccommodationTypeId 
        {
            get
            {
                if (_accommodationTypeId == default(int?))
                    _accommodationTypeId = string.IsNullOrWhiteSpace(_accommodationType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("AccommodationType", _accommodationType);

                return _accommodationTypeId;
            } 
            set
            {
                _accommodationTypeId = value;
                _accommodationType = null;
            }
        }

        private int? _accommodationTypeId;
        private string _accommodationType;

        public virtual string AccommodationType
        {
            get
            {
                if (_accommodationType == null)
                    _accommodationType = _accommodationTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("AccommodationType", _accommodationTypeId.Value);
                    
                return _accommodationType;
            }
            set
            {
                _accommodationType = value;
                _accommodationTypeId = default(int?);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AccommodationType", new LookupColumnDetails { PropertyName = "AccommodationTypeId", LookupTypeName = "AccommodationType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AccommodationDescriptorId", AccommodationDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAccommodationDescriptor>
        {
            return this.SynchronizeTo((IAccommodationDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAccommodationDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAccommodationTypeSupported = true;
        bool IAccommodationDescriptorSynchronizationSourceSupport.IsAccommodationTypeSupported 
        { 
            get { return _isAccommodationTypeSupported; } 
            set { _isAccommodationTypeSupported = value; }
        }

        private bool _isCodeValueSupported = true;
        bool IAccommodationDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAccommodationDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool IAccommodationDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool IAccommodationDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool IAccommodationDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool IAccommodationDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAccommodationDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AccommodationType

namespace EdFi.Ods.Entities.NHibernate.AccommodationTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AccommodationType table of the AccommodationType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AccommodationType : AggregateRootWithCompositeKey, 
        IAccommodationType, IAccommodationTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAccommodationTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AccommodationTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AccommodationTypeId", AccommodationTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAccommodationType>
        {
            return this.SynchronizeTo((IAccommodationType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAccommodationType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IAccommodationTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAccommodationTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAccommodationTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: Account

namespace EdFi.Ods.Entities.NHibernate.AccountAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.Account table of the Account aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class Account : AggregateRootWithCompositeKey, 
        IAccount, IAccountRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAccountSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        public Account()
        {
            AccountCodes = new List<AccountCode>();

        }
// restore warnings for inheritance from classes marked Obsolete
#pragma warning restore 612, 618 
               
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault]
        public virtual int EducationOrganizationId  { get; set; }
        [DomainSignature, RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string AccountNumber  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int FiscalYear  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------

        private IList<AccountCode> _accountCodes;
        private IList<IAccountCode> _accountCodesCovariant;
        [RequiredCollection]
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<AccountCode> AccountCodes
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _accountCodes)
                    if (item.Account == null)
                        item.Account = this;
                // -------------------------------------------------------------

                return _accountCodes;
            }
            set 
            { 
                _accountCodes = value;
                _accountCodesCovariant = new CovariantIListAdapter<IAccountCode, AccountCode>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<IAccountCode> IAccount.AccountCodes
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _accountCodes)
                    if (item.Account == null)
                        item.Account = this;
                // -------------------------------------------------------------

                return _accountCodesCovariant; 
            }
            set 
            { 
                AccountCodes = new List<AccountCode>(value.Cast<AccountCode>()); 
            }
        }

        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AccountNumber", AccountNumber);
            keyValues.Add("EducationOrganizationId", EducationOrganizationId);
            keyValues.Add("FiscalYear", FiscalYear);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAccount>
        {
            return this.SynchronizeTo((IAccount)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAccount) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAccountCodesSupported = true;
        bool IAccountSynchronizationSourceSupport.IsAccountCodesSupported 
        { 
            get { return _isAccountCodesSupported; } 
            set { _isAccountCodesSupported = value; }
        }

        private Func<IAccountCode, bool> _isAccountCodeIncluded;
        Func<IAccountCode, bool> IAccountSynchronizationSourceSupport.IsAccountCodeIncluded
        { 
            get { return _isAccountCodeIncluded; } 
            set { _isAccountCodeIncluded = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AccountCode table of the Account aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AccountCode : EntityWithCompositeKey, IChildEntity, 
        IAccountCode, IAccountCodeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAccountCodeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual Account Account { get; set; }

        IAccount IAccountCode.Account
        {
            get { return Account; }
            set { Account = (Account) value; }
        }

        int IAccountCodeRecord.EducationOrganizationId
        {
            get { return ((IAccountRecord) Account).EducationOrganizationId; }
            set { ((IAccountRecord) Account).EducationOrganizationId = value; }
        }


        string IAccountCodeRecord.AccountNumber
        {
            get { return ((IAccountRecord) Account).AccountNumber; }
            set { ((IAccountRecord) Account).AccountNumber = value; }
        }


        int IAccountCodeRecord.FiscalYear
        {
            get { return ((IAccountRecord) Account).FiscalYear; }
            set { ((IAccountRecord) Account).FiscalYear = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int AccountCodeDescriptorId 
        {
            get
            {
                if (_accountCodeDescriptorId == default(int))
                    _accountCodeDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("AccountCodeDescriptor", _accountCodeDescriptor);

                return _accountCodeDescriptorId;
            } 
            set
            {
                _accountCodeDescriptorId = value;
                _accountCodeDescriptor = null;
            }
        }

        private int _accountCodeDescriptorId;
        private string _accountCodeDescriptor;

        public virtual string AccountCodeDescriptor
        {
            get
            {
                if (_accountCodeDescriptor == null)
                    _accountCodeDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("AccountCodeDescriptor", _accountCodeDescriptorId);
                    
                return _accountCodeDescriptor;
            }
            set
            {
                _accountCodeDescriptor = value;
                _accountCodeDescriptorId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AccountCodeDescriptor", new LookupColumnDetails { PropertyName = "AccountCodeDescriptorId", LookupTypeName = "AccountCodeDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (Account as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("AccountCodeDescriptorId", AccountCodeDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAccountCode>
        {
            return this.SynchronizeTo((IAccountCode)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAccountCode) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            Account = (Account) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 
}
// Aggregate: AccountabilityRating

namespace EdFi.Ods.Entities.NHibernate.AccountabilityRatingAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AccountabilityRating table of the AccountabilityRating aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AccountabilityRating : AggregateRootWithCompositeKey, 
        IAccountabilityRating, IAccountabilityRatingRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAccountabilityRatingSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string RatingTitle  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int EducationOrganizationId  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual short SchoolYear  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(35), NoDangerousText]
        public virtual string Rating  { get; set; }
        [SqlServerDateTimeRange]
        public virtual DateTime? RatingDate 
        {
            get { return _ratingDate; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _ratingDate = null;
                } else
                {
                    var given = (DateTime) value;
                    _ratingDate = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _ratingDate;
        
        [StringLength(35), NoDangerousText]
        public virtual string RatingOrganization  { get; set; }
        [StringLength(30), NoDangerousText]
        public virtual string RatingProgram  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("EducationOrganizationId", EducationOrganizationId);
            keyValues.Add("RatingTitle", RatingTitle);
            keyValues.Add("SchoolYear", SchoolYear);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAccountabilityRating>
        {
            return this.SynchronizeTo((IAccountabilityRating)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAccountabilityRating) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isRatingSupported = true;
        bool IAccountabilityRatingSynchronizationSourceSupport.IsRatingSupported 
        { 
            get { return _isRatingSupported; } 
            set { _isRatingSupported = value; }
        }

        private bool _isRatingDateSupported = true;
        bool IAccountabilityRatingSynchronizationSourceSupport.IsRatingDateSupported 
        { 
            get { return _isRatingDateSupported; } 
            set { _isRatingDateSupported = value; }
        }

        private bool _isRatingOrganizationSupported = true;
        bool IAccountabilityRatingSynchronizationSourceSupport.IsRatingOrganizationSupported 
        { 
            get { return _isRatingOrganizationSupported; } 
            set { _isRatingOrganizationSupported = value; }
        }

        private bool _isRatingProgramSupported = true;
        bool IAccountabilityRatingSynchronizationSourceSupport.IsRatingProgramSupported 
        { 
            get { return _isRatingProgramSupported; } 
            set { _isRatingProgramSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AccountCodeDescriptor

namespace EdFi.Ods.Entities.NHibernate.AccountCodeDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AccountCodeDescriptor table of the AccountCodeDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AccountCodeDescriptor : DescriptorAggregate.Descriptor, 
        IAccountCodeDescriptor, IAccountCodeDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAccountCodeDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AccountCodeDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(20), NoDangerousText]
        public virtual string AccountCodeCategory  { get; set; }
        [SqlServerDateTimeRange]
        public virtual DateTime? BeginDate 
        {
            get { return _beginDate; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _beginDate = null;
                } else
                {
                    var given = (DateTime) value;
                    _beginDate = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _beginDate;
        
        [SqlServerDateTimeRange]
        public virtual DateTime? EndDate 
        {
            get { return _endDate; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _endDate = null;
                } else
                {
                    var given = (DateTime) value;
                    _endDate = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _endDate;
        
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AccountCodeDescriptorId", AccountCodeDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAccountCodeDescriptor>
        {
            return this.SynchronizeTo((IAccountCodeDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAccountCodeDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAccountCodeCategorySupported = true;
        bool IAccountCodeDescriptorSynchronizationSourceSupport.IsAccountCodeCategorySupported 
        { 
            get { return _isAccountCodeCategorySupported; } 
            set { _isAccountCodeCategorySupported = value; }
        }

        private bool _isBeginDateSupported = true;
        bool IAccountCodeDescriptorSynchronizationSourceSupport.IsBeginDateSupported 
        { 
            get { return _isBeginDateSupported; } 
            set { _isBeginDateSupported = value; }
        }

        private bool _isCodeValueSupported = true;
        bool IAccountCodeDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAccountCodeDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool IAccountCodeDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool IAccountCodeDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isEndDateSupported = true;
        bool IAccountCodeDescriptorSynchronizationSourceSupport.IsEndDateSupported 
        { 
            get { return _isEndDateSupported; } 
            set { _isEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool IAccountCodeDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool IAccountCodeDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAccountCodeDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AchievementCategoryDescriptor

namespace EdFi.Ods.Entities.NHibernate.AchievementCategoryDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AchievementCategoryDescriptor table of the AchievementCategoryDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AchievementCategoryDescriptor : DescriptorAggregate.Descriptor, 
        IAchievementCategoryDescriptor, IAchievementCategoryDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAchievementCategoryDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AchievementCategoryDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        public virtual int? AchievementCategoryTypeId 
        {
            get
            {
                if (_achievementCategoryTypeId == default(int?))
                    _achievementCategoryTypeId = string.IsNullOrWhiteSpace(_achievementCategoryType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("AchievementCategoryType", _achievementCategoryType);

                return _achievementCategoryTypeId;
            } 
            set
            {
                _achievementCategoryTypeId = value;
                _achievementCategoryType = null;
            }
        }

        private int? _achievementCategoryTypeId;
        private string _achievementCategoryType;

        public virtual string AchievementCategoryType
        {
            get
            {
                if (_achievementCategoryType == null)
                    _achievementCategoryType = _achievementCategoryTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("AchievementCategoryType", _achievementCategoryTypeId.Value);
                    
                return _achievementCategoryType;
            }
            set
            {
                _achievementCategoryType = value;
                _achievementCategoryTypeId = default(int?);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AchievementCategoryType", new LookupColumnDetails { PropertyName = "AchievementCategoryTypeId", LookupTypeName = "AchievementCategoryType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AchievementCategoryDescriptorId", AchievementCategoryDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAchievementCategoryDescriptor>
        {
            return this.SynchronizeTo((IAchievementCategoryDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAchievementCategoryDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAchievementCategoryTypeSupported = true;
        bool IAchievementCategoryDescriptorSynchronizationSourceSupport.IsAchievementCategoryTypeSupported 
        { 
            get { return _isAchievementCategoryTypeSupported; } 
            set { _isAchievementCategoryTypeSupported = value; }
        }

        private bool _isCodeValueSupported = true;
        bool IAchievementCategoryDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAchievementCategoryDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool IAchievementCategoryDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool IAchievementCategoryDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool IAchievementCategoryDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool IAchievementCategoryDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAchievementCategoryDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AchievementCategoryType

namespace EdFi.Ods.Entities.NHibernate.AchievementCategoryTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AchievementCategoryType table of the AchievementCategoryType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AchievementCategoryType : AggregateRootWithCompositeKey, 
        IAchievementCategoryType, IAchievementCategoryTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAchievementCategoryTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AchievementCategoryTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AchievementCategoryTypeId", AchievementCategoryTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAchievementCategoryType>
        {
            return this.SynchronizeTo((IAchievementCategoryType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAchievementCategoryType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IAchievementCategoryTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAchievementCategoryTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAchievementCategoryTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: Actual

namespace EdFi.Ods.Entities.NHibernate.ActualAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.Actual table of the Actual aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class Actual : AggregateRootWithCompositeKey, 
        IActual, IActualRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IActualSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault]
        public virtual int EducationOrganizationId  { get; set; }
        [DomainSignature, RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string AccountNumber  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int FiscalYear  { get; set; }
        [DomainSignature, RequiredWithNonDefault, SqlServerDateTimeRange]
        public virtual DateTime AsOfDate 
        {
            get { return _asOfDate; }
            //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
            set { _asOfDate = new DateTime(value.Year, value.Month, value.Day); }
        }

        private DateTime _asOfDate;
        
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [Range(typeof(decimal), "-999999999999999.9999", "999999999999999.9999")]
        public virtual decimal AmountToDate  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AccountNumber", AccountNumber);
            keyValues.Add("AsOfDate", AsOfDate);
            keyValues.Add("EducationOrganizationId", EducationOrganizationId);
            keyValues.Add("FiscalYear", FiscalYear);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IActual>
        {
            return this.SynchronizeTo((IActual)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IActual) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAmountToDateSupported = true;
        bool IActualSynchronizationSourceSupport.IsAmountToDateSupported 
        { 
            get { return _isAmountToDateSupported; } 
            set { _isAmountToDateSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AdditionalCreditType

namespace EdFi.Ods.Entities.NHibernate.AdditionalCreditTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AdditionalCreditType table of the AdditionalCreditType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AdditionalCreditType : AggregateRootWithCompositeKey, 
        IAdditionalCreditType, IAdditionalCreditTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAdditionalCreditTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AdditionalCreditTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AdditionalCreditTypeId", AdditionalCreditTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAdditionalCreditType>
        {
            return this.SynchronizeTo((IAdditionalCreditType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAdditionalCreditType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IAdditionalCreditTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAdditionalCreditTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAdditionalCreditTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AddressType

namespace EdFi.Ods.Entities.NHibernate.AddressTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AddressType table of the AddressType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AddressType : AggregateRootWithCompositeKey, 
        IAddressType, IAddressTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAddressTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AddressTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AddressTypeId", AddressTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAddressType>
        {
            return this.SynchronizeTo((IAddressType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAddressType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IAddressTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAddressTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAddressTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AdministrationEnvironmentType

namespace EdFi.Ods.Entities.NHibernate.AdministrationEnvironmentTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AdministrationEnvironmentType table of the AdministrationEnvironmentType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AdministrationEnvironmentType : AggregateRootWithCompositeKey, 
        IAdministrationEnvironmentType, IAdministrationEnvironmentTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAdministrationEnvironmentTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AdministrationEnvironmentTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AdministrationEnvironmentTypeId", AdministrationEnvironmentTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAdministrationEnvironmentType>
        {
            return this.SynchronizeTo((IAdministrationEnvironmentType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAdministrationEnvironmentType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IAdministrationEnvironmentTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAdministrationEnvironmentTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAdministrationEnvironmentTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AdministrativeFundingControlDescriptor

namespace EdFi.Ods.Entities.NHibernate.AdministrativeFundingControlDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AdministrativeFundingControlDescriptor table of the AdministrativeFundingControlDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AdministrativeFundingControlDescriptor : DescriptorAggregate.Descriptor, 
        IAdministrativeFundingControlDescriptor, IAdministrativeFundingControlDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAdministrativeFundingControlDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AdministrativeFundingControlDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        public virtual int? AdministrativeFundingControlTypeId 
        {
            get
            {
                if (_administrativeFundingControlTypeId == default(int?))
                    _administrativeFundingControlTypeId = string.IsNullOrWhiteSpace(_administrativeFundingControlType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("AdministrativeFundingControlType", _administrativeFundingControlType);

                return _administrativeFundingControlTypeId;
            } 
            set
            {
                _administrativeFundingControlTypeId = value;
                _administrativeFundingControlType = null;
            }
        }

        private int? _administrativeFundingControlTypeId;
        private string _administrativeFundingControlType;

        public virtual string AdministrativeFundingControlType
        {
            get
            {
                if (_administrativeFundingControlType == null)
                    _administrativeFundingControlType = _administrativeFundingControlTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("AdministrativeFundingControlType", _administrativeFundingControlTypeId.Value);
                    
                return _administrativeFundingControlType;
            }
            set
            {
                _administrativeFundingControlType = value;
                _administrativeFundingControlTypeId = default(int?);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AdministrativeFundingControlType", new LookupColumnDetails { PropertyName = "AdministrativeFundingControlTypeId", LookupTypeName = "AdministrativeFundingControlType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AdministrativeFundingControlDescriptorId", AdministrativeFundingControlDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAdministrativeFundingControlDescriptor>
        {
            return this.SynchronizeTo((IAdministrativeFundingControlDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAdministrativeFundingControlDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAdministrativeFundingControlTypeSupported = true;
        bool IAdministrativeFundingControlDescriptorSynchronizationSourceSupport.IsAdministrativeFundingControlTypeSupported 
        { 
            get { return _isAdministrativeFundingControlTypeSupported; } 
            set { _isAdministrativeFundingControlTypeSupported = value; }
        }

        private bool _isCodeValueSupported = true;
        bool IAdministrativeFundingControlDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAdministrativeFundingControlDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool IAdministrativeFundingControlDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool IAdministrativeFundingControlDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool IAdministrativeFundingControlDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool IAdministrativeFundingControlDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAdministrativeFundingControlDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AdministrativeFundingControlType

namespace EdFi.Ods.Entities.NHibernate.AdministrativeFundingControlTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AdministrativeFundingControlType table of the AdministrativeFundingControlType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AdministrativeFundingControlType : AggregateRootWithCompositeKey, 
        IAdministrativeFundingControlType, IAdministrativeFundingControlTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAdministrativeFundingControlTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AdministrativeFundingControlTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AdministrativeFundingControlTypeId", AdministrativeFundingControlTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAdministrativeFundingControlType>
        {
            return this.SynchronizeTo((IAdministrativeFundingControlType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAdministrativeFundingControlType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IAdministrativeFundingControlTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAdministrativeFundingControlTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAdministrativeFundingControlTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: ApplicationStatusType

namespace EdFi.Ods.Entities.NHibernate.ApplicationStatusTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the extension.ApplicationStatusType table of the ApplicationStatusType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class ApplicationStatusType : AggregateRootWithCompositeKey, 
        IApplicationStatusType, IApplicationStatusTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IApplicationStatusTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int ApplicationStatusTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("ApplicationStatusTypeId", ApplicationStatusTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IApplicationStatusType>
        {
            return this.SynchronizeTo((IApplicationStatusType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IApplicationStatusType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IApplicationStatusTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IApplicationStatusTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IApplicationStatusTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: ApplyTexasApplication

namespace EdFi.Ods.Entities.NHibernate.ApplyTexasApplicationAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the extension.ApplyTexasApplication table of the ApplyTexasApplication aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class ApplyTexasApplication : AggregateRootWithCompositeKey, 
        IApplyTexasApplication, IApplyTexasApplicationRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IApplyTexasApplicationSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault]
        public virtual int ApplicationId  { get; set; }
        [DomainSignature, RequiredWithNonDefault, SqlServerDateTimeRange]
        public virtual DateTime EventDate 
        {
            get { return _eventDate; }
            //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
            set { _eventDate = new DateTime(value.Year, value.Month, value.Day); }
        }

        private DateTime _eventDate;
        
        [DomainSignature, RequiredWithNonDefault]
        public virtual int PostSecondaryEventCategoryTypeId 
        {
            get
            {
                if (_postSecondaryEventCategoryTypeId == default(int))
                    _postSecondaryEventCategoryTypeId = TypesAndDescriptorsCache.GetCache().GetId("PostSecondaryEventCategoryType", _postSecondaryEventCategoryType);

                return _postSecondaryEventCategoryTypeId;
            } 
            set
            {
                _postSecondaryEventCategoryTypeId = value;
                _postSecondaryEventCategoryType = null;
            }
        }

        private int _postSecondaryEventCategoryTypeId;
        private string _postSecondaryEventCategoryType;

        public virtual string PostSecondaryEventCategoryType
        {
            get
            {
                if (_postSecondaryEventCategoryType == null)
                    _postSecondaryEventCategoryType = TypesAndDescriptorsCache.GetCache().GetValue("PostSecondaryEventCategoryType", _postSecondaryEventCategoryTypeId);
                    
                return _postSecondaryEventCategoryType;
            }
            set
            {
                _postSecondaryEventCategoryType = value;
                _postSecondaryEventCategoryTypeId = default(int);
            }
        }
        [Display(Name="StudentUniqueId")]
        [DomainSignature, RequiredWithNonDefault]
        public virtual int StudentUSI 
        {
            get
            {
                if (_studentUSI == default(int))
                    _studentUSI = PersonUniqueIdToUsiCache.GetCache().GetUsi("Student", _studentUniqueId);

                return _studentUSI;
            } 
            set
            {
                _studentUSI = value;
            }
        }

        private int _studentUSI;
        private string _studentUniqueId;

        public virtual string StudentUniqueId
        {
            get
            {
                if (_studentUniqueId == null)
                    _studentUniqueId = PersonUniqueIdToUsiCache.GetCache().GetUniqueId("Student", _studentUSI);
                    
                return _studentUniqueId;
            }
            set
            {
                _studentUniqueId = value;
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, SqlServerDateTimeRange]
        public virtual DateTime ApplicationDeadline 
        {
            get { return _applicationDeadline; }
            //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
            set { _applicationDeadline = new DateTime(value.Year, value.Month, value.Day); }
        }

        private DateTime _applicationDeadline;
        
        [RequiredWithNonDefault, SqlServerDateTimeRange]
        public virtual DateTime ApplicationModified 
        {
            get { return _applicationModified; }
            //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
            set { _applicationModified = new DateTime(value.Year, value.Month, value.Day); }
        }

        private DateTime _applicationModified;
        
        [RequiredWithNonDefault]
        public virtual int ApplicationStatusTypeId 
        {
            get
            {
                if (_applicationStatusTypeId == default(int))
                    _applicationStatusTypeId = TypesAndDescriptorsCache.GetCache().GetId("ApplicationStatusType", _applicationStatusType);

                return _applicationStatusTypeId;
            } 
            set
            {
                _applicationStatusTypeId = value;
                _applicationStatusType = null;
            }
        }

        private int _applicationStatusTypeId;
        private string _applicationStatusType;

        public virtual string ApplicationStatusType
        {
            get
            {
                if (_applicationStatusType == null)
                    _applicationStatusType = TypesAndDescriptorsCache.GetCache().GetValue("ApplicationStatusType", _applicationStatusTypeId);
                    
                return _applicationStatusType;
            }
            set
            {
                _applicationStatusType = value;
                _applicationStatusTypeId = default(int);
            }
        }
        [RequiredWithNonDefault]
        public virtual int ApplyTexasApplicationTypeId 
        {
            get
            {
                if (_applyTexasApplicationTypeId == default(int))
                    _applyTexasApplicationTypeId = TypesAndDescriptorsCache.GetCache().GetId("ApplyTexasApplicationType", _applyTexasApplicationType);

                return _applyTexasApplicationTypeId;
            } 
            set
            {
                _applyTexasApplicationTypeId = value;
                _applyTexasApplicationType = null;
            }
        }

        private int _applyTexasApplicationTypeId;
        private string _applyTexasApplicationType;

        public virtual string ApplyTexasApplicationType
        {
            get
            {
                if (_applyTexasApplicationType == null)
                    _applyTexasApplicationType = TypesAndDescriptorsCache.GetCache().GetValue("ApplyTexasApplicationType", _applyTexasApplicationTypeId);
                    
                return _applyTexasApplicationType;
            }
            set
            {
                _applyTexasApplicationType = value;
                _applyTexasApplicationTypeId = default(int);
            }
        }
        public virtual bool? CollegeScholarshipApplication  { get; set; }
        public virtual int? CollegeScholarshipApplicationStatusTypeId 
        {
            get
            {
                if (_collegeScholarshipApplicationStatusTypeId == default(int?))
                    _collegeScholarshipApplicationStatusTypeId = string.IsNullOrWhiteSpace(_collegeScholarshipApplicationStatusType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("CollegeScholarshipApplicationStatusType", _collegeScholarshipApplicationStatusType);

                return _collegeScholarshipApplicationStatusTypeId;
            } 
            set
            {
                _collegeScholarshipApplicationStatusTypeId = value;
                _collegeScholarshipApplicationStatusType = null;
            }
        }

        private int? _collegeScholarshipApplicationStatusTypeId;
        private string _collegeScholarshipApplicationStatusType;

        public virtual string CollegeScholarshipApplicationStatusType
        {
            get
            {
                if (_collegeScholarshipApplicationStatusType == null)
                    _collegeScholarshipApplicationStatusType = _collegeScholarshipApplicationStatusTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("CollegeScholarshipApplicationStatusType", _collegeScholarshipApplicationStatusTypeId.Value);
                    
                return _collegeScholarshipApplicationStatusType;
            }
            set
            {
                _collegeScholarshipApplicationStatusType = value;
                _collegeScholarshipApplicationStatusTypeId = default(int?);
            }
        }
        [SqlServerDateTimeRange]
        public virtual DateTime? CollegeScholarshipDeadline 
        {
            get { return _collegeScholarshipDeadline; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _collegeScholarshipDeadline = null;
                } else
                {
                    var given = (DateTime) value;
                    _collegeScholarshipDeadline = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _collegeScholarshipDeadline;
        
        public virtual int? CollegeScholarshipPagesComplete  { get; set; }
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string DestinationCollege  { get; set; }
        public virtual int? EssaysTypeId 
        {
            get
            {
                if (_essaysTypeId == default(int?))
                    _essaysTypeId = string.IsNullOrWhiteSpace(_essaysType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("EssaysType", _essaysType);

                return _essaysTypeId;
            } 
            set
            {
                _essaysTypeId = value;
                _essaysType = null;
            }
        }

        private int? _essaysTypeId;
        private string _essaysType;

        public virtual string EssaysType
        {
            get
            {
                if (_essaysType == null)
                    _essaysType = _essaysTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("EssaysType", _essaysTypeId.Value);
                    
                return _essaysType;
            }
            set
            {
                _essaysType = value;
                _essaysTypeId = default(int?);
            }
        }
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string Session  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "ApplicationStatusType", new LookupColumnDetails { PropertyName = "ApplicationStatusTypeId", LookupTypeName = "ApplicationStatusType"} },
                { "ApplyTexasApplicationType", new LookupColumnDetails { PropertyName = "ApplyTexasApplicationTypeId", LookupTypeName = "ApplyTexasApplicationType"} },
                { "CollegeScholarshipApplicationStatusType", new LookupColumnDetails { PropertyName = "CollegeScholarshipApplicationStatusTypeId", LookupTypeName = "CollegeScholarshipApplicationStatusType"} },
                { "EssaysType", new LookupColumnDetails { PropertyName = "EssaysTypeId", LookupTypeName = "EssaysType"} },
                { "PostSecondaryEventCategoryType", new LookupColumnDetails { PropertyName = "PostSecondaryEventCategoryTypeId", LookupTypeName = "PostSecondaryEventCategoryType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("ApplicationId", ApplicationId);
            keyValues.Add("EventDate", EventDate);
            keyValues.Add("PostSecondaryEventCategoryTypeId", PostSecondaryEventCategoryTypeId);
            keyValues.Add("StudentUSI", StudentUSI);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IApplyTexasApplication>
        {
            return this.SynchronizeTo((IApplyTexasApplication)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IApplyTexasApplication) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isApplicationDeadlineSupported = true;
        bool IApplyTexasApplicationSynchronizationSourceSupport.IsApplicationDeadlineSupported 
        { 
            get { return _isApplicationDeadlineSupported; } 
            set { _isApplicationDeadlineSupported = value; }
        }

        private bool _isApplicationModifiedSupported = true;
        bool IApplyTexasApplicationSynchronizationSourceSupport.IsApplicationModifiedSupported 
        { 
            get { return _isApplicationModifiedSupported; } 
            set { _isApplicationModifiedSupported = value; }
        }

        private bool _isApplicationStatusTypeSupported = true;
        bool IApplyTexasApplicationSynchronizationSourceSupport.IsApplicationStatusTypeSupported 
        { 
            get { return _isApplicationStatusTypeSupported; } 
            set { _isApplicationStatusTypeSupported = value; }
        }

        private bool _isApplyTexasApplicationTypeSupported = true;
        bool IApplyTexasApplicationSynchronizationSourceSupport.IsApplyTexasApplicationTypeSupported 
        { 
            get { return _isApplyTexasApplicationTypeSupported; } 
            set { _isApplyTexasApplicationTypeSupported = value; }
        }

        private bool _isCollegeScholarshipApplicationSupported = true;
        bool IApplyTexasApplicationSynchronizationSourceSupport.IsCollegeScholarshipApplicationSupported 
        { 
            get { return _isCollegeScholarshipApplicationSupported; } 
            set { _isCollegeScholarshipApplicationSupported = value; }
        }

        private bool _isCollegeScholarshipApplicationStatusTypeSupported = true;
        bool IApplyTexasApplicationSynchronizationSourceSupport.IsCollegeScholarshipApplicationStatusTypeSupported 
        { 
            get { return _isCollegeScholarshipApplicationStatusTypeSupported; } 
            set { _isCollegeScholarshipApplicationStatusTypeSupported = value; }
        }

        private bool _isCollegeScholarshipDeadlineSupported = true;
        bool IApplyTexasApplicationSynchronizationSourceSupport.IsCollegeScholarshipDeadlineSupported 
        { 
            get { return _isCollegeScholarshipDeadlineSupported; } 
            set { _isCollegeScholarshipDeadlineSupported = value; }
        }

        private bool _isCollegeScholarshipPagesCompleteSupported = true;
        bool IApplyTexasApplicationSynchronizationSourceSupport.IsCollegeScholarshipPagesCompleteSupported 
        { 
            get { return _isCollegeScholarshipPagesCompleteSupported; } 
            set { _isCollegeScholarshipPagesCompleteSupported = value; }
        }

        private bool _isDestinationCollegeSupported = true;
        bool IApplyTexasApplicationSynchronizationSourceSupport.IsDestinationCollegeSupported 
        { 
            get { return _isDestinationCollegeSupported; } 
            set { _isDestinationCollegeSupported = value; }
        }

        private bool _isEssaysTypeSupported = true;
        bool IApplyTexasApplicationSynchronizationSourceSupport.IsEssaysTypeSupported 
        { 
            get { return _isEssaysTypeSupported; } 
            set { _isEssaysTypeSupported = value; }
        }

        private bool _isSessionSupported = true;
        bool IApplyTexasApplicationSynchronizationSourceSupport.IsSessionSupported 
        { 
            get { return _isSessionSupported; } 
            set { _isSessionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: ApplyTexasApplicationType

namespace EdFi.Ods.Entities.NHibernate.ApplyTexasApplicationTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the extension.ApplyTexasApplicationType table of the ApplyTexasApplicationType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class ApplyTexasApplicationType : AggregateRootWithCompositeKey, 
        IApplyTexasApplicationType, IApplyTexasApplicationTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IApplyTexasApplicationTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int ApplyTexasApplicationTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("ApplyTexasApplicationTypeId", ApplyTexasApplicationTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IApplyTexasApplicationType>
        {
            return this.SynchronizeTo((IApplyTexasApplicationType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IApplyTexasApplicationType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IApplyTexasApplicationTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IApplyTexasApplicationTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IApplyTexasApplicationTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: Assessment

namespace EdFi.Ods.Entities.NHibernate.AssessmentAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.Assessment table of the Assessment aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class Assessment : AggregateRootWithCompositeKey, 
        IAssessment, IAssessmentRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        public Assessment()
        {
           AssessmentContentStandardPersistentList = new List<AssessmentContentStandard>();
            AssessmentIdentificationCodes = new List<AssessmentIdentificationCode>();
            AssessmentLanguages = new List<AssessmentLanguage>();
            AssessmentPerformanceLevels = new List<AssessmentPerformanceLevel>();
            AssessmentPrograms = new List<AssessmentProgram>();
            AssessmentScores = new List<AssessmentScore>();
            AssessmentSections = new List<AssessmentSection>();

        }
// restore warnings for inheritance from classes marked Obsolete
#pragma warning restore 612, 618 
               
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string AssessmentTitle  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int AssessedGradeLevelDescriptorId 
        {
            get
            {
                if (_assessedGradeLevelDescriptorId == default(int))
                    _assessedGradeLevelDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("GradeLevelDescriptor", _assessedGradeLevelDescriptor);

                return _assessedGradeLevelDescriptorId;
            } 
            set
            {
                _assessedGradeLevelDescriptorId = value;
                _assessedGradeLevelDescriptor = null;
            }
        }

        private int _assessedGradeLevelDescriptorId;
        private string _assessedGradeLevelDescriptor;

        public virtual string AssessedGradeLevelDescriptor
        {
            get
            {
                if (_assessedGradeLevelDescriptor == null)
                    _assessedGradeLevelDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("GradeLevelDescriptor", _assessedGradeLevelDescriptorId);
                    
                return _assessedGradeLevelDescriptor;
            }
            set
            {
                _assessedGradeLevelDescriptor = value;
                _assessedGradeLevelDescriptorId = default(int);
            }
        }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int AcademicSubjectDescriptorId 
        {
            get
            {
                if (_academicSubjectDescriptorId == default(int))
                    _academicSubjectDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("AcademicSubjectDescriptor", _academicSubjectDescriptor);

                return _academicSubjectDescriptorId;
            } 
            set
            {
                _academicSubjectDescriptorId = value;
                _academicSubjectDescriptor = null;
            }
        }

        private int _academicSubjectDescriptorId;
        private string _academicSubjectDescriptor;

        public virtual string AcademicSubjectDescriptor
        {
            get
            {
                if (_academicSubjectDescriptor == null)
                    _academicSubjectDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("AcademicSubjectDescriptor", _academicSubjectDescriptorId);
                    
                return _academicSubjectDescriptor;
            }
            set
            {
                _academicSubjectDescriptor = value;
                _academicSubjectDescriptorId = default(int);
            }
        }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int Version  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        public virtual int? AssessmentCategoryDescriptorId 
        {
            get
            {
                if (_assessmentCategoryDescriptorId == default(int?))
                    _assessmentCategoryDescriptorId = string.IsNullOrWhiteSpace(_assessmentCategoryDescriptor) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("AssessmentCategoryDescriptor", _assessmentCategoryDescriptor);

                return _assessmentCategoryDescriptorId;
            } 
            set
            {
                _assessmentCategoryDescriptorId = value;
                _assessmentCategoryDescriptor = null;
            }
        }

        private int? _assessmentCategoryDescriptorId;
        private string _assessmentCategoryDescriptor;

        public virtual string AssessmentCategoryDescriptor
        {
            get
            {
                if (_assessmentCategoryDescriptor == null)
                    _assessmentCategoryDescriptor = _assessmentCategoryDescriptorId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("AssessmentCategoryDescriptor", _assessmentCategoryDescriptorId.Value);
                    
                return _assessmentCategoryDescriptor;
            }
            set
            {
                _assessmentCategoryDescriptor = value;
                _assessmentCategoryDescriptorId = default(int?);
            }
        }
        [StringLength(60), NoDangerousText]
        public virtual string AssessmentFamilyTitle  { get; set; }
        [StringLength(60), NoDangerousText]
        public virtual string AssessmentForm  { get; set; }
        public virtual int? AssessmentPeriodDescriptorId 
        {
            get
            {
                if (_assessmentPeriodDescriptorId == default(int?))
                    _assessmentPeriodDescriptorId = string.IsNullOrWhiteSpace(_assessmentPeriodDescriptor) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("AssessmentPeriodDescriptor", _assessmentPeriodDescriptor);

                return _assessmentPeriodDescriptorId;
            } 
            set
            {
                _assessmentPeriodDescriptorId = value;
                _assessmentPeriodDescriptor = null;
            }
        }

        private int? _assessmentPeriodDescriptorId;
        private string _assessmentPeriodDescriptor;

        public virtual string AssessmentPeriodDescriptor
        {
            get
            {
                if (_assessmentPeriodDescriptor == null)
                    _assessmentPeriodDescriptor = _assessmentPeriodDescriptorId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("AssessmentPeriodDescriptor", _assessmentPeriodDescriptorId.Value);
                    
                return _assessmentPeriodDescriptor;
            }
            set
            {
                _assessmentPeriodDescriptor = value;
                _assessmentPeriodDescriptorId = default(int?);
            }
        }
        public virtual int? LowestAssessedGradeLevelDescriptorId 
        {
            get
            {
                if (_lowestAssessedGradeLevelDescriptorId == default(int?))
                    _lowestAssessedGradeLevelDescriptorId = string.IsNullOrWhiteSpace(_lowestAssessedGradeLevelDescriptor) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("GradeLevelDescriptor", _lowestAssessedGradeLevelDescriptor);

                return _lowestAssessedGradeLevelDescriptorId;
            } 
            set
            {
                _lowestAssessedGradeLevelDescriptorId = value;
                _lowestAssessedGradeLevelDescriptor = null;
            }
        }

        private int? _lowestAssessedGradeLevelDescriptorId;
        private string _lowestAssessedGradeLevelDescriptor;

        public virtual string LowestAssessedGradeLevelDescriptor
        {
            get
            {
                if (_lowestAssessedGradeLevelDescriptor == null)
                    _lowestAssessedGradeLevelDescriptor = _lowestAssessedGradeLevelDescriptorId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("GradeLevelDescriptor", _lowestAssessedGradeLevelDescriptorId.Value);
                    
                return _lowestAssessedGradeLevelDescriptor;
            }
            set
            {
                _lowestAssessedGradeLevelDescriptor = value;
                _lowestAssessedGradeLevelDescriptorId = default(int?);
            }
        }
        public virtual int? MaxRawScore  { get; set; }
        [StringLength(255), NoDangerousText]
        public virtual string Namespace  { get; set; }
        [StringLength(35), NoDangerousText]
        public virtual string Nomenclature  { get; set; }
        [SqlServerDateTimeRange]
        public virtual DateTime? RevisionDate 
        {
            get { return _revisionDate; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _revisionDate = null;
                } else
                {
                    var given = (DateTime) value;
                    _revisionDate = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _revisionDate;
        
        // -------------------------------------------------------------

        // =============================================================
        //                     One-to-one relationships
        // -------------------------------------------------------------
        [ValidateObject]
        public virtual AssessmentContentStandard AssessmentContentStandard
        {
            get
            {
                // Return the item in the list, if one exists
                if (AssessmentContentStandardPersistentList.Any())
                    return AssessmentContentStandardPersistentList[0];

                // No reference is present
                return null;
            }
            set
            {
                // Delete the existing object
                if (AssessmentContentStandardPersistentList.Any())
                    AssessmentContentStandardPersistentList.RemoveAt(0);

                // If we're setting a value, add it to the list now
                if (value != null)
                    AssessmentContentStandardPersistentList.Add(value);
            }
        }

        IAssessmentContentStandard IAssessment.AssessmentContentStandard
        {
            get { return AssessmentContentStandard; }
            set { AssessmentContentStandard = (AssessmentContentStandard) value; }
        }

        private IList<AssessmentContentStandard> _assessmentContentStandardPersistentList;

        public virtual IList<AssessmentContentStandard> AssessmentContentStandardPersistentList
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentContentStandardPersistentList)
                    if (item.Assessment == null)
                        item.Assessment = this;
                // -------------------------------------------------------------

                return _assessmentContentStandardPersistentList;
            }
            set
            {
                _assessmentContentStandardPersistentList = value;
            }
        }


        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------

        private IList<AssessmentIdentificationCode> _assessmentIdentificationCodes;
        private IList<IAssessmentIdentificationCode> _assessmentIdentificationCodesCovariant;
        [RequiredCollection]
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<AssessmentIdentificationCode> AssessmentIdentificationCodes
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentIdentificationCodes)
                    if (item.Assessment == null)
                        item.Assessment = this;
                // -------------------------------------------------------------

                return _assessmentIdentificationCodes;
            }
            set 
            { 
                _assessmentIdentificationCodes = value;
                _assessmentIdentificationCodesCovariant = new CovariantIListAdapter<IAssessmentIdentificationCode, AssessmentIdentificationCode>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<IAssessmentIdentificationCode> IAssessment.AssessmentIdentificationCodes
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentIdentificationCodes)
                    if (item.Assessment == null)
                        item.Assessment = this;
                // -------------------------------------------------------------

                return _assessmentIdentificationCodesCovariant; 
            }
            set 
            { 
                AssessmentIdentificationCodes = new List<AssessmentIdentificationCode>(value.Cast<AssessmentIdentificationCode>()); 
            }
        }


        private IList<AssessmentLanguage> _assessmentLanguages;
        private IList<IAssessmentLanguage> _assessmentLanguagesCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<AssessmentLanguage> AssessmentLanguages
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentLanguages)
                    if (item.Assessment == null)
                        item.Assessment = this;
                // -------------------------------------------------------------

                return _assessmentLanguages;
            }
            set 
            { 
                _assessmentLanguages = value;
                _assessmentLanguagesCovariant = new CovariantIListAdapter<IAssessmentLanguage, AssessmentLanguage>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<IAssessmentLanguage> IAssessment.AssessmentLanguages
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentLanguages)
                    if (item.Assessment == null)
                        item.Assessment = this;
                // -------------------------------------------------------------

                return _assessmentLanguagesCovariant; 
            }
            set 
            { 
                AssessmentLanguages = new List<AssessmentLanguage>(value.Cast<AssessmentLanguage>()); 
            }
        }


        private IList<AssessmentPerformanceLevel> _assessmentPerformanceLevels;
        private IList<IAssessmentPerformanceLevel> _assessmentPerformanceLevelsCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<AssessmentPerformanceLevel> AssessmentPerformanceLevels
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentPerformanceLevels)
                    if (item.Assessment == null)
                        item.Assessment = this;
                // -------------------------------------------------------------

                return _assessmentPerformanceLevels;
            }
            set 
            { 
                _assessmentPerformanceLevels = value;
                _assessmentPerformanceLevelsCovariant = new CovariantIListAdapter<IAssessmentPerformanceLevel, AssessmentPerformanceLevel>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<IAssessmentPerformanceLevel> IAssessment.AssessmentPerformanceLevels
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentPerformanceLevels)
                    if (item.Assessment == null)
                        item.Assessment = this;
                // -------------------------------------------------------------

                return _assessmentPerformanceLevelsCovariant; 
            }
            set 
            { 
                AssessmentPerformanceLevels = new List<AssessmentPerformanceLevel>(value.Cast<AssessmentPerformanceLevel>()); 
            }
        }


        private IList<AssessmentProgram> _assessmentPrograms;
        private IList<IAssessmentProgram> _assessmentProgramsCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<AssessmentProgram> AssessmentPrograms
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentPrograms)
                    if (item.Assessment == null)
                        item.Assessment = this;
                // -------------------------------------------------------------

                return _assessmentPrograms;
            }
            set 
            { 
                _assessmentPrograms = value;
                _assessmentProgramsCovariant = new CovariantIListAdapter<IAssessmentProgram, AssessmentProgram>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<IAssessmentProgram> IAssessment.AssessmentPrograms
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentPrograms)
                    if (item.Assessment == null)
                        item.Assessment = this;
                // -------------------------------------------------------------

                return _assessmentProgramsCovariant; 
            }
            set 
            { 
                AssessmentPrograms = new List<AssessmentProgram>(value.Cast<AssessmentProgram>()); 
            }
        }


        private IList<AssessmentScore> _assessmentScores;
        private IList<IAssessmentScore> _assessmentScoresCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<AssessmentScore> AssessmentScores
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentScores)
                    if (item.Assessment == null)
                        item.Assessment = this;
                // -------------------------------------------------------------

                return _assessmentScores;
            }
            set 
            { 
                _assessmentScores = value;
                _assessmentScoresCovariant = new CovariantIListAdapter<IAssessmentScore, AssessmentScore>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<IAssessmentScore> IAssessment.AssessmentScores
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentScores)
                    if (item.Assessment == null)
                        item.Assessment = this;
                // -------------------------------------------------------------

                return _assessmentScoresCovariant; 
            }
            set 
            { 
                AssessmentScores = new List<AssessmentScore>(value.Cast<AssessmentScore>()); 
            }
        }


        private IList<AssessmentSection> _assessmentSections;
        private IList<IAssessmentSection> _assessmentSectionsCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<AssessmentSection> AssessmentSections
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentSections)
                    if (item.Assessment == null)
                        item.Assessment = this;
                // -------------------------------------------------------------

                return _assessmentSections;
            }
            set 
            { 
                _assessmentSections = value;
                _assessmentSectionsCovariant = new CovariantIListAdapter<IAssessmentSection, AssessmentSection>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<IAssessmentSection> IAssessment.AssessmentSections
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentSections)
                    if (item.Assessment == null)
                        item.Assessment = this;
                // -------------------------------------------------------------

                return _assessmentSectionsCovariant; 
            }
            set 
            { 
                AssessmentSections = new List<AssessmentSection>(value.Cast<AssessmentSection>()); 
            }
        }

        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
                { "AssessedGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "AssessedGradeLevelDescriptorId", LookupTypeName = "AssessedGradeLevelDescriptor"} },
                { "AssessmentCategoryDescriptor", new LookupColumnDetails { PropertyName = "AssessmentCategoryDescriptorId", LookupTypeName = "AssessmentCategoryDescriptor"} },
                { "AssessmentPeriodDescriptor", new LookupColumnDetails { PropertyName = "AssessmentPeriodDescriptorId", LookupTypeName = "AssessmentPeriodDescriptor"} },
                { "LowestAssessedGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "LowestAssessedGradeLevelDescriptorId", LookupTypeName = "LowestAssessedGradeLevelDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AcademicSubjectDescriptorId", AcademicSubjectDescriptorId);
            keyValues.Add("AssessedGradeLevelDescriptorId", AssessedGradeLevelDescriptorId);
            keyValues.Add("AssessmentTitle", AssessmentTitle);
            keyValues.Add("Version", Version);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessment>
        {
            return this.SynchronizeTo((IAssessment)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessment) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAssessmentCategoryDescriptorSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsAssessmentCategoryDescriptorSupported 
        { 
            get { return _isAssessmentCategoryDescriptorSupported; } 
            set { _isAssessmentCategoryDescriptorSupported = value; }
        }

        private bool _isAssessmentContentStandardSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsAssessmentContentStandardSupported 
        { 
            get { return _isAssessmentContentStandardSupported; } 
            set { _isAssessmentContentStandardSupported = value; }
        }

        private bool _isAssessmentFamilyTitleSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsAssessmentFamilyTitleSupported 
        { 
            get { return _isAssessmentFamilyTitleSupported; } 
            set { _isAssessmentFamilyTitleSupported = value; }
        }

        private bool _isAssessmentFormSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsAssessmentFormSupported 
        { 
            get { return _isAssessmentFormSupported; } 
            set { _isAssessmentFormSupported = value; }
        }

        private bool _isAssessmentIdentificationCodesSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsAssessmentIdentificationCodesSupported 
        { 
            get { return _isAssessmentIdentificationCodesSupported; } 
            set { _isAssessmentIdentificationCodesSupported = value; }
        }

        private bool _isAssessmentLanguagesSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsAssessmentLanguagesSupported 
        { 
            get { return _isAssessmentLanguagesSupported; } 
            set { _isAssessmentLanguagesSupported = value; }
        }

        private bool _isAssessmentPerformanceLevelsSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsAssessmentPerformanceLevelsSupported 
        { 
            get { return _isAssessmentPerformanceLevelsSupported; } 
            set { _isAssessmentPerformanceLevelsSupported = value; }
        }

        private bool _isAssessmentPeriodDescriptorSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsAssessmentPeriodDescriptorSupported 
        { 
            get { return _isAssessmentPeriodDescriptorSupported; } 
            set { _isAssessmentPeriodDescriptorSupported = value; }
        }

        private bool _isAssessmentProgramsSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsAssessmentProgramsSupported 
        { 
            get { return _isAssessmentProgramsSupported; } 
            set { _isAssessmentProgramsSupported = value; }
        }

        private bool _isAssessmentScoresSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsAssessmentScoresSupported 
        { 
            get { return _isAssessmentScoresSupported; } 
            set { _isAssessmentScoresSupported = value; }
        }

        private bool _isAssessmentSectionsSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsAssessmentSectionsSupported 
        { 
            get { return _isAssessmentSectionsSupported; } 
            set { _isAssessmentSectionsSupported = value; }
        }

        private bool _isLowestAssessedGradeLevelDescriptorSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsLowestAssessedGradeLevelDescriptorSupported 
        { 
            get { return _isLowestAssessedGradeLevelDescriptorSupported; } 
            set { _isLowestAssessedGradeLevelDescriptorSupported = value; }
        }

        private bool _isMaxRawScoreSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsMaxRawScoreSupported 
        { 
            get { return _isMaxRawScoreSupported; } 
            set { _isMaxRawScoreSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isNomenclatureSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsNomenclatureSupported 
        { 
            get { return _isNomenclatureSupported; } 
            set { _isNomenclatureSupported = value; }
        }

        private bool _isRevisionDateSupported = true;
        bool IAssessmentSynchronizationSourceSupport.IsRevisionDateSupported 
        { 
            get { return _isRevisionDateSupported; } 
            set { _isRevisionDateSupported = value; }
        }

        private Func<IAssessmentIdentificationCode, bool> _isAssessmentIdentificationCodeIncluded;
        Func<IAssessmentIdentificationCode, bool> IAssessmentSynchronizationSourceSupport.IsAssessmentIdentificationCodeIncluded
        { 
            get { return _isAssessmentIdentificationCodeIncluded; } 
            set { _isAssessmentIdentificationCodeIncluded = value; }
        }

        private Func<IAssessmentLanguage, bool> _isAssessmentLanguageIncluded;
        Func<IAssessmentLanguage, bool> IAssessmentSynchronizationSourceSupport.IsAssessmentLanguageIncluded
        { 
            get { return _isAssessmentLanguageIncluded; } 
            set { _isAssessmentLanguageIncluded = value; }
        }

        private Func<IAssessmentPerformanceLevel, bool> _isAssessmentPerformanceLevelIncluded;
        Func<IAssessmentPerformanceLevel, bool> IAssessmentSynchronizationSourceSupport.IsAssessmentPerformanceLevelIncluded
        { 
            get { return _isAssessmentPerformanceLevelIncluded; } 
            set { _isAssessmentPerformanceLevelIncluded = value; }
        }

        private Func<IAssessmentProgram, bool> _isAssessmentProgramIncluded;
        Func<IAssessmentProgram, bool> IAssessmentSynchronizationSourceSupport.IsAssessmentProgramIncluded
        { 
            get { return _isAssessmentProgramIncluded; } 
            set { _isAssessmentProgramIncluded = value; }
        }

        private Func<IAssessmentScore, bool> _isAssessmentScoreIncluded;
        Func<IAssessmentScore, bool> IAssessmentSynchronizationSourceSupport.IsAssessmentScoreIncluded
        { 
            get { return _isAssessmentScoreIncluded; } 
            set { _isAssessmentScoreIncluded = value; }
        }

        private Func<IAssessmentSection, bool> _isAssessmentSectionIncluded;
        Func<IAssessmentSection, bool> IAssessmentSynchronizationSourceSupport.IsAssessmentSectionIncluded
        { 
            get { return _isAssessmentSectionIncluded; } 
            set { _isAssessmentSectionIncluded = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentLanguage table of the Assessment aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentLanguage : EntityWithCompositeKey, IChildEntity, 
        IAssessmentLanguage, IAssessmentLanguageRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentLanguageSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual Assessment Assessment { get; set; }

        IAssessment IAssessmentLanguage.Assessment
        {
            get { return Assessment; }
            set { Assessment = (Assessment) value; }
        }

        string IAssessmentLanguageRecord.AssessmentTitle
        {
            get { return ((IAssessmentRecord) Assessment).AssessmentTitle; }
            set { ((IAssessmentRecord) Assessment).AssessmentTitle = value; }
        }


        int IAssessmentLanguageRecord.AssessedGradeLevelDescriptorId
        {
            get { return ((IAssessmentRecord) Assessment).AssessedGradeLevelDescriptorId; }
            set { ((IAssessmentRecord) Assessment).AssessedGradeLevelDescriptorId = value; }
        }


        int IAssessmentLanguageRecord.AcademicSubjectDescriptorId
        {
            get { return ((IAssessmentRecord) Assessment).AcademicSubjectDescriptorId; }
            set { ((IAssessmentRecord) Assessment).AcademicSubjectDescriptorId = value; }
        }


        int IAssessmentLanguageRecord.Version
        {
            get { return ((IAssessmentRecord) Assessment).Version; }
            set { ((IAssessmentRecord) Assessment).Version = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int LanguageDescriptorId 
        {
            get
            {
                if (_languageDescriptorId == default(int))
                    _languageDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("LanguageDescriptor", _languageDescriptor);

                return _languageDescriptorId;
            } 
            set
            {
                _languageDescriptorId = value;
                _languageDescriptor = null;
            }
        }

        private int _languageDescriptorId;
        private string _languageDescriptor;

        public virtual string LanguageDescriptor
        {
            get
            {
                if (_languageDescriptor == null)
                    _languageDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("LanguageDescriptor", _languageDescriptorId);
                    
                return _languageDescriptor;
            }
            set
            {
                _languageDescriptor = value;
                _languageDescriptorId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
                { "AssessedGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "AssessedGradeLevelDescriptorId", LookupTypeName = "AssessedGradeLevelDescriptor"} },
                { "LanguageDescriptor", new LookupColumnDetails { PropertyName = "LanguageDescriptorId", LookupTypeName = "LanguageDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (Assessment as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("LanguageDescriptorId", LanguageDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentLanguage>
        {
            return this.SynchronizeTo((IAssessmentLanguage)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentLanguage) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            Assessment = (Assessment) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentScore table of the Assessment aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentScore : EntityWithCompositeKey, IChildEntity, 
        IAssessmentScore, IAssessmentScoreRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentScoreSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual Assessment Assessment { get; set; }

        IAssessment IAssessmentScore.Assessment
        {
            get { return Assessment; }
            set { Assessment = (Assessment) value; }
        }

        string IAssessmentScoreRecord.AssessmentTitle
        {
            get { return ((IAssessmentRecord) Assessment).AssessmentTitle; }
            set { ((IAssessmentRecord) Assessment).AssessmentTitle = value; }
        }


        int IAssessmentScoreRecord.AssessedGradeLevelDescriptorId
        {
            get { return ((IAssessmentRecord) Assessment).AssessedGradeLevelDescriptorId; }
            set { ((IAssessmentRecord) Assessment).AssessedGradeLevelDescriptorId = value; }
        }


        int IAssessmentScoreRecord.AcademicSubjectDescriptorId
        {
            get { return ((IAssessmentRecord) Assessment).AcademicSubjectDescriptorId; }
            set { ((IAssessmentRecord) Assessment).AcademicSubjectDescriptorId = value; }
        }


        int IAssessmentScoreRecord.Version
        {
            get { return ((IAssessmentRecord) Assessment).Version; }
            set { ((IAssessmentRecord) Assessment).Version = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int AssessmentReportingMethodTypeId 
        {
            get
            {
                if (_assessmentReportingMethodTypeId == default(int))
                    _assessmentReportingMethodTypeId = TypesAndDescriptorsCache.GetCache().GetId("AssessmentReportingMethodType", _assessmentReportingMethodType);

                return _assessmentReportingMethodTypeId;
            } 
            set
            {
                _assessmentReportingMethodTypeId = value;
                _assessmentReportingMethodType = null;
            }
        }

        private int _assessmentReportingMethodTypeId;
        private string _assessmentReportingMethodType;

        public virtual string AssessmentReportingMethodType
        {
            get
            {
                if (_assessmentReportingMethodType == null)
                    _assessmentReportingMethodType = TypesAndDescriptorsCache.GetCache().GetValue("AssessmentReportingMethodType", _assessmentReportingMethodTypeId);
                    
                return _assessmentReportingMethodType;
            }
            set
            {
                _assessmentReportingMethodType = value;
                _assessmentReportingMethodTypeId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [StringLength(35), NoDangerousText]
        public virtual string MaximumScore  { get; set; }
        [StringLength(35), NoDangerousText]
        public virtual string MinimumScore  { get; set; }
        public virtual int? ResultDatatypeTypeId 
        {
            get
            {
                if (_resultDatatypeTypeId == default(int?))
                    _resultDatatypeTypeId = string.IsNullOrWhiteSpace(_resultDatatypeType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("ResultDatatypeType", _resultDatatypeType);

                return _resultDatatypeTypeId;
            } 
            set
            {
                _resultDatatypeTypeId = value;
                _resultDatatypeType = null;
            }
        }

        private int? _resultDatatypeTypeId;
        private string _resultDatatypeType;

        public virtual string ResultDatatypeType
        {
            get
            {
                if (_resultDatatypeType == null)
                    _resultDatatypeType = _resultDatatypeTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("ResultDatatypeType", _resultDatatypeTypeId.Value);
                    
                return _resultDatatypeType;
            }
            set
            {
                _resultDatatypeType = value;
                _resultDatatypeTypeId = default(int?);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
                { "AssessedGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "AssessedGradeLevelDescriptorId", LookupTypeName = "AssessedGradeLevelDescriptor"} },
                { "AssessmentReportingMethodType", new LookupColumnDetails { PropertyName = "AssessmentReportingMethodTypeId", LookupTypeName = "AssessmentReportingMethodType"} },
                { "ResultDatatypeType", new LookupColumnDetails { PropertyName = "ResultDatatypeTypeId", LookupTypeName = "ResultDatatypeType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (Assessment as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("AssessmentReportingMethodTypeId", AssessmentReportingMethodTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentScore>
        {
            return this.SynchronizeTo((IAssessmentScore)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentScore) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            Assessment = (Assessment) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isMaximumScoreSupported = true;
        bool IAssessmentScoreSynchronizationSourceSupport.IsMaximumScoreSupported 
        { 
            get { return _isMaximumScoreSupported; } 
            set { _isMaximumScoreSupported = value; }
        }

        private bool _isMinimumScoreSupported = true;
        bool IAssessmentScoreSynchronizationSourceSupport.IsMinimumScoreSupported 
        { 
            get { return _isMinimumScoreSupported; } 
            set { _isMinimumScoreSupported = value; }
        }

        private bool _isResultDatatypeTypeSupported = true;
        bool IAssessmentScoreSynchronizationSourceSupport.IsResultDatatypeTypeSupported 
        { 
            get { return _isResultDatatypeTypeSupported; } 
            set { _isResultDatatypeTypeSupported = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentContentStandard table of the Assessment aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentContentStandard : EntityWithCompositeKey, IChildEntity, 
        IAssessmentContentStandard, IAssessmentContentStandardRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentContentStandardSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        public AssessmentContentStandard()
        {
            AssessmentContentStandardAuthors = new List<AssessmentContentStandardAuthor>();

        }
// restore warnings for inheritance from classes marked Obsolete
#pragma warning restore 612, 618 
               
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual Assessment Assessment { get; set; }

        IAssessment IAssessmentContentStandard.Assessment
        {
            get { return Assessment; }
            set { Assessment = (Assessment) value; }
        }

        string IAssessmentContentStandardRecord.AssessmentTitle
        {
            get { return ((IAssessmentRecord) Assessment).AssessmentTitle; }
            set { ((IAssessmentRecord) Assessment).AssessmentTitle = value; }
        }


        int IAssessmentContentStandardRecord.AssessedGradeLevelDescriptorId
        {
            get { return ((IAssessmentRecord) Assessment).AssessedGradeLevelDescriptorId; }
            set { ((IAssessmentRecord) Assessment).AssessedGradeLevelDescriptorId = value; }
        }


        int IAssessmentContentStandardRecord.AcademicSubjectDescriptorId
        {
            get { return ((IAssessmentRecord) Assessment).AcademicSubjectDescriptorId; }
            set { ((IAssessmentRecord) Assessment).AcademicSubjectDescriptorId = value; }
        }


        int IAssessmentContentStandardRecord.AssessmentVersion
        {
            get { return ((IAssessmentRecord) Assessment).Version; }
            set { ((IAssessmentRecord) Assessment).Version = value; }
        }


        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [SqlServerDateTimeRange]
        public virtual DateTime? BeginDate 
        {
            get { return _beginDate; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _beginDate = null;
                } else
                {
                    var given = (DateTime) value;
                    _beginDate = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _beginDate;
        
        [SqlServerDateTimeRange]
        public virtual DateTime? EndDate 
        {
            get { return _endDate; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _endDate = null;
                } else
                {
                    var given = (DateTime) value;
                    _endDate = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _endDate;
        
        public virtual int? MandatingEducationOrganizationId  { get; set; }
        [SqlServerDateTimeRange]
        public virtual DateTime? PublicationDate 
        {
            get { return _publicationDate; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _publicationDate = null;
                } else
                {
                    var given = (DateTime) value;
                    _publicationDate = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _publicationDate;
        
        public virtual int? PublicationStatusTypeId 
        {
            get
            {
                if (_publicationStatusTypeId == default(int?))
                    _publicationStatusTypeId = string.IsNullOrWhiteSpace(_publicationStatusType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("PublicationStatusType", _publicationStatusType);

                return _publicationStatusTypeId;
            } 
            set
            {
                _publicationStatusTypeId = value;
                _publicationStatusType = null;
            }
        }

        private int? _publicationStatusTypeId;
        private string _publicationStatusType;

        public virtual string PublicationStatusType
        {
            get
            {
                if (_publicationStatusType == null)
                    _publicationStatusType = _publicationStatusTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("PublicationStatusType", _publicationStatusTypeId.Value);
                    
                return _publicationStatusType;
            }
            set
            {
                _publicationStatusType = value;
                _publicationStatusTypeId = default(int?);
            }
        }
        public virtual short? PublicationYear  { get; set; }
        [RequiredWithNonDefault, StringLength(75), NoDangerousText]
        public virtual string Title  { get; set; }
        [StringLength(255), NoDangerousText]
        public virtual string URI  { get; set; }
        [StringLength(50), NoDangerousText]
        public virtual string Version  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------

        private IList<AssessmentContentStandardAuthor> _assessmentContentStandardAuthors;
        private IList<IAssessmentContentStandardAuthor> _assessmentContentStandardAuthorsCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<AssessmentContentStandardAuthor> AssessmentContentStandardAuthors
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentContentStandardAuthors)
                    if (item.AssessmentContentStandard == null)
                        item.AssessmentContentStandard = this;
                // -------------------------------------------------------------

                return _assessmentContentStandardAuthors;
            }
            set 
            { 
                _assessmentContentStandardAuthors = value;
                _assessmentContentStandardAuthorsCovariant = new CovariantIListAdapter<IAssessmentContentStandardAuthor, AssessmentContentStandardAuthor>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<IAssessmentContentStandardAuthor> IAssessmentContentStandard.AssessmentContentStandardAuthors
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentContentStandardAuthors)
                    if (item.AssessmentContentStandard == null)
                        item.AssessmentContentStandard = this;
                // -------------------------------------------------------------

                return _assessmentContentStandardAuthorsCovariant; 
            }
            set 
            { 
                AssessmentContentStandardAuthors = new List<AssessmentContentStandardAuthor>(value.Cast<AssessmentContentStandardAuthor>()); 
            }
        }

        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
                { "AssessedGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "AssessedGradeLevelDescriptorId", LookupTypeName = "AssessedGradeLevelDescriptor"} },
                { "PublicationStatusType", new LookupColumnDetails { PropertyName = "PublicationStatusTypeId", LookupTypeName = "PublicationStatusType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (Assessment as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentContentStandard>
        {
            return this.SynchronizeTo((IAssessmentContentStandard)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentContentStandard) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            Assessment = (Assessment) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAssessmentContentStandardAuthorsSupported = true;
        bool IAssessmentContentStandardSynchronizationSourceSupport.IsAssessmentContentStandardAuthorsSupported 
        { 
            get { return _isAssessmentContentStandardAuthorsSupported; } 
            set { _isAssessmentContentStandardAuthorsSupported = value; }
        }

        private bool _isBeginDateSupported = true;
        bool IAssessmentContentStandardSynchronizationSourceSupport.IsBeginDateSupported 
        { 
            get { return _isBeginDateSupported; } 
            set { _isBeginDateSupported = value; }
        }

        private bool _isEndDateSupported = true;
        bool IAssessmentContentStandardSynchronizationSourceSupport.IsEndDateSupported 
        { 
            get { return _isEndDateSupported; } 
            set { _isEndDateSupported = value; }
        }

        private bool _isMandatingEducationOrganizationIdSupported = true;
        bool IAssessmentContentStandardSynchronizationSourceSupport.IsMandatingEducationOrganizationIdSupported 
        { 
            get { return _isMandatingEducationOrganizationIdSupported; } 
            set { _isMandatingEducationOrganizationIdSupported = value; }
        }

        private bool _isPublicationDateSupported = true;
        bool IAssessmentContentStandardSynchronizationSourceSupport.IsPublicationDateSupported 
        { 
            get { return _isPublicationDateSupported; } 
            set { _isPublicationDateSupported = value; }
        }

        private bool _isPublicationStatusTypeSupported = true;
        bool IAssessmentContentStandardSynchronizationSourceSupport.IsPublicationStatusTypeSupported 
        { 
            get { return _isPublicationStatusTypeSupported; } 
            set { _isPublicationStatusTypeSupported = value; }
        }

        private bool _isPublicationYearSupported = true;
        bool IAssessmentContentStandardSynchronizationSourceSupport.IsPublicationYearSupported 
        { 
            get { return _isPublicationYearSupported; } 
            set { _isPublicationYearSupported = value; }
        }

        private bool _isTitleSupported = true;
        bool IAssessmentContentStandardSynchronizationSourceSupport.IsTitleSupported 
        { 
            get { return _isTitleSupported; } 
            set { _isTitleSupported = value; }
        }

        private bool _isURISupported = true;
        bool IAssessmentContentStandardSynchronizationSourceSupport.IsURISupported 
        { 
            get { return _isURISupported; } 
            set { _isURISupported = value; }
        }

        private bool _isVersionSupported = true;
        bool IAssessmentContentStandardSynchronizationSourceSupport.IsVersionSupported 
        { 
            get { return _isVersionSupported; } 
            set { _isVersionSupported = value; }
        }

        private Func<IAssessmentContentStandardAuthor, bool> _isAssessmentContentStandardAuthorIncluded;
        Func<IAssessmentContentStandardAuthor, bool> IAssessmentContentStandardSynchronizationSourceSupport.IsAssessmentContentStandardAuthorIncluded
        { 
            get { return _isAssessmentContentStandardAuthorIncluded; } 
            set { _isAssessmentContentStandardAuthorIncluded = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentContentStandardAuthor table of the Assessment aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentContentStandardAuthor : EntityWithCompositeKey, IChildEntity, 
        IAssessmentContentStandardAuthor, IAssessmentContentStandardAuthorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentContentStandardAuthorSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual AssessmentContentStandard AssessmentContentStandard { get; set; }

        IAssessmentContentStandard IAssessmentContentStandardAuthor.AssessmentContentStandard
        {
            get { return AssessmentContentStandard; }
            set { AssessmentContentStandard = (AssessmentContentStandard) value; }
        }

        int IAssessmentContentStandardAuthorRecord.AssessmentVersion
        {
            get { return ((IAssessmentContentStandardRecord) AssessmentContentStandard).AssessmentVersion; }
            set { ((IAssessmentContentStandardRecord) AssessmentContentStandard).AssessmentVersion = value; }
        }


        string IAssessmentContentStandardAuthorRecord.AssessmentTitle
        {
            get { return ((IAssessmentContentStandardRecord) AssessmentContentStandard).AssessmentTitle; }
            set { ((IAssessmentContentStandardRecord) AssessmentContentStandard).AssessmentTitle = value; }
        }


        int IAssessmentContentStandardAuthorRecord.AcademicSubjectDescriptorId
        {
            get { return ((IAssessmentContentStandardRecord) AssessmentContentStandard).AcademicSubjectDescriptorId; }
            set { ((IAssessmentContentStandardRecord) AssessmentContentStandard).AcademicSubjectDescriptorId = value; }
        }


        int IAssessmentContentStandardAuthorRecord.AssessedGradeLevelDescriptorId
        {
            get { return ((IAssessmentContentStandardRecord) AssessmentContentStandard).AssessedGradeLevelDescriptorId; }
            set { ((IAssessmentContentStandardRecord) AssessmentContentStandard).AssessedGradeLevelDescriptorId = value; }
        }


        [DomainSignature, RequiredWithNonDefault, StringLength(255), NoDangerousText]
        public virtual string Author  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
                { "AssessedGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "AssessedGradeLevelDescriptorId", LookupTypeName = "AssessedGradeLevelDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (AssessmentContentStandard as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("Author", Author);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentContentStandardAuthor>
        {
            return this.SynchronizeTo((IAssessmentContentStandardAuthor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentContentStandardAuthor) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            AssessmentContentStandard = (AssessmentContentStandard) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentIdentificationCode table of the Assessment aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentIdentificationCode : EntityWithCompositeKey, IChildEntity, 
        IAssessmentIdentificationCode, IAssessmentIdentificationCodeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentIdentificationCodeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual Assessment Assessment { get; set; }

        IAssessment IAssessmentIdentificationCode.Assessment
        {
            get { return Assessment; }
            set { Assessment = (Assessment) value; }
        }

        string IAssessmentIdentificationCodeRecord.AssessmentTitle
        {
            get { return ((IAssessmentRecord) Assessment).AssessmentTitle; }
            set { ((IAssessmentRecord) Assessment).AssessmentTitle = value; }
        }


        int IAssessmentIdentificationCodeRecord.AssessedGradeLevelDescriptorId
        {
            get { return ((IAssessmentRecord) Assessment).AssessedGradeLevelDescriptorId; }
            set { ((IAssessmentRecord) Assessment).AssessedGradeLevelDescriptorId = value; }
        }


        int IAssessmentIdentificationCodeRecord.AcademicSubjectDescriptorId
        {
            get { return ((IAssessmentRecord) Assessment).AcademicSubjectDescriptorId; }
            set { ((IAssessmentRecord) Assessment).AcademicSubjectDescriptorId = value; }
        }


        int IAssessmentIdentificationCodeRecord.Version
        {
            get { return ((IAssessmentRecord) Assessment).Version; }
            set { ((IAssessmentRecord) Assessment).Version = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int AssessmentIdentificationSystemDescriptorId 
        {
            get
            {
                if (_assessmentIdentificationSystemDescriptorId == default(int))
                    _assessmentIdentificationSystemDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("AssessmentIdentificationSystemDescriptor", _assessmentIdentificationSystemDescriptor);

                return _assessmentIdentificationSystemDescriptorId;
            } 
            set
            {
                _assessmentIdentificationSystemDescriptorId = value;
                _assessmentIdentificationSystemDescriptor = null;
            }
        }

        private int _assessmentIdentificationSystemDescriptorId;
        private string _assessmentIdentificationSystemDescriptor;

        public virtual string AssessmentIdentificationSystemDescriptor
        {
            get
            {
                if (_assessmentIdentificationSystemDescriptor == null)
                    _assessmentIdentificationSystemDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("AssessmentIdentificationSystemDescriptor", _assessmentIdentificationSystemDescriptorId);
                    
                return _assessmentIdentificationSystemDescriptor;
            }
            set
            {
                _assessmentIdentificationSystemDescriptor = value;
                _assessmentIdentificationSystemDescriptorId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [StringLength(60), NoDangerousText]
        public virtual string AssigningOrganizationIdentificationCode  { get; set; }
        [RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string IdentificationCode  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
                { "AssessedGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "AssessedGradeLevelDescriptorId", LookupTypeName = "AssessedGradeLevelDescriptor"} },
                { "AssessmentIdentificationSystemDescriptor", new LookupColumnDetails { PropertyName = "AssessmentIdentificationSystemDescriptorId", LookupTypeName = "AssessmentIdentificationSystemDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (Assessment as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("AssessmentIdentificationSystemDescriptorId", AssessmentIdentificationSystemDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentIdentificationCode>
        {
            return this.SynchronizeTo((IAssessmentIdentificationCode)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentIdentificationCode) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            Assessment = (Assessment) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAssigningOrganizationIdentificationCodeSupported = true;
        bool IAssessmentIdentificationCodeSynchronizationSourceSupport.IsAssigningOrganizationIdentificationCodeSupported 
        { 
            get { return _isAssigningOrganizationIdentificationCodeSupported; } 
            set { _isAssigningOrganizationIdentificationCodeSupported = value; }
        }

        private bool _isIdentificationCodeSupported = true;
        bool IAssessmentIdentificationCodeSynchronizationSourceSupport.IsIdentificationCodeSupported 
        { 
            get { return _isIdentificationCodeSupported; } 
            set { _isIdentificationCodeSupported = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentPerformanceLevel table of the Assessment aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentPerformanceLevel : EntityWithCompositeKey, IChildEntity, 
        IAssessmentPerformanceLevel, IAssessmentPerformanceLevelRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentPerformanceLevelSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual Assessment Assessment { get; set; }

        IAssessment IAssessmentPerformanceLevel.Assessment
        {
            get { return Assessment; }
            set { Assessment = (Assessment) value; }
        }

        string IAssessmentPerformanceLevelRecord.AssessmentTitle
        {
            get { return ((IAssessmentRecord) Assessment).AssessmentTitle; }
            set { ((IAssessmentRecord) Assessment).AssessmentTitle = value; }
        }


        int IAssessmentPerformanceLevelRecord.AssessedGradeLevelDescriptorId
        {
            get { return ((IAssessmentRecord) Assessment).AssessedGradeLevelDescriptorId; }
            set { ((IAssessmentRecord) Assessment).AssessedGradeLevelDescriptorId = value; }
        }


        int IAssessmentPerformanceLevelRecord.AcademicSubjectDescriptorId
        {
            get { return ((IAssessmentRecord) Assessment).AcademicSubjectDescriptorId; }
            set { ((IAssessmentRecord) Assessment).AcademicSubjectDescriptorId = value; }
        }


        int IAssessmentPerformanceLevelRecord.Version
        {
            get { return ((IAssessmentRecord) Assessment).Version; }
            set { ((IAssessmentRecord) Assessment).Version = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int PerformanceLevelDescriptorId 
        {
            get
            {
                if (_performanceLevelDescriptorId == default(int))
                    _performanceLevelDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("PerformanceLevelDescriptor", _performanceLevelDescriptor);

                return _performanceLevelDescriptorId;
            } 
            set
            {
                _performanceLevelDescriptorId = value;
                _performanceLevelDescriptor = null;
            }
        }

        private int _performanceLevelDescriptorId;
        private string _performanceLevelDescriptor;

        public virtual string PerformanceLevelDescriptor
        {
            get
            {
                if (_performanceLevelDescriptor == null)
                    _performanceLevelDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("PerformanceLevelDescriptor", _performanceLevelDescriptorId);
                    
                return _performanceLevelDescriptor;
            }
            set
            {
                _performanceLevelDescriptor = value;
                _performanceLevelDescriptorId = default(int);
            }
        }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int AssessmentReportingMethodTypeId 
        {
            get
            {
                if (_assessmentReportingMethodTypeId == default(int))
                    _assessmentReportingMethodTypeId = TypesAndDescriptorsCache.GetCache().GetId("AssessmentReportingMethodType", _assessmentReportingMethodType);

                return _assessmentReportingMethodTypeId;
            } 
            set
            {
                _assessmentReportingMethodTypeId = value;
                _assessmentReportingMethodType = null;
            }
        }

        private int _assessmentReportingMethodTypeId;
        private string _assessmentReportingMethodType;

        public virtual string AssessmentReportingMethodType
        {
            get
            {
                if (_assessmentReportingMethodType == null)
                    _assessmentReportingMethodType = TypesAndDescriptorsCache.GetCache().GetValue("AssessmentReportingMethodType", _assessmentReportingMethodTypeId);
                    
                return _assessmentReportingMethodType;
            }
            set
            {
                _assessmentReportingMethodType = value;
                _assessmentReportingMethodTypeId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [StringLength(35), NoDangerousText]
        public virtual string MaximumScore  { get; set; }
        [StringLength(35), NoDangerousText]
        public virtual string MinimumScore  { get; set; }
        public virtual int? ResultDatatypeTypeId 
        {
            get
            {
                if (_resultDatatypeTypeId == default(int?))
                    _resultDatatypeTypeId = string.IsNullOrWhiteSpace(_resultDatatypeType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("ResultDatatypeType", _resultDatatypeType);

                return _resultDatatypeTypeId;
            } 
            set
            {
                _resultDatatypeTypeId = value;
                _resultDatatypeType = null;
            }
        }

        private int? _resultDatatypeTypeId;
        private string _resultDatatypeType;

        public virtual string ResultDatatypeType
        {
            get
            {
                if (_resultDatatypeType == null)
                    _resultDatatypeType = _resultDatatypeTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("ResultDatatypeType", _resultDatatypeTypeId.Value);
                    
                return _resultDatatypeType;
            }
            set
            {
                _resultDatatypeType = value;
                _resultDatatypeTypeId = default(int?);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
                { "AssessedGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "AssessedGradeLevelDescriptorId", LookupTypeName = "AssessedGradeLevelDescriptor"} },
                { "AssessmentReportingMethodType", new LookupColumnDetails { PropertyName = "AssessmentReportingMethodTypeId", LookupTypeName = "AssessmentReportingMethodType"} },
                { "PerformanceLevelDescriptor", new LookupColumnDetails { PropertyName = "PerformanceLevelDescriptorId", LookupTypeName = "PerformanceLevelDescriptor"} },
                { "ResultDatatypeType", new LookupColumnDetails { PropertyName = "ResultDatatypeTypeId", LookupTypeName = "ResultDatatypeType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (Assessment as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("AssessmentReportingMethodTypeId", AssessmentReportingMethodTypeId);
            keyValues.Add("PerformanceLevelDescriptorId", PerformanceLevelDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentPerformanceLevel>
        {
            return this.SynchronizeTo((IAssessmentPerformanceLevel)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentPerformanceLevel) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            Assessment = (Assessment) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isMaximumScoreSupported = true;
        bool IAssessmentPerformanceLevelSynchronizationSourceSupport.IsMaximumScoreSupported 
        { 
            get { return _isMaximumScoreSupported; } 
            set { _isMaximumScoreSupported = value; }
        }

        private bool _isMinimumScoreSupported = true;
        bool IAssessmentPerformanceLevelSynchronizationSourceSupport.IsMinimumScoreSupported 
        { 
            get { return _isMinimumScoreSupported; } 
            set { _isMinimumScoreSupported = value; }
        }

        private bool _isResultDatatypeTypeSupported = true;
        bool IAssessmentPerformanceLevelSynchronizationSourceSupport.IsResultDatatypeTypeSupported 
        { 
            get { return _isResultDatatypeTypeSupported; } 
            set { _isResultDatatypeTypeSupported = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentSection table of the Assessment aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentSection : EntityWithCompositeKey, IChildEntity, 
        IAssessmentSection, IAssessmentSectionRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentSectionSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual Assessment Assessment { get; set; }

        IAssessment IAssessmentSection.Assessment
        {
            get { return Assessment; }
            set { Assessment = (Assessment) value; }
        }

        string IAssessmentSectionRecord.AssessmentTitle
        {
            get { return ((IAssessmentRecord) Assessment).AssessmentTitle; }
            set { ((IAssessmentRecord) Assessment).AssessmentTitle = value; }
        }


        int IAssessmentSectionRecord.AssessedGradeLevelDescriptorId
        {
            get { return ((IAssessmentRecord) Assessment).AssessedGradeLevelDescriptorId; }
            set { ((IAssessmentRecord) Assessment).AssessedGradeLevelDescriptorId = value; }
        }


        int IAssessmentSectionRecord.AcademicSubjectDescriptorId
        {
            get { return ((IAssessmentRecord) Assessment).AcademicSubjectDescriptorId; }
            set { ((IAssessmentRecord) Assessment).AcademicSubjectDescriptorId = value; }
        }


        int IAssessmentSectionRecord.Version
        {
            get { return ((IAssessmentRecord) Assessment).Version; }
            set { ((IAssessmentRecord) Assessment).Version = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int SchoolId  { get; set; }
        [DomainSignature, RequiredWithNonDefault, StringLength(20), NoDangerousText]
        public virtual string ClassPeriodName  { get; set; }
        [DomainSignature, RequiredWithNonDefault, StringLength(20), NoDangerousText]
        public virtual string ClassroomIdentificationCode  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual short SchoolYear  { get; set; }
        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string LocalCourseCode  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int TermDescriptorId 
        {
            get
            {
                if (_termDescriptorId == default(int))
                    _termDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("TermDescriptor", _termDescriptor);

                return _termDescriptorId;
            } 
            set
            {
                _termDescriptorId = value;
                _termDescriptor = null;
            }
        }

        private int _termDescriptorId;
        private string _termDescriptor;

        public virtual string TermDescriptor
        {
            get
            {
                if (_termDescriptor == null)
                    _termDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("TermDescriptor", _termDescriptorId);
                    
                return _termDescriptor;
            }
            set
            {
                _termDescriptor = value;
                _termDescriptorId = default(int);
            }
        }
        [DomainSignature, RequiredWithNonDefault, StringLength(255), NoDangerousText]
        public virtual string UniqueSectionCode  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int SequenceOfCourse  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
                { "AssessedGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "AssessedGradeLevelDescriptorId", LookupTypeName = "AssessedGradeLevelDescriptor"} },
                { "TermDescriptor", new LookupColumnDetails { PropertyName = "TermDescriptorId", LookupTypeName = "TermDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (Assessment as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("ClassPeriodName", ClassPeriodName);
            keyValues.Add("ClassroomIdentificationCode", ClassroomIdentificationCode);
            keyValues.Add("LocalCourseCode", LocalCourseCode);
            keyValues.Add("SchoolId", SchoolId);
            keyValues.Add("SchoolYear", SchoolYear);
            keyValues.Add("SequenceOfCourse", SequenceOfCourse);
            keyValues.Add("TermDescriptorId", TermDescriptorId);
            keyValues.Add("UniqueSectionCode", UniqueSectionCode);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentSection>
        {
            return this.SynchronizeTo((IAssessmentSection)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentSection) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            Assessment = (Assessment) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentProgram table of the Assessment aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentProgram : EntityWithCompositeKey, IChildEntity, 
        IAssessmentProgram, IAssessmentProgramRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentProgramSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual Assessment Assessment { get; set; }

        IAssessment IAssessmentProgram.Assessment
        {
            get { return Assessment; }
            set { Assessment = (Assessment) value; }
        }

        string IAssessmentProgramRecord.AssessmentTitle
        {
            get { return ((IAssessmentRecord) Assessment).AssessmentTitle; }
            set { ((IAssessmentRecord) Assessment).AssessmentTitle = value; }
        }


        int IAssessmentProgramRecord.AssessedGradeLevelDescriptorId
        {
            get { return ((IAssessmentRecord) Assessment).AssessedGradeLevelDescriptorId; }
            set { ((IAssessmentRecord) Assessment).AssessedGradeLevelDescriptorId = value; }
        }


        int IAssessmentProgramRecord.AcademicSubjectDescriptorId
        {
            get { return ((IAssessmentRecord) Assessment).AcademicSubjectDescriptorId; }
            set { ((IAssessmentRecord) Assessment).AcademicSubjectDescriptorId = value; }
        }


        int IAssessmentProgramRecord.Version
        {
            get { return ((IAssessmentRecord) Assessment).Version; }
            set { ((IAssessmentRecord) Assessment).Version = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int EducationOrganizationId  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int ProgramTypeId 
        {
            get
            {
                if (_programTypeId == default(int))
                    _programTypeId = TypesAndDescriptorsCache.GetCache().GetId("ProgramType", _programType);

                return _programTypeId;
            } 
            set
            {
                _programTypeId = value;
                _programType = null;
            }
        }

        private int _programTypeId;
        private string _programType;

        public virtual string ProgramType
        {
            get
            {
                if (_programType == null)
                    _programType = TypesAndDescriptorsCache.GetCache().GetValue("ProgramType", _programTypeId);
                    
                return _programType;
            }
            set
            {
                _programType = value;
                _programTypeId = default(int);
            }
        }
        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string ProgramName  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
                { "AssessedGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "AssessedGradeLevelDescriptorId", LookupTypeName = "AssessedGradeLevelDescriptor"} },
                { "ProgramType", new LookupColumnDetails { PropertyName = "ProgramTypeId", LookupTypeName = "ProgramType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (Assessment as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("EducationOrganizationId", EducationOrganizationId);
            keyValues.Add("ProgramName", ProgramName);
            keyValues.Add("ProgramTypeId", ProgramTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentProgram>
        {
            return this.SynchronizeTo((IAssessmentProgram)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentProgram) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            Assessment = (Assessment) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 
}
// Aggregate: AssessmentCategoryDescriptor

namespace EdFi.Ods.Entities.NHibernate.AssessmentCategoryDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentCategoryDescriptor table of the AssessmentCategoryDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentCategoryDescriptor : DescriptorAggregate.Descriptor, 
        IAssessmentCategoryDescriptor, IAssessmentCategoryDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentCategoryDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AssessmentCategoryDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        public virtual int? AssessmentCategoryTypeId 
        {
            get
            {
                if (_assessmentCategoryTypeId == default(int?))
                    _assessmentCategoryTypeId = string.IsNullOrWhiteSpace(_assessmentCategoryType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("AssessmentCategoryType", _assessmentCategoryType);

                return _assessmentCategoryTypeId;
            } 
            set
            {
                _assessmentCategoryTypeId = value;
                _assessmentCategoryType = null;
            }
        }

        private int? _assessmentCategoryTypeId;
        private string _assessmentCategoryType;

        public virtual string AssessmentCategoryType
        {
            get
            {
                if (_assessmentCategoryType == null)
                    _assessmentCategoryType = _assessmentCategoryTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("AssessmentCategoryType", _assessmentCategoryTypeId.Value);
                    
                return _assessmentCategoryType;
            }
            set
            {
                _assessmentCategoryType = value;
                _assessmentCategoryTypeId = default(int?);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AssessmentCategoryType", new LookupColumnDetails { PropertyName = "AssessmentCategoryTypeId", LookupTypeName = "AssessmentCategoryType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AssessmentCategoryDescriptorId", AssessmentCategoryDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentCategoryDescriptor>
        {
            return this.SynchronizeTo((IAssessmentCategoryDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentCategoryDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAssessmentCategoryTypeSupported = true;
        bool IAssessmentCategoryDescriptorSynchronizationSourceSupport.IsAssessmentCategoryTypeSupported 
        { 
            get { return _isAssessmentCategoryTypeSupported; } 
            set { _isAssessmentCategoryTypeSupported = value; }
        }

        private bool _isCodeValueSupported = true;
        bool IAssessmentCategoryDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAssessmentCategoryDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool IAssessmentCategoryDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool IAssessmentCategoryDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool IAssessmentCategoryDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool IAssessmentCategoryDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAssessmentCategoryDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AssessmentCategoryType

namespace EdFi.Ods.Entities.NHibernate.AssessmentCategoryTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentCategoryType table of the AssessmentCategoryType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentCategoryType : AggregateRootWithCompositeKey, 
        IAssessmentCategoryType, IAssessmentCategoryTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentCategoryTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AssessmentCategoryTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AssessmentCategoryTypeId", AssessmentCategoryTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentCategoryType>
        {
            return this.SynchronizeTo((IAssessmentCategoryType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentCategoryType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IAssessmentCategoryTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAssessmentCategoryTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAssessmentCategoryTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AssessmentFamily

namespace EdFi.Ods.Entities.NHibernate.AssessmentFamilyAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentFamily table of the AssessmentFamily aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentFamily : AggregateRootWithCompositeKey, 
        IAssessmentFamily, IAssessmentFamilyRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentFamilySynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        public AssessmentFamily()
        {
           AssessmentFamilyContentStandardPersistentList = new List<AssessmentFamilyContentStandard>();
            AssessmentFamilyAssessmentPeriods = new List<AssessmentFamilyAssessmentPeriod>();
            AssessmentFamilyIdentificationCodes = new List<AssessmentFamilyIdentificationCode>();
            AssessmentFamilyLanguages = new List<AssessmentFamilyLanguage>();

        }
// restore warnings for inheritance from classes marked Obsolete
#pragma warning restore 612, 618 
               
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string AssessmentFamilyTitle  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        public virtual int? AcademicSubjectDescriptorId 
        {
            get
            {
                if (_academicSubjectDescriptorId == default(int?))
                    _academicSubjectDescriptorId = string.IsNullOrWhiteSpace(_academicSubjectDescriptor) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("AcademicSubjectDescriptor", _academicSubjectDescriptor);

                return _academicSubjectDescriptorId;
            } 
            set
            {
                _academicSubjectDescriptorId = value;
                _academicSubjectDescriptor = null;
            }
        }

        private int? _academicSubjectDescriptorId;
        private string _academicSubjectDescriptor;

        public virtual string AcademicSubjectDescriptor
        {
            get
            {
                if (_academicSubjectDescriptor == null)
                    _academicSubjectDescriptor = _academicSubjectDescriptorId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("AcademicSubjectDescriptor", _academicSubjectDescriptorId.Value);
                    
                return _academicSubjectDescriptor;
            }
            set
            {
                _academicSubjectDescriptor = value;
                _academicSubjectDescriptorId = default(int?);
            }
        }
        public virtual int? AssessedGradeLevelDescriptorId 
        {
            get
            {
                if (_assessedGradeLevelDescriptorId == default(int?))
                    _assessedGradeLevelDescriptorId = string.IsNullOrWhiteSpace(_assessedGradeLevelDescriptor) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("GradeLevelDescriptor", _assessedGradeLevelDescriptor);

                return _assessedGradeLevelDescriptorId;
            } 
            set
            {
                _assessedGradeLevelDescriptorId = value;
                _assessedGradeLevelDescriptor = null;
            }
        }

        private int? _assessedGradeLevelDescriptorId;
        private string _assessedGradeLevelDescriptor;

        public virtual string AssessedGradeLevelDescriptor
        {
            get
            {
                if (_assessedGradeLevelDescriptor == null)
                    _assessedGradeLevelDescriptor = _assessedGradeLevelDescriptorId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("GradeLevelDescriptor", _assessedGradeLevelDescriptorId.Value);
                    
                return _assessedGradeLevelDescriptor;
            }
            set
            {
                _assessedGradeLevelDescriptor = value;
                _assessedGradeLevelDescriptorId = default(int?);
            }
        }
        public virtual int? AssessmentCategoryDescriptorId 
        {
            get
            {
                if (_assessmentCategoryDescriptorId == default(int?))
                    _assessmentCategoryDescriptorId = string.IsNullOrWhiteSpace(_assessmentCategoryDescriptor) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("AssessmentCategoryDescriptor", _assessmentCategoryDescriptor);

                return _assessmentCategoryDescriptorId;
            } 
            set
            {
                _assessmentCategoryDescriptorId = value;
                _assessmentCategoryDescriptor = null;
            }
        }

        private int? _assessmentCategoryDescriptorId;
        private string _assessmentCategoryDescriptor;

        public virtual string AssessmentCategoryDescriptor
        {
            get
            {
                if (_assessmentCategoryDescriptor == null)
                    _assessmentCategoryDescriptor = _assessmentCategoryDescriptorId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("AssessmentCategoryDescriptor", _assessmentCategoryDescriptorId.Value);
                    
                return _assessmentCategoryDescriptor;
            }
            set
            {
                _assessmentCategoryDescriptor = value;
                _assessmentCategoryDescriptorId = default(int?);
            }
        }
        public virtual int? LowestAssessedGradeLevelDescriptorId 
        {
            get
            {
                if (_lowestAssessedGradeLevelDescriptorId == default(int?))
                    _lowestAssessedGradeLevelDescriptorId = string.IsNullOrWhiteSpace(_lowestAssessedGradeLevelDescriptor) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("GradeLevelDescriptor", _lowestAssessedGradeLevelDescriptor);

                return _lowestAssessedGradeLevelDescriptorId;
            } 
            set
            {
                _lowestAssessedGradeLevelDescriptorId = value;
                _lowestAssessedGradeLevelDescriptor = null;
            }
        }

        private int? _lowestAssessedGradeLevelDescriptorId;
        private string _lowestAssessedGradeLevelDescriptor;

        public virtual string LowestAssessedGradeLevelDescriptor
        {
            get
            {
                if (_lowestAssessedGradeLevelDescriptor == null)
                    _lowestAssessedGradeLevelDescriptor = _lowestAssessedGradeLevelDescriptorId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("GradeLevelDescriptor", _lowestAssessedGradeLevelDescriptorId.Value);
                    
                return _lowestAssessedGradeLevelDescriptor;
            }
            set
            {
                _lowestAssessedGradeLevelDescriptor = value;
                _lowestAssessedGradeLevelDescriptorId = default(int?);
            }
        }
        [RequiredWithNonDefault, StringLength(255), NoDangerousText]
        public virtual string Namespace  { get; set; }
        [StringLength(35), NoDangerousText]
        public virtual string Nomenclature  { get; set; }
        [StringLength(60), NoDangerousText]
        public virtual string ParentAssessmentFamilyTitle  { get; set; }
        [SqlServerDateTimeRange]
        public virtual DateTime? RevisionDate 
        {
            get { return _revisionDate; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _revisionDate = null;
                } else
                {
                    var given = (DateTime) value;
                    _revisionDate = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _revisionDate;
        
        public virtual int? Version  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                     One-to-one relationships
        // -------------------------------------------------------------
        [ValidateObject]
        public virtual AssessmentFamilyContentStandard AssessmentFamilyContentStandard
        {
            get
            {
                // Return the item in the list, if one exists
                if (AssessmentFamilyContentStandardPersistentList.Any())
                    return AssessmentFamilyContentStandardPersistentList[0];

                // No reference is present
                return null;
            }
            set
            {
                // Delete the existing object
                if (AssessmentFamilyContentStandardPersistentList.Any())
                    AssessmentFamilyContentStandardPersistentList.RemoveAt(0);

                // If we're setting a value, add it to the list now
                if (value != null)
                    AssessmentFamilyContentStandardPersistentList.Add(value);
            }
        }

        IAssessmentFamilyContentStandard IAssessmentFamily.AssessmentFamilyContentStandard
        {
            get { return AssessmentFamilyContentStandard; }
            set { AssessmentFamilyContentStandard = (AssessmentFamilyContentStandard) value; }
        }

        private IList<AssessmentFamilyContentStandard> _assessmentFamilyContentStandardPersistentList;

        public virtual IList<AssessmentFamilyContentStandard> AssessmentFamilyContentStandardPersistentList
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentFamilyContentStandardPersistentList)
                    if (item.AssessmentFamily == null)
                        item.AssessmentFamily = this;
                // -------------------------------------------------------------

                return _assessmentFamilyContentStandardPersistentList;
            }
            set
            {
                _assessmentFamilyContentStandardPersistentList = value;
            }
        }


        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------

        private IList<AssessmentFamilyAssessmentPeriod> _assessmentFamilyAssessmentPeriods;
        private IList<IAssessmentFamilyAssessmentPeriod> _assessmentFamilyAssessmentPeriodsCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<AssessmentFamilyAssessmentPeriod> AssessmentFamilyAssessmentPeriods
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentFamilyAssessmentPeriods)
                    if (item.AssessmentFamily == null)
                        item.AssessmentFamily = this;
                // -------------------------------------------------------------

                return _assessmentFamilyAssessmentPeriods;
            }
            set 
            { 
                _assessmentFamilyAssessmentPeriods = value;
                _assessmentFamilyAssessmentPeriodsCovariant = new CovariantIListAdapter<IAssessmentFamilyAssessmentPeriod, AssessmentFamilyAssessmentPeriod>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<IAssessmentFamilyAssessmentPeriod> IAssessmentFamily.AssessmentFamilyAssessmentPeriods
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentFamilyAssessmentPeriods)
                    if (item.AssessmentFamily == null)
                        item.AssessmentFamily = this;
                // -------------------------------------------------------------

                return _assessmentFamilyAssessmentPeriodsCovariant; 
            }
            set 
            { 
                AssessmentFamilyAssessmentPeriods = new List<AssessmentFamilyAssessmentPeriod>(value.Cast<AssessmentFamilyAssessmentPeriod>()); 
            }
        }


        private IList<AssessmentFamilyIdentificationCode> _assessmentFamilyIdentificationCodes;
        private IList<IAssessmentFamilyIdentificationCode> _assessmentFamilyIdentificationCodesCovariant;
        [RequiredCollection]
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<AssessmentFamilyIdentificationCode> AssessmentFamilyIdentificationCodes
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentFamilyIdentificationCodes)
                    if (item.AssessmentFamily == null)
                        item.AssessmentFamily = this;
                // -------------------------------------------------------------

                return _assessmentFamilyIdentificationCodes;
            }
            set 
            { 
                _assessmentFamilyIdentificationCodes = value;
                _assessmentFamilyIdentificationCodesCovariant = new CovariantIListAdapter<IAssessmentFamilyIdentificationCode, AssessmentFamilyIdentificationCode>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<IAssessmentFamilyIdentificationCode> IAssessmentFamily.AssessmentFamilyIdentificationCodes
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentFamilyIdentificationCodes)
                    if (item.AssessmentFamily == null)
                        item.AssessmentFamily = this;
                // -------------------------------------------------------------

                return _assessmentFamilyIdentificationCodesCovariant; 
            }
            set 
            { 
                AssessmentFamilyIdentificationCodes = new List<AssessmentFamilyIdentificationCode>(value.Cast<AssessmentFamilyIdentificationCode>()); 
            }
        }


        private IList<AssessmentFamilyLanguage> _assessmentFamilyLanguages;
        private IList<IAssessmentFamilyLanguage> _assessmentFamilyLanguagesCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<AssessmentFamilyLanguage> AssessmentFamilyLanguages
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentFamilyLanguages)
                    if (item.AssessmentFamily == null)
                        item.AssessmentFamily = this;
                // -------------------------------------------------------------

                return _assessmentFamilyLanguages;
            }
            set 
            { 
                _assessmentFamilyLanguages = value;
                _assessmentFamilyLanguagesCovariant = new CovariantIListAdapter<IAssessmentFamilyLanguage, AssessmentFamilyLanguage>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<IAssessmentFamilyLanguage> IAssessmentFamily.AssessmentFamilyLanguages
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentFamilyLanguages)
                    if (item.AssessmentFamily == null)
                        item.AssessmentFamily = this;
                // -------------------------------------------------------------

                return _assessmentFamilyLanguagesCovariant; 
            }
            set 
            { 
                AssessmentFamilyLanguages = new List<AssessmentFamilyLanguage>(value.Cast<AssessmentFamilyLanguage>()); 
            }
        }

        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
                { "AssessedGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "AssessedGradeLevelDescriptorId", LookupTypeName = "AssessedGradeLevelDescriptor"} },
                { "AssessmentCategoryDescriptor", new LookupColumnDetails { PropertyName = "AssessmentCategoryDescriptorId", LookupTypeName = "AssessmentCategoryDescriptor"} },
                { "LowestAssessedGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "LowestAssessedGradeLevelDescriptorId", LookupTypeName = "LowestAssessedGradeLevelDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AssessmentFamilyTitle", AssessmentFamilyTitle);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentFamily>
        {
            return this.SynchronizeTo((IAssessmentFamily)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentFamily) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAcademicSubjectDescriptorSupported = true;
        bool IAssessmentFamilySynchronizationSourceSupport.IsAcademicSubjectDescriptorSupported 
        { 
            get { return _isAcademicSubjectDescriptorSupported; } 
            set { _isAcademicSubjectDescriptorSupported = value; }
        }

        private bool _isAssessedGradeLevelDescriptorSupported = true;
        bool IAssessmentFamilySynchronizationSourceSupport.IsAssessedGradeLevelDescriptorSupported 
        { 
            get { return _isAssessedGradeLevelDescriptorSupported; } 
            set { _isAssessedGradeLevelDescriptorSupported = value; }
        }

        private bool _isAssessmentCategoryDescriptorSupported = true;
        bool IAssessmentFamilySynchronizationSourceSupport.IsAssessmentCategoryDescriptorSupported 
        { 
            get { return _isAssessmentCategoryDescriptorSupported; } 
            set { _isAssessmentCategoryDescriptorSupported = value; }
        }

        private bool _isAssessmentFamilyAssessmentPeriodsSupported = true;
        bool IAssessmentFamilySynchronizationSourceSupport.IsAssessmentFamilyAssessmentPeriodsSupported 
        { 
            get { return _isAssessmentFamilyAssessmentPeriodsSupported; } 
            set { _isAssessmentFamilyAssessmentPeriodsSupported = value; }
        }

        private bool _isAssessmentFamilyContentStandardSupported = true;
        bool IAssessmentFamilySynchronizationSourceSupport.IsAssessmentFamilyContentStandardSupported 
        { 
            get { return _isAssessmentFamilyContentStandardSupported; } 
            set { _isAssessmentFamilyContentStandardSupported = value; }
        }

        private bool _isAssessmentFamilyIdentificationCodesSupported = true;
        bool IAssessmentFamilySynchronizationSourceSupport.IsAssessmentFamilyIdentificationCodesSupported 
        { 
            get { return _isAssessmentFamilyIdentificationCodesSupported; } 
            set { _isAssessmentFamilyIdentificationCodesSupported = value; }
        }

        private bool _isAssessmentFamilyLanguagesSupported = true;
        bool IAssessmentFamilySynchronizationSourceSupport.IsAssessmentFamilyLanguagesSupported 
        { 
            get { return _isAssessmentFamilyLanguagesSupported; } 
            set { _isAssessmentFamilyLanguagesSupported = value; }
        }

        private bool _isLowestAssessedGradeLevelDescriptorSupported = true;
        bool IAssessmentFamilySynchronizationSourceSupport.IsLowestAssessedGradeLevelDescriptorSupported 
        { 
            get { return _isLowestAssessedGradeLevelDescriptorSupported; } 
            set { _isLowestAssessedGradeLevelDescriptorSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool IAssessmentFamilySynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isNomenclatureSupported = true;
        bool IAssessmentFamilySynchronizationSourceSupport.IsNomenclatureSupported 
        { 
            get { return _isNomenclatureSupported; } 
            set { _isNomenclatureSupported = value; }
        }

        private bool _isParentAssessmentFamilyTitleSupported = true;
        bool IAssessmentFamilySynchronizationSourceSupport.IsParentAssessmentFamilyTitleSupported 
        { 
            get { return _isParentAssessmentFamilyTitleSupported; } 
            set { _isParentAssessmentFamilyTitleSupported = value; }
        }

        private bool _isRevisionDateSupported = true;
        bool IAssessmentFamilySynchronizationSourceSupport.IsRevisionDateSupported 
        { 
            get { return _isRevisionDateSupported; } 
            set { _isRevisionDateSupported = value; }
        }

        private bool _isVersionSupported = true;
        bool IAssessmentFamilySynchronizationSourceSupport.IsVersionSupported 
        { 
            get { return _isVersionSupported; } 
            set { _isVersionSupported = value; }
        }

        private Func<IAssessmentFamilyAssessmentPeriod, bool> _isAssessmentFamilyAssessmentPeriodIncluded;
        Func<IAssessmentFamilyAssessmentPeriod, bool> IAssessmentFamilySynchronizationSourceSupport.IsAssessmentFamilyAssessmentPeriodIncluded
        { 
            get { return _isAssessmentFamilyAssessmentPeriodIncluded; } 
            set { _isAssessmentFamilyAssessmentPeriodIncluded = value; }
        }

        private Func<IAssessmentFamilyIdentificationCode, bool> _isAssessmentFamilyIdentificationCodeIncluded;
        Func<IAssessmentFamilyIdentificationCode, bool> IAssessmentFamilySynchronizationSourceSupport.IsAssessmentFamilyIdentificationCodeIncluded
        { 
            get { return _isAssessmentFamilyIdentificationCodeIncluded; } 
            set { _isAssessmentFamilyIdentificationCodeIncluded = value; }
        }

        private Func<IAssessmentFamilyLanguage, bool> _isAssessmentFamilyLanguageIncluded;
        Func<IAssessmentFamilyLanguage, bool> IAssessmentFamilySynchronizationSourceSupport.IsAssessmentFamilyLanguageIncluded
        { 
            get { return _isAssessmentFamilyLanguageIncluded; } 
            set { _isAssessmentFamilyLanguageIncluded = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentFamilyAssessmentPeriod table of the AssessmentFamily aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentFamilyAssessmentPeriod : EntityWithCompositeKey, IChildEntity, 
        IAssessmentFamilyAssessmentPeriod, IAssessmentFamilyAssessmentPeriodRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentFamilyAssessmentPeriodSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual AssessmentFamily AssessmentFamily { get; set; }

        IAssessmentFamily IAssessmentFamilyAssessmentPeriod.AssessmentFamily
        {
            get { return AssessmentFamily; }
            set { AssessmentFamily = (AssessmentFamily) value; }
        }

        string IAssessmentFamilyAssessmentPeriodRecord.AssessmentFamilyTitle
        {
            get { return ((IAssessmentFamilyRecord) AssessmentFamily).AssessmentFamilyTitle; }
            set { ((IAssessmentFamilyRecord) AssessmentFamily).AssessmentFamilyTitle = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int AssessmentPeriodDescriptorId 
        {
            get
            {
                if (_assessmentPeriodDescriptorId == default(int))
                    _assessmentPeriodDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("AssessmentPeriodDescriptor", _assessmentPeriodDescriptor);

                return _assessmentPeriodDescriptorId;
            } 
            set
            {
                _assessmentPeriodDescriptorId = value;
                _assessmentPeriodDescriptor = null;
            }
        }

        private int _assessmentPeriodDescriptorId;
        private string _assessmentPeriodDescriptor;

        public virtual string AssessmentPeriodDescriptor
        {
            get
            {
                if (_assessmentPeriodDescriptor == null)
                    _assessmentPeriodDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("AssessmentPeriodDescriptor", _assessmentPeriodDescriptorId);
                    
                return _assessmentPeriodDescriptor;
            }
            set
            {
                _assessmentPeriodDescriptor = value;
                _assessmentPeriodDescriptorId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AssessmentPeriodDescriptor", new LookupColumnDetails { PropertyName = "AssessmentPeriodDescriptorId", LookupTypeName = "AssessmentPeriodDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (AssessmentFamily as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("AssessmentPeriodDescriptorId", AssessmentPeriodDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentFamilyAssessmentPeriod>
        {
            return this.SynchronizeTo((IAssessmentFamilyAssessmentPeriod)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentFamilyAssessmentPeriod) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            AssessmentFamily = (AssessmentFamily) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentFamilyIdentificationCode table of the AssessmentFamily aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentFamilyIdentificationCode : EntityWithCompositeKey, IChildEntity, 
        IAssessmentFamilyIdentificationCode, IAssessmentFamilyIdentificationCodeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentFamilyIdentificationCodeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual AssessmentFamily AssessmentFamily { get; set; }

        IAssessmentFamily IAssessmentFamilyIdentificationCode.AssessmentFamily
        {
            get { return AssessmentFamily; }
            set { AssessmentFamily = (AssessmentFamily) value; }
        }

        string IAssessmentFamilyIdentificationCodeRecord.AssessmentFamilyTitle
        {
            get { return ((IAssessmentFamilyRecord) AssessmentFamily).AssessmentFamilyTitle; }
            set { ((IAssessmentFamilyRecord) AssessmentFamily).AssessmentFamilyTitle = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int AssessmentIdentificationSystemDescriptorId 
        {
            get
            {
                if (_assessmentIdentificationSystemDescriptorId == default(int))
                    _assessmentIdentificationSystemDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("AssessmentIdentificationSystemDescriptor", _assessmentIdentificationSystemDescriptor);

                return _assessmentIdentificationSystemDescriptorId;
            } 
            set
            {
                _assessmentIdentificationSystemDescriptorId = value;
                _assessmentIdentificationSystemDescriptor = null;
            }
        }

        private int _assessmentIdentificationSystemDescriptorId;
        private string _assessmentIdentificationSystemDescriptor;

        public virtual string AssessmentIdentificationSystemDescriptor
        {
            get
            {
                if (_assessmentIdentificationSystemDescriptor == null)
                    _assessmentIdentificationSystemDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("AssessmentIdentificationSystemDescriptor", _assessmentIdentificationSystemDescriptorId);
                    
                return _assessmentIdentificationSystemDescriptor;
            }
            set
            {
                _assessmentIdentificationSystemDescriptor = value;
                _assessmentIdentificationSystemDescriptorId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [StringLength(60), NoDangerousText]
        public virtual string AssigningOrganizationIdentificationCode  { get; set; }
        [RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string IdentificationCode  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AssessmentIdentificationSystemDescriptor", new LookupColumnDetails { PropertyName = "AssessmentIdentificationSystemDescriptorId", LookupTypeName = "AssessmentIdentificationSystemDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (AssessmentFamily as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("AssessmentIdentificationSystemDescriptorId", AssessmentIdentificationSystemDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentFamilyIdentificationCode>
        {
            return this.SynchronizeTo((IAssessmentFamilyIdentificationCode)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentFamilyIdentificationCode) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            AssessmentFamily = (AssessmentFamily) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAssigningOrganizationIdentificationCodeSupported = true;
        bool IAssessmentFamilyIdentificationCodeSynchronizationSourceSupport.IsAssigningOrganizationIdentificationCodeSupported 
        { 
            get { return _isAssigningOrganizationIdentificationCodeSupported; } 
            set { _isAssigningOrganizationIdentificationCodeSupported = value; }
        }

        private bool _isIdentificationCodeSupported = true;
        bool IAssessmentFamilyIdentificationCodeSynchronizationSourceSupport.IsIdentificationCodeSupported 
        { 
            get { return _isIdentificationCodeSupported; } 
            set { _isIdentificationCodeSupported = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentFamilyContentStandard table of the AssessmentFamily aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentFamilyContentStandard : EntityWithCompositeKey, IChildEntity, 
        IAssessmentFamilyContentStandard, IAssessmentFamilyContentStandardRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentFamilyContentStandardSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        public AssessmentFamilyContentStandard()
        {
            AssessmentFamilyContentStandardAuthors = new List<AssessmentFamilyContentStandardAuthor>();

        }
// restore warnings for inheritance from classes marked Obsolete
#pragma warning restore 612, 618 
               
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual AssessmentFamily AssessmentFamily { get; set; }

        IAssessmentFamily IAssessmentFamilyContentStandard.AssessmentFamily
        {
            get { return AssessmentFamily; }
            set { AssessmentFamily = (AssessmentFamily) value; }
        }

        string IAssessmentFamilyContentStandardRecord.AssessmentFamilyTitle
        {
            get { return ((IAssessmentFamilyRecord) AssessmentFamily).AssessmentFamilyTitle; }
            set { ((IAssessmentFamilyRecord) AssessmentFamily).AssessmentFamilyTitle = value; }
        }


        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [SqlServerDateTimeRange]
        public virtual DateTime? BeginDate 
        {
            get { return _beginDate; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _beginDate = null;
                } else
                {
                    var given = (DateTime) value;
                    _beginDate = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _beginDate;
        
        [SqlServerDateTimeRange]
        public virtual DateTime? EndDate 
        {
            get { return _endDate; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _endDate = null;
                } else
                {
                    var given = (DateTime) value;
                    _endDate = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _endDate;
        
        public virtual int? MandatingEducationOrganizationId  { get; set; }
        [SqlServerDateTimeRange]
        public virtual DateTime? PublicationDate 
        {
            get { return _publicationDate; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _publicationDate = null;
                } else
                {
                    var given = (DateTime) value;
                    _publicationDate = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _publicationDate;
        
        public virtual int? PublicationStatusTypeId 
        {
            get
            {
                if (_publicationStatusTypeId == default(int?))
                    _publicationStatusTypeId = string.IsNullOrWhiteSpace(_publicationStatusType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("PublicationStatusType", _publicationStatusType);

                return _publicationStatusTypeId;
            } 
            set
            {
                _publicationStatusTypeId = value;
                _publicationStatusType = null;
            }
        }

        private int? _publicationStatusTypeId;
        private string _publicationStatusType;

        public virtual string PublicationStatusType
        {
            get
            {
                if (_publicationStatusType == null)
                    _publicationStatusType = _publicationStatusTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("PublicationStatusType", _publicationStatusTypeId.Value);
                    
                return _publicationStatusType;
            }
            set
            {
                _publicationStatusType = value;
                _publicationStatusTypeId = default(int?);
            }
        }
        public virtual short? PublicationYear  { get; set; }
        [RequiredWithNonDefault, StringLength(75), NoDangerousText]
        public virtual string Title  { get; set; }
        [StringLength(255), NoDangerousText]
        public virtual string URI  { get; set; }
        [StringLength(50), NoDangerousText]
        public virtual string Version  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------

        private IList<AssessmentFamilyContentStandardAuthor> _assessmentFamilyContentStandardAuthors;
        private IList<IAssessmentFamilyContentStandardAuthor> _assessmentFamilyContentStandardAuthorsCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<AssessmentFamilyContentStandardAuthor> AssessmentFamilyContentStandardAuthors
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentFamilyContentStandardAuthors)
                    if (item.AssessmentFamilyContentStandard == null)
                        item.AssessmentFamilyContentStandard = this;
                // -------------------------------------------------------------

                return _assessmentFamilyContentStandardAuthors;
            }
            set 
            { 
                _assessmentFamilyContentStandardAuthors = value;
                _assessmentFamilyContentStandardAuthorsCovariant = new CovariantIListAdapter<IAssessmentFamilyContentStandardAuthor, AssessmentFamilyContentStandardAuthor>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<IAssessmentFamilyContentStandardAuthor> IAssessmentFamilyContentStandard.AssessmentFamilyContentStandardAuthors
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentFamilyContentStandardAuthors)
                    if (item.AssessmentFamilyContentStandard == null)
                        item.AssessmentFamilyContentStandard = this;
                // -------------------------------------------------------------

                return _assessmentFamilyContentStandardAuthorsCovariant; 
            }
            set 
            { 
                AssessmentFamilyContentStandardAuthors = new List<AssessmentFamilyContentStandardAuthor>(value.Cast<AssessmentFamilyContentStandardAuthor>()); 
            }
        }

        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "PublicationStatusType", new LookupColumnDetails { PropertyName = "PublicationStatusTypeId", LookupTypeName = "PublicationStatusType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (AssessmentFamily as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentFamilyContentStandard>
        {
            return this.SynchronizeTo((IAssessmentFamilyContentStandard)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentFamilyContentStandard) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            AssessmentFamily = (AssessmentFamily) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAssessmentFamilyContentStandardAuthorsSupported = true;
        bool IAssessmentFamilyContentStandardSynchronizationSourceSupport.IsAssessmentFamilyContentStandardAuthorsSupported 
        { 
            get { return _isAssessmentFamilyContentStandardAuthorsSupported; } 
            set { _isAssessmentFamilyContentStandardAuthorsSupported = value; }
        }

        private bool _isBeginDateSupported = true;
        bool IAssessmentFamilyContentStandardSynchronizationSourceSupport.IsBeginDateSupported 
        { 
            get { return _isBeginDateSupported; } 
            set { _isBeginDateSupported = value; }
        }

        private bool _isEndDateSupported = true;
        bool IAssessmentFamilyContentStandardSynchronizationSourceSupport.IsEndDateSupported 
        { 
            get { return _isEndDateSupported; } 
            set { _isEndDateSupported = value; }
        }

        private bool _isMandatingEducationOrganizationIdSupported = true;
        bool IAssessmentFamilyContentStandardSynchronizationSourceSupport.IsMandatingEducationOrganizationIdSupported 
        { 
            get { return _isMandatingEducationOrganizationIdSupported; } 
            set { _isMandatingEducationOrganizationIdSupported = value; }
        }

        private bool _isPublicationDateSupported = true;
        bool IAssessmentFamilyContentStandardSynchronizationSourceSupport.IsPublicationDateSupported 
        { 
            get { return _isPublicationDateSupported; } 
            set { _isPublicationDateSupported = value; }
        }

        private bool _isPublicationStatusTypeSupported = true;
        bool IAssessmentFamilyContentStandardSynchronizationSourceSupport.IsPublicationStatusTypeSupported 
        { 
            get { return _isPublicationStatusTypeSupported; } 
            set { _isPublicationStatusTypeSupported = value; }
        }

        private bool _isPublicationYearSupported = true;
        bool IAssessmentFamilyContentStandardSynchronizationSourceSupport.IsPublicationYearSupported 
        { 
            get { return _isPublicationYearSupported; } 
            set { _isPublicationYearSupported = value; }
        }

        private bool _isTitleSupported = true;
        bool IAssessmentFamilyContentStandardSynchronizationSourceSupport.IsTitleSupported 
        { 
            get { return _isTitleSupported; } 
            set { _isTitleSupported = value; }
        }

        private bool _isURISupported = true;
        bool IAssessmentFamilyContentStandardSynchronizationSourceSupport.IsURISupported 
        { 
            get { return _isURISupported; } 
            set { _isURISupported = value; }
        }

        private bool _isVersionSupported = true;
        bool IAssessmentFamilyContentStandardSynchronizationSourceSupport.IsVersionSupported 
        { 
            get { return _isVersionSupported; } 
            set { _isVersionSupported = value; }
        }

        private Func<IAssessmentFamilyContentStandardAuthor, bool> _isAssessmentFamilyContentStandardAuthorIncluded;
        Func<IAssessmentFamilyContentStandardAuthor, bool> IAssessmentFamilyContentStandardSynchronizationSourceSupport.IsAssessmentFamilyContentStandardAuthorIncluded
        { 
            get { return _isAssessmentFamilyContentStandardAuthorIncluded; } 
            set { _isAssessmentFamilyContentStandardAuthorIncluded = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentFamilyContentStandardAuthor table of the AssessmentFamily aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentFamilyContentStandardAuthor : EntityWithCompositeKey, IChildEntity, 
        IAssessmentFamilyContentStandardAuthor, IAssessmentFamilyContentStandardAuthorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentFamilyContentStandardAuthorSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual AssessmentFamilyContentStandard AssessmentFamilyContentStandard { get; set; }

        IAssessmentFamilyContentStandard IAssessmentFamilyContentStandardAuthor.AssessmentFamilyContentStandard
        {
            get { return AssessmentFamilyContentStandard; }
            set { AssessmentFamilyContentStandard = (AssessmentFamilyContentStandard) value; }
        }

        string IAssessmentFamilyContentStandardAuthorRecord.AssessmentFamilyTitle
        {
            get { return ((IAssessmentFamilyContentStandardRecord) AssessmentFamilyContentStandard).AssessmentFamilyTitle; }
            set { ((IAssessmentFamilyContentStandardRecord) AssessmentFamilyContentStandard).AssessmentFamilyTitle = value; }
        }


        [DomainSignature, RequiredWithNonDefault, StringLength(255), NoDangerousText]
        public virtual string Author  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (AssessmentFamilyContentStandard as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("Author", Author);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentFamilyContentStandardAuthor>
        {
            return this.SynchronizeTo((IAssessmentFamilyContentStandardAuthor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentFamilyContentStandardAuthor) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            AssessmentFamilyContentStandard = (AssessmentFamilyContentStandard) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentFamilyLanguage table of the AssessmentFamily aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentFamilyLanguage : EntityWithCompositeKey, IChildEntity, 
        IAssessmentFamilyLanguage, IAssessmentFamilyLanguageRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentFamilyLanguageSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual AssessmentFamily AssessmentFamily { get; set; }

        IAssessmentFamily IAssessmentFamilyLanguage.AssessmentFamily
        {
            get { return AssessmentFamily; }
            set { AssessmentFamily = (AssessmentFamily) value; }
        }

        string IAssessmentFamilyLanguageRecord.AssessmentFamilyTitle
        {
            get { return ((IAssessmentFamilyRecord) AssessmentFamily).AssessmentFamilyTitle; }
            set { ((IAssessmentFamilyRecord) AssessmentFamily).AssessmentFamilyTitle = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int LanguageDescriptorId 
        {
            get
            {
                if (_languageDescriptorId == default(int))
                    _languageDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("LanguageDescriptor", _languageDescriptor);

                return _languageDescriptorId;
            } 
            set
            {
                _languageDescriptorId = value;
                _languageDescriptor = null;
            }
        }

        private int _languageDescriptorId;
        private string _languageDescriptor;

        public virtual string LanguageDescriptor
        {
            get
            {
                if (_languageDescriptor == null)
                    _languageDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("LanguageDescriptor", _languageDescriptorId);
                    
                return _languageDescriptor;
            }
            set
            {
                _languageDescriptor = value;
                _languageDescriptorId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "LanguageDescriptor", new LookupColumnDetails { PropertyName = "LanguageDescriptorId", LookupTypeName = "LanguageDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (AssessmentFamily as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("LanguageDescriptorId", LanguageDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentFamilyLanguage>
        {
            return this.SynchronizeTo((IAssessmentFamilyLanguage)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentFamilyLanguage) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            AssessmentFamily = (AssessmentFamily) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 
}
// Aggregate: AssessmentIdentificationSystemDescriptor

namespace EdFi.Ods.Entities.NHibernate.AssessmentIdentificationSystemDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentIdentificationSystemDescriptor table of the AssessmentIdentificationSystemDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentIdentificationSystemDescriptor : DescriptorAggregate.Descriptor, 
        IAssessmentIdentificationSystemDescriptor, IAssessmentIdentificationSystemDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentIdentificationSystemDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AssessmentIdentificationSystemDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault]
        public virtual int AssessmentIdentificationSystemTypeId 
        {
            get
            {
                if (_assessmentIdentificationSystemTypeId == default(int))
                    _assessmentIdentificationSystemTypeId = TypesAndDescriptorsCache.GetCache().GetId("AssessmentIdentificationSystemType", _assessmentIdentificationSystemType);

                return _assessmentIdentificationSystemTypeId;
            } 
            set
            {
                _assessmentIdentificationSystemTypeId = value;
                _assessmentIdentificationSystemType = null;
            }
        }

        private int _assessmentIdentificationSystemTypeId;
        private string _assessmentIdentificationSystemType;

        public virtual string AssessmentIdentificationSystemType
        {
            get
            {
                if (_assessmentIdentificationSystemType == null)
                    _assessmentIdentificationSystemType = TypesAndDescriptorsCache.GetCache().GetValue("AssessmentIdentificationSystemType", _assessmentIdentificationSystemTypeId);
                    
                return _assessmentIdentificationSystemType;
            }
            set
            {
                _assessmentIdentificationSystemType = value;
                _assessmentIdentificationSystemTypeId = default(int);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AssessmentIdentificationSystemType", new LookupColumnDetails { PropertyName = "AssessmentIdentificationSystemTypeId", LookupTypeName = "AssessmentIdentificationSystemType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AssessmentIdentificationSystemDescriptorId", AssessmentIdentificationSystemDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentIdentificationSystemDescriptor>
        {
            return this.SynchronizeTo((IAssessmentIdentificationSystemDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentIdentificationSystemDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAssessmentIdentificationSystemTypeSupported = true;
        bool IAssessmentIdentificationSystemDescriptorSynchronizationSourceSupport.IsAssessmentIdentificationSystemTypeSupported 
        { 
            get { return _isAssessmentIdentificationSystemTypeSupported; } 
            set { _isAssessmentIdentificationSystemTypeSupported = value; }
        }

        private bool _isCodeValueSupported = true;
        bool IAssessmentIdentificationSystemDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAssessmentIdentificationSystemDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool IAssessmentIdentificationSystemDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool IAssessmentIdentificationSystemDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool IAssessmentIdentificationSystemDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool IAssessmentIdentificationSystemDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAssessmentIdentificationSystemDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AssessmentIdentificationSystemType

namespace EdFi.Ods.Entities.NHibernate.AssessmentIdentificationSystemTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentIdentificationSystemType table of the AssessmentIdentificationSystemType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentIdentificationSystemType : AggregateRootWithCompositeKey, 
        IAssessmentIdentificationSystemType, IAssessmentIdentificationSystemTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentIdentificationSystemTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AssessmentIdentificationSystemTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AssessmentIdentificationSystemTypeId", AssessmentIdentificationSystemTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentIdentificationSystemType>
        {
            return this.SynchronizeTo((IAssessmentIdentificationSystemType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentIdentificationSystemType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IAssessmentIdentificationSystemTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAssessmentIdentificationSystemTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAssessmentIdentificationSystemTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AssessmentItem

namespace EdFi.Ods.Entities.NHibernate.AssessmentItemAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentItem table of the AssessmentItem aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentItem : AggregateRootWithCompositeKey, 
        IAssessmentItem, IAssessmentItemRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentItemSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        public AssessmentItem()
        {
            AssessmentItemLearningStandards = new List<AssessmentItemLearningStandard>();

        }
// restore warnings for inheritance from classes marked Obsolete
#pragma warning restore 612, 618 
               
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string AssessmentTitle  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int AcademicSubjectDescriptorId 
        {
            get
            {
                if (_academicSubjectDescriptorId == default(int))
                    _academicSubjectDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("AcademicSubjectDescriptor", _academicSubjectDescriptor);

                return _academicSubjectDescriptorId;
            } 
            set
            {
                _academicSubjectDescriptorId = value;
                _academicSubjectDescriptor = null;
            }
        }

        private int _academicSubjectDescriptorId;
        private string _academicSubjectDescriptor;

        public virtual string AcademicSubjectDescriptor
        {
            get
            {
                if (_academicSubjectDescriptor == null)
                    _academicSubjectDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("AcademicSubjectDescriptor", _academicSubjectDescriptorId);
                    
                return _academicSubjectDescriptor;
            }
            set
            {
                _academicSubjectDescriptor = value;
                _academicSubjectDescriptorId = default(int);
            }
        }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int AssessedGradeLevelDescriptorId 
        {
            get
            {
                if (_assessedGradeLevelDescriptorId == default(int))
                    _assessedGradeLevelDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("GradeLevelDescriptor", _assessedGradeLevelDescriptor);

                return _assessedGradeLevelDescriptorId;
            } 
            set
            {
                _assessedGradeLevelDescriptorId = value;
                _assessedGradeLevelDescriptor = null;
            }
        }

        private int _assessedGradeLevelDescriptorId;
        private string _assessedGradeLevelDescriptor;

        public virtual string AssessedGradeLevelDescriptor
        {
            get
            {
                if (_assessedGradeLevelDescriptor == null)
                    _assessedGradeLevelDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("GradeLevelDescriptor", _assessedGradeLevelDescriptorId);
                    
                return _assessedGradeLevelDescriptor;
            }
            set
            {
                _assessedGradeLevelDescriptor = value;
                _assessedGradeLevelDescriptorId = default(int);
            }
        }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int Version  { get; set; }
        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string IdentificationCode  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        public virtual int? AssessmentItemCategoryTypeId 
        {
            get
            {
                if (_assessmentItemCategoryTypeId == default(int?))
                    _assessmentItemCategoryTypeId = string.IsNullOrWhiteSpace(_assessmentItemCategoryType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("AssessmentItemCategoryType", _assessmentItemCategoryType);

                return _assessmentItemCategoryTypeId;
            } 
            set
            {
                _assessmentItemCategoryTypeId = value;
                _assessmentItemCategoryType = null;
            }
        }

        private int? _assessmentItemCategoryTypeId;
        private string _assessmentItemCategoryType;

        public virtual string AssessmentItemCategoryType
        {
            get
            {
                if (_assessmentItemCategoryType == null)
                    _assessmentItemCategoryType = _assessmentItemCategoryTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("AssessmentItemCategoryType", _assessmentItemCategoryTypeId.Value);
                    
                return _assessmentItemCategoryType;
            }
            set
            {
                _assessmentItemCategoryType = value;
                _assessmentItemCategoryTypeId = default(int?);
            }
        }
        [StringLength(20), NoDangerousText]
        public virtual string CorrectResponse  { get; set; }
        [StringLength(30), NoDangerousText]
        public virtual string ExpectedTimeAssessed  { get; set; }
        public virtual int? MaxRawScore  { get; set; }
        [StringLength(35), NoDangerousText]
        public virtual string Nomenclature  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------

        private IList<AssessmentItemLearningStandard> _assessmentItemLearningStandards;
        private IList<IAssessmentItemLearningStandard> _assessmentItemLearningStandardsCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<AssessmentItemLearningStandard> AssessmentItemLearningStandards
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentItemLearningStandards)
                    if (item.AssessmentItem == null)
                        item.AssessmentItem = this;
                // -------------------------------------------------------------

                return _assessmentItemLearningStandards;
            }
            set 
            { 
                _assessmentItemLearningStandards = value;
                _assessmentItemLearningStandardsCovariant = new CovariantIListAdapter<IAssessmentItemLearningStandard, AssessmentItemLearningStandard>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<IAssessmentItemLearningStandard> IAssessmentItem.AssessmentItemLearningStandards
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _assessmentItemLearningStandards)
                    if (item.AssessmentItem == null)
                        item.AssessmentItem = this;
                // -------------------------------------------------------------

                return _assessmentItemLearningStandardsCovariant; 
            }
            set 
            { 
                AssessmentItemLearningStandards = new List<AssessmentItemLearningStandard>(value.Cast<AssessmentItemLearningStandard>()); 
            }
        }

        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
                { "AssessedGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "AssessedGradeLevelDescriptorId", LookupTypeName = "AssessedGradeLevelDescriptor"} },
                { "AssessmentItemCategoryType", new LookupColumnDetails { PropertyName = "AssessmentItemCategoryTypeId", LookupTypeName = "AssessmentItemCategoryType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AcademicSubjectDescriptorId", AcademicSubjectDescriptorId);
            keyValues.Add("AssessedGradeLevelDescriptorId", AssessedGradeLevelDescriptorId);
            keyValues.Add("AssessmentTitle", AssessmentTitle);
            keyValues.Add("IdentificationCode", IdentificationCode);
            keyValues.Add("Version", Version);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentItem>
        {
            return this.SynchronizeTo((IAssessmentItem)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentItem) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAssessmentItemCategoryTypeSupported = true;
        bool IAssessmentItemSynchronizationSourceSupport.IsAssessmentItemCategoryTypeSupported 
        { 
            get { return _isAssessmentItemCategoryTypeSupported; } 
            set { _isAssessmentItemCategoryTypeSupported = value; }
        }

        private bool _isAssessmentItemLearningStandardsSupported = true;
        bool IAssessmentItemSynchronizationSourceSupport.IsAssessmentItemLearningStandardsSupported 
        { 
            get { return _isAssessmentItemLearningStandardsSupported; } 
            set { _isAssessmentItemLearningStandardsSupported = value; }
        }

        private bool _isCorrectResponseSupported = true;
        bool IAssessmentItemSynchronizationSourceSupport.IsCorrectResponseSupported 
        { 
            get { return _isCorrectResponseSupported; } 
            set { _isCorrectResponseSupported = value; }
        }

        private bool _isExpectedTimeAssessedSupported = true;
        bool IAssessmentItemSynchronizationSourceSupport.IsExpectedTimeAssessedSupported 
        { 
            get { return _isExpectedTimeAssessedSupported; } 
            set { _isExpectedTimeAssessedSupported = value; }
        }

        private bool _isMaxRawScoreSupported = true;
        bool IAssessmentItemSynchronizationSourceSupport.IsMaxRawScoreSupported 
        { 
            get { return _isMaxRawScoreSupported; } 
            set { _isMaxRawScoreSupported = value; }
        }

        private bool _isNomenclatureSupported = true;
        bool IAssessmentItemSynchronizationSourceSupport.IsNomenclatureSupported 
        { 
            get { return _isNomenclatureSupported; } 
            set { _isNomenclatureSupported = value; }
        }

        private Func<IAssessmentItemLearningStandard, bool> _isAssessmentItemLearningStandardIncluded;
        Func<IAssessmentItemLearningStandard, bool> IAssessmentItemSynchronizationSourceSupport.IsAssessmentItemLearningStandardIncluded
        { 
            get { return _isAssessmentItemLearningStandardIncluded; } 
            set { _isAssessmentItemLearningStandardIncluded = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentItemLearningStandard table of the AssessmentItem aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentItemLearningStandard : EntityWithCompositeKey, IChildEntity, 
        IAssessmentItemLearningStandard, IAssessmentItemLearningStandardRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentItemLearningStandardSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual AssessmentItem AssessmentItem { get; set; }

        IAssessmentItem IAssessmentItemLearningStandard.AssessmentItem
        {
            get { return AssessmentItem; }
            set { AssessmentItem = (AssessmentItem) value; }
        }

        string IAssessmentItemLearningStandardRecord.AssessmentTitle
        {
            get { return ((IAssessmentItemRecord) AssessmentItem).AssessmentTitle; }
            set { ((IAssessmentItemRecord) AssessmentItem).AssessmentTitle = value; }
        }


        int IAssessmentItemLearningStandardRecord.AcademicSubjectDescriptorId
        {
            get { return ((IAssessmentItemRecord) AssessmentItem).AcademicSubjectDescriptorId; }
            set { ((IAssessmentItemRecord) AssessmentItem).AcademicSubjectDescriptorId = value; }
        }


        int IAssessmentItemLearningStandardRecord.AssessedGradeLevelDescriptorId
        {
            get { return ((IAssessmentItemRecord) AssessmentItem).AssessedGradeLevelDescriptorId; }
            set { ((IAssessmentItemRecord) AssessmentItem).AssessedGradeLevelDescriptorId = value; }
        }


        int IAssessmentItemLearningStandardRecord.Version
        {
            get { return ((IAssessmentItemRecord) AssessmentItem).Version; }
            set { ((IAssessmentItemRecord) AssessmentItem).Version = value; }
        }


        string IAssessmentItemLearningStandardRecord.IdentificationCode
        {
            get { return ((IAssessmentItemRecord) AssessmentItem).IdentificationCode; }
            set { ((IAssessmentItemRecord) AssessmentItem).IdentificationCode = value; }
        }


        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string LearningStandardId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
                { "AssessedGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "AssessedGradeLevelDescriptorId", LookupTypeName = "AssessedGradeLevelDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (AssessmentItem as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("LearningStandardId", LearningStandardId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentItemLearningStandard>
        {
            return this.SynchronizeTo((IAssessmentItemLearningStandard)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentItemLearningStandard) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            AssessmentItem = (AssessmentItem) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 
}
// Aggregate: AssessmentItemCategoryType

namespace EdFi.Ods.Entities.NHibernate.AssessmentItemCategoryTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentItemCategoryType table of the AssessmentItemCategoryType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentItemCategoryType : AggregateRootWithCompositeKey, 
        IAssessmentItemCategoryType, IAssessmentItemCategoryTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentItemCategoryTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AssessmentItemCategoryTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AssessmentItemCategoryTypeId", AssessmentItemCategoryTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentItemCategoryType>
        {
            return this.SynchronizeTo((IAssessmentItemCategoryType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentItemCategoryType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IAssessmentItemCategoryTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAssessmentItemCategoryTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAssessmentItemCategoryTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AssessmentItemResultType

namespace EdFi.Ods.Entities.NHibernate.AssessmentItemResultTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentItemResultType table of the AssessmentItemResultType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentItemResultType : AggregateRootWithCompositeKey, 
        IAssessmentItemResultType, IAssessmentItemResultTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentItemResultTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AssessmentItemResultTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AssessmentItemResultTypeId", AssessmentItemResultTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentItemResultType>
        {
            return this.SynchronizeTo((IAssessmentItemResultType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentItemResultType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IAssessmentItemResultTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAssessmentItemResultTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAssessmentItemResultTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AssessmentPeriodDescriptor

namespace EdFi.Ods.Entities.NHibernate.AssessmentPeriodDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentPeriodDescriptor table of the AssessmentPeriodDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentPeriodDescriptor : DescriptorAggregate.Descriptor, 
        IAssessmentPeriodDescriptor, IAssessmentPeriodDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentPeriodDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AssessmentPeriodDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [SqlServerDateTimeRange]
        public virtual DateTime? BeginDate 
        {
            get { return _beginDate; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _beginDate = null;
                } else
                {
                    var given = (DateTime) value;
                    _beginDate = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _beginDate;
        
        [SqlServerDateTimeRange]
        public virtual DateTime? EndDate 
        {
            get { return _endDate; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _endDate = null;
                } else
                {
                    var given = (DateTime) value;
                    _endDate = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _endDate;
        
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AssessmentPeriodDescriptorId", AssessmentPeriodDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentPeriodDescriptor>
        {
            return this.SynchronizeTo((IAssessmentPeriodDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentPeriodDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isBeginDateSupported = true;
        bool IAssessmentPeriodDescriptorSynchronizationSourceSupport.IsBeginDateSupported 
        { 
            get { return _isBeginDateSupported; } 
            set { _isBeginDateSupported = value; }
        }

        private bool _isCodeValueSupported = true;
        bool IAssessmentPeriodDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAssessmentPeriodDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool IAssessmentPeriodDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool IAssessmentPeriodDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isEndDateSupported = true;
        bool IAssessmentPeriodDescriptorSynchronizationSourceSupport.IsEndDateSupported 
        { 
            get { return _isEndDateSupported; } 
            set { _isEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool IAssessmentPeriodDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool IAssessmentPeriodDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAssessmentPeriodDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AssessmentReportingMethodType

namespace EdFi.Ods.Entities.NHibernate.AssessmentReportingMethodTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AssessmentReportingMethodType table of the AssessmentReportingMethodType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AssessmentReportingMethodType : AggregateRootWithCompositeKey, 
        IAssessmentReportingMethodType, IAssessmentReportingMethodTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAssessmentReportingMethodTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AssessmentReportingMethodTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AssessmentReportingMethodTypeId", AssessmentReportingMethodTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAssessmentReportingMethodType>
        {
            return this.SynchronizeTo((IAssessmentReportingMethodType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAssessmentReportingMethodType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IAssessmentReportingMethodTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAssessmentReportingMethodTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAssessmentReportingMethodTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AttendanceEventCategoryDescriptor

namespace EdFi.Ods.Entities.NHibernate.AttendanceEventCategoryDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AttendanceEventCategoryDescriptor table of the AttendanceEventCategoryDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AttendanceEventCategoryDescriptor : DescriptorAggregate.Descriptor, 
        IAttendanceEventCategoryDescriptor, IAttendanceEventCategoryDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAttendanceEventCategoryDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AttendanceEventCategoryDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault]
        public virtual int AttendanceEventCategoryTypeId 
        {
            get
            {
                if (_attendanceEventCategoryTypeId == default(int))
                    _attendanceEventCategoryTypeId = TypesAndDescriptorsCache.GetCache().GetId("AttendanceEventCategoryType", _attendanceEventCategoryType);

                return _attendanceEventCategoryTypeId;
            } 
            set
            {
                _attendanceEventCategoryTypeId = value;
                _attendanceEventCategoryType = null;
            }
        }

        private int _attendanceEventCategoryTypeId;
        private string _attendanceEventCategoryType;

        public virtual string AttendanceEventCategoryType
        {
            get
            {
                if (_attendanceEventCategoryType == null)
                    _attendanceEventCategoryType = TypesAndDescriptorsCache.GetCache().GetValue("AttendanceEventCategoryType", _attendanceEventCategoryTypeId);
                    
                return _attendanceEventCategoryType;
            }
            set
            {
                _attendanceEventCategoryType = value;
                _attendanceEventCategoryTypeId = default(int);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AttendanceEventCategoryType", new LookupColumnDetails { PropertyName = "AttendanceEventCategoryTypeId", LookupTypeName = "AttendanceEventCategoryType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AttendanceEventCategoryDescriptorId", AttendanceEventCategoryDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAttendanceEventCategoryDescriptor>
        {
            return this.SynchronizeTo((IAttendanceEventCategoryDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAttendanceEventCategoryDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAttendanceEventCategoryTypeSupported = true;
        bool IAttendanceEventCategoryDescriptorSynchronizationSourceSupport.IsAttendanceEventCategoryTypeSupported 
        { 
            get { return _isAttendanceEventCategoryTypeSupported; } 
            set { _isAttendanceEventCategoryTypeSupported = value; }
        }

        private bool _isCodeValueSupported = true;
        bool IAttendanceEventCategoryDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAttendanceEventCategoryDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool IAttendanceEventCategoryDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool IAttendanceEventCategoryDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool IAttendanceEventCategoryDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool IAttendanceEventCategoryDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAttendanceEventCategoryDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: AttendanceEventCategoryType

namespace EdFi.Ods.Entities.NHibernate.AttendanceEventCategoryTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.AttendanceEventCategoryType table of the AttendanceEventCategoryType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class AttendanceEventCategoryType : AggregateRootWithCompositeKey, 
        IAttendanceEventCategoryType, IAttendanceEventCategoryTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IAttendanceEventCategoryTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int AttendanceEventCategoryTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AttendanceEventCategoryTypeId", AttendanceEventCategoryTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IAttendanceEventCategoryType>
        {
            return this.SynchronizeTo((IAttendanceEventCategoryType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IAttendanceEventCategoryType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IAttendanceEventCategoryTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IAttendanceEventCategoryTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IAttendanceEventCategoryTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: BehaviorDescriptor

namespace EdFi.Ods.Entities.NHibernate.BehaviorDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.BehaviorDescriptor table of the BehaviorDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class BehaviorDescriptor : DescriptorAggregate.Descriptor, 
        IBehaviorDescriptor, IBehaviorDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IBehaviorDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int BehaviorDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        public virtual int? BehaviorTypeId 
        {
            get
            {
                if (_behaviorTypeId == default(int?))
                    _behaviorTypeId = string.IsNullOrWhiteSpace(_behaviorType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("BehaviorType", _behaviorType);

                return _behaviorTypeId;
            } 
            set
            {
                _behaviorTypeId = value;
                _behaviorType = null;
            }
        }

        private int? _behaviorTypeId;
        private string _behaviorType;

        public virtual string BehaviorType
        {
            get
            {
                if (_behaviorType == null)
                    _behaviorType = _behaviorTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("BehaviorType", _behaviorTypeId.Value);
                    
                return _behaviorType;
            }
            set
            {
                _behaviorType = value;
                _behaviorTypeId = default(int?);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "BehaviorType", new LookupColumnDetails { PropertyName = "BehaviorTypeId", LookupTypeName = "BehaviorType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("BehaviorDescriptorId", BehaviorDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IBehaviorDescriptor>
        {
            return this.SynchronizeTo((IBehaviorDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IBehaviorDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isBehaviorTypeSupported = true;
        bool IBehaviorDescriptorSynchronizationSourceSupport.IsBehaviorTypeSupported 
        { 
            get { return _isBehaviorTypeSupported; } 
            set { _isBehaviorTypeSupported = value; }
        }

        private bool _isCodeValueSupported = true;
        bool IBehaviorDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IBehaviorDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool IBehaviorDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool IBehaviorDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool IBehaviorDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool IBehaviorDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IBehaviorDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: BehaviorType

namespace EdFi.Ods.Entities.NHibernate.BehaviorTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.BehaviorType table of the BehaviorType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class BehaviorType : AggregateRootWithCompositeKey, 
        IBehaviorType, IBehaviorTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IBehaviorTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int BehaviorTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("BehaviorTypeId", BehaviorTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IBehaviorType>
        {
            return this.SynchronizeTo((IBehaviorType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IBehaviorType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IBehaviorTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IBehaviorTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IBehaviorTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: BellSchedule

namespace EdFi.Ods.Entities.NHibernate.BellScheduleAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.BellSchedule table of the BellSchedule aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class BellSchedule : AggregateRootWithCompositeKey, 
        IBellSchedule, IBellScheduleRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IBellScheduleSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        public BellSchedule()
        {
            BellScheduleMeetingTimes = new List<BellScheduleMeetingTime>();

        }
// restore warnings for inheritance from classes marked Obsolete
#pragma warning restore 612, 618 
               
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string BellScheduleName  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int GradeLevelDescriptorId 
        {
            get
            {
                if (_gradeLevelDescriptorId == default(int))
                    _gradeLevelDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("GradeLevelDescriptor", _gradeLevelDescriptor);

                return _gradeLevelDescriptorId;
            } 
            set
            {
                _gradeLevelDescriptorId = value;
                _gradeLevelDescriptor = null;
            }
        }

        private int _gradeLevelDescriptorId;
        private string _gradeLevelDescriptor;

        public virtual string GradeLevelDescriptor
        {
            get
            {
                if (_gradeLevelDescriptor == null)
                    _gradeLevelDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("GradeLevelDescriptor", _gradeLevelDescriptorId);
                    
                return _gradeLevelDescriptor;
            }
            set
            {
                _gradeLevelDescriptor = value;
                _gradeLevelDescriptorId = default(int);
            }
        }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int SchoolId  { get; set; }
        [DomainSignature, RequiredWithNonDefault, SqlServerDateTimeRange]
        public virtual DateTime Date 
        {
            get { return _date; }
            //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
            set { _date = new DateTime(value.Year, value.Month, value.Day); }
        }

        private DateTime _date;
        
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------

        private IList<BellScheduleMeetingTime> _bellScheduleMeetingTimes;
        private IList<IBellScheduleMeetingTime> _bellScheduleMeetingTimesCovariant;
        [RequiredCollection]
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<BellScheduleMeetingTime> BellScheduleMeetingTimes
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _bellScheduleMeetingTimes)
                    if (item.BellSchedule == null)
                        item.BellSchedule = this;
                // -------------------------------------------------------------

                return _bellScheduleMeetingTimes;
            }
            set 
            { 
                _bellScheduleMeetingTimes = value;
                _bellScheduleMeetingTimesCovariant = new CovariantIListAdapter<IBellScheduleMeetingTime, BellScheduleMeetingTime>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<IBellScheduleMeetingTime> IBellSchedule.BellScheduleMeetingTimes
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _bellScheduleMeetingTimes)
                    if (item.BellSchedule == null)
                        item.BellSchedule = this;
                // -------------------------------------------------------------

                return _bellScheduleMeetingTimesCovariant; 
            }
            set 
            { 
                BellScheduleMeetingTimes = new List<BellScheduleMeetingTime>(value.Cast<BellScheduleMeetingTime>()); 
            }
        }

        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "GradeLevelDescriptor", new LookupColumnDetails { PropertyName = "GradeLevelDescriptorId", LookupTypeName = "GradeLevelDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("BellScheduleName", BellScheduleName);
            keyValues.Add("Date", Date);
            keyValues.Add("GradeLevelDescriptorId", GradeLevelDescriptorId);
            keyValues.Add("SchoolId", SchoolId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IBellSchedule>
        {
            return this.SynchronizeTo((IBellSchedule)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IBellSchedule) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isBellScheduleMeetingTimesSupported = true;
        bool IBellScheduleSynchronizationSourceSupport.IsBellScheduleMeetingTimesSupported 
        { 
            get { return _isBellScheduleMeetingTimesSupported; } 
            set { _isBellScheduleMeetingTimesSupported = value; }
        }

        private Func<IBellScheduleMeetingTime, bool> _isBellScheduleMeetingTimeIncluded;
        Func<IBellScheduleMeetingTime, bool> IBellScheduleSynchronizationSourceSupport.IsBellScheduleMeetingTimeIncluded
        { 
            get { return _isBellScheduleMeetingTimeIncluded; } 
            set { _isBellScheduleMeetingTimeIncluded = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.BellScheduleMeetingTime table of the BellSchedule aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class BellScheduleMeetingTime : EntityWithCompositeKey, IChildEntity, 
        IBellScheduleMeetingTime, IBellScheduleMeetingTimeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IBellScheduleMeetingTimeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual BellSchedule BellSchedule { get; set; }

        IBellSchedule IBellScheduleMeetingTime.BellSchedule
        {
            get { return BellSchedule; }
            set { BellSchedule = (BellSchedule) value; }
        }

        string IBellScheduleMeetingTimeRecord.BellScheduleName
        {
            get { return ((IBellScheduleRecord) BellSchedule).BellScheduleName; }
            set { ((IBellScheduleRecord) BellSchedule).BellScheduleName = value; }
        }


        int IBellScheduleMeetingTimeRecord.GradeLevelDescriptorId
        {
            get { return ((IBellScheduleRecord) BellSchedule).GradeLevelDescriptorId; }
            set { ((IBellScheduleRecord) BellSchedule).GradeLevelDescriptorId = value; }
        }


        int IBellScheduleMeetingTimeRecord.SchoolId
        {
            get { return ((IBellScheduleRecord) BellSchedule).SchoolId; }
            set { ((IBellScheduleRecord) BellSchedule).SchoolId = value; }
        }


        DateTime IBellScheduleMeetingTimeRecord.Date
        {
            get { return ((IBellScheduleRecord) BellSchedule).Date; }
            set { ((IBellScheduleRecord) BellSchedule).Date = value; }
        }


        [DomainSignature, RequiredWithNonDefault, StringLength(20), NoDangerousText]
        public virtual string ClassPeriodName  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual TimeSpan StartTime  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [StringLength(20), NoDangerousText]
        public virtual string AlternateDayName  { get; set; }
        [RequiredWithNonDefault]
        public virtual TimeSpan EndTime  { get; set; }
        public virtual bool? OfficialAttendancePeriod  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "GradeLevelDescriptor", new LookupColumnDetails { PropertyName = "GradeLevelDescriptorId", LookupTypeName = "GradeLevelDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (BellSchedule as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("ClassPeriodName", ClassPeriodName);
            keyValues.Add("StartTime", StartTime);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IBellScheduleMeetingTime>
        {
            return this.SynchronizeTo((IBellScheduleMeetingTime)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IBellScheduleMeetingTime) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            BellSchedule = (BellSchedule) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAlternateDayNameSupported = true;
        bool IBellScheduleMeetingTimeSynchronizationSourceSupport.IsAlternateDayNameSupported 
        { 
            get { return _isAlternateDayNameSupported; } 
            set { _isAlternateDayNameSupported = value; }
        }

        private bool _isEndTimeSupported = true;
        bool IBellScheduleMeetingTimeSynchronizationSourceSupport.IsEndTimeSupported 
        { 
            get { return _isEndTimeSupported; } 
            set { _isEndTimeSupported = value; }
        }

        private bool _isOfficialAttendancePeriodSupported = true;
        bool IBellScheduleMeetingTimeSynchronizationSourceSupport.IsOfficialAttendancePeriodSupported 
        { 
            get { return _isOfficialAttendancePeriodSupported; } 
            set { _isOfficialAttendancePeriodSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: Budget

namespace EdFi.Ods.Entities.NHibernate.BudgetAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.Budget table of the Budget aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class Budget : AggregateRootWithCompositeKey, 
        IBudget, IBudgetRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IBudgetSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault]
        public virtual int EducationOrganizationId  { get; set; }
        [DomainSignature, RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string AccountNumber  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int FiscalYear  { get; set; }
        [DomainSignature, RequiredWithNonDefault, SqlServerDateTimeRange]
        public virtual DateTime AsOfDate 
        {
            get { return _asOfDate; }
            //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
            set { _asOfDate = new DateTime(value.Year, value.Month, value.Day); }
        }

        private DateTime _asOfDate;
        
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [Range(typeof(decimal), "-999999999999999.9999", "999999999999999.9999")]
        public virtual decimal Amount  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AccountNumber", AccountNumber);
            keyValues.Add("AsOfDate", AsOfDate);
            keyValues.Add("EducationOrganizationId", EducationOrganizationId);
            keyValues.Add("FiscalYear", FiscalYear);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IBudget>
        {
            return this.SynchronizeTo((IBudget)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IBudget) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAmountSupported = true;
        bool IBudgetSynchronizationSourceSupport.IsAmountSupported 
        { 
            get { return _isAmountSupported; } 
            set { _isAmountSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CalendarDate

namespace EdFi.Ods.Entities.NHibernate.CalendarDateAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CalendarDate table of the CalendarDate aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CalendarDate : AggregateRootWithCompositeKey, 
        ICalendarDate, ICalendarDateRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICalendarDateSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        public CalendarDate()
        {
            CalendarDateCalendarEvents = new List<CalendarDateCalendarEvent>();

        }
// restore warnings for inheritance from classes marked Obsolete
#pragma warning restore 612, 618 
               
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault]
        public virtual int SchoolId  { get; set; }
        [DomainSignature, RequiredWithNonDefault, SqlServerDateTimeRange]
        public virtual DateTime Date 
        {
            get { return _date; }
            //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
            set { _date = new DateTime(value.Year, value.Month, value.Day); }
        }

        private DateTime _date;
        
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------

        private IList<CalendarDateCalendarEvent> _calendarDateCalendarEvents;
        private IList<ICalendarDateCalendarEvent> _calendarDateCalendarEventsCovariant;
        [RequiredCollection]
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<CalendarDateCalendarEvent> CalendarDateCalendarEvents
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _calendarDateCalendarEvents)
                    if (item.CalendarDate == null)
                        item.CalendarDate = this;
                // -------------------------------------------------------------

                return _calendarDateCalendarEvents;
            }
            set 
            { 
                _calendarDateCalendarEvents = value;
                _calendarDateCalendarEventsCovariant = new CovariantIListAdapter<ICalendarDateCalendarEvent, CalendarDateCalendarEvent>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<ICalendarDateCalendarEvent> ICalendarDate.CalendarDateCalendarEvents
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _calendarDateCalendarEvents)
                    if (item.CalendarDate == null)
                        item.CalendarDate = this;
                // -------------------------------------------------------------

                return _calendarDateCalendarEventsCovariant; 
            }
            set 
            { 
                CalendarDateCalendarEvents = new List<CalendarDateCalendarEvent>(value.Cast<CalendarDateCalendarEvent>()); 
            }
        }

        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("Date", Date);
            keyValues.Add("SchoolId", SchoolId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICalendarDate>
        {
            return this.SynchronizeTo((ICalendarDate)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICalendarDate) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCalendarDateCalendarEventsSupported = true;
        bool ICalendarDateSynchronizationSourceSupport.IsCalendarDateCalendarEventsSupported 
        { 
            get { return _isCalendarDateCalendarEventsSupported; } 
            set { _isCalendarDateCalendarEventsSupported = value; }
        }

        private Func<ICalendarDateCalendarEvent, bool> _isCalendarDateCalendarEventIncluded;
        Func<ICalendarDateCalendarEvent, bool> ICalendarDateSynchronizationSourceSupport.IsCalendarDateCalendarEventIncluded
        { 
            get { return _isCalendarDateCalendarEventIncluded; } 
            set { _isCalendarDateCalendarEventIncluded = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CalendarDateCalendarEvent table of the CalendarDate aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CalendarDateCalendarEvent : EntityWithCompositeKey, IChildEntity, 
        ICalendarDateCalendarEvent, ICalendarDateCalendarEventRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICalendarDateCalendarEventSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual CalendarDate CalendarDate { get; set; }

        ICalendarDate ICalendarDateCalendarEvent.CalendarDate
        {
            get { return CalendarDate; }
            set { CalendarDate = (CalendarDate) value; }
        }

        int ICalendarDateCalendarEventRecord.SchoolId
        {
            get { return ((ICalendarDateRecord) CalendarDate).SchoolId; }
            set { ((ICalendarDateRecord) CalendarDate).SchoolId = value; }
        }


        DateTime ICalendarDateCalendarEventRecord.Date
        {
            get { return ((ICalendarDateRecord) CalendarDate).Date; }
            set { ((ICalendarDateRecord) CalendarDate).Date = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int CalendarEventDescriptorId 
        {
            get
            {
                if (_calendarEventDescriptorId == default(int))
                    _calendarEventDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("CalendarEventDescriptor", _calendarEventDescriptor);

                return _calendarEventDescriptorId;
            } 
            set
            {
                _calendarEventDescriptorId = value;
                _calendarEventDescriptor = null;
            }
        }

        private int _calendarEventDescriptorId;
        private string _calendarEventDescriptor;

        public virtual string CalendarEventDescriptor
        {
            get
            {
                if (_calendarEventDescriptor == null)
                    _calendarEventDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("CalendarEventDescriptor", _calendarEventDescriptorId);
                    
                return _calendarEventDescriptor;
            }
            set
            {
                _calendarEventDescriptor = value;
                _calendarEventDescriptorId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [Range(typeof(decimal), "-9.99", "9.99")]
        public virtual decimal EventDuration  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "CalendarEventDescriptor", new LookupColumnDetails { PropertyName = "CalendarEventDescriptorId", LookupTypeName = "CalendarEventDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (CalendarDate as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("CalendarEventDescriptorId", CalendarEventDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICalendarDateCalendarEvent>
        {
            return this.SynchronizeTo((ICalendarDateCalendarEvent)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICalendarDateCalendarEvent) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            CalendarDate = (CalendarDate) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isEventDurationSupported = true;
        bool ICalendarDateCalendarEventSynchronizationSourceSupport.IsEventDurationSupported 
        { 
            get { return _isEventDurationSupported; } 
            set { _isEventDurationSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CalendarEventDescriptor

namespace EdFi.Ods.Entities.NHibernate.CalendarEventDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CalendarEventDescriptor table of the CalendarEventDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CalendarEventDescriptor : DescriptorAggregate.Descriptor, 
        ICalendarEventDescriptor, ICalendarEventDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICalendarEventDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CalendarEventDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault]
        public virtual int CalendarEventTypeId 
        {
            get
            {
                if (_calendarEventTypeId == default(int))
                    _calendarEventTypeId = TypesAndDescriptorsCache.GetCache().GetId("CalendarEventType", _calendarEventType);

                return _calendarEventTypeId;
            } 
            set
            {
                _calendarEventTypeId = value;
                _calendarEventType = null;
            }
        }

        private int _calendarEventTypeId;
        private string _calendarEventType;

        public virtual string CalendarEventType
        {
            get
            {
                if (_calendarEventType == null)
                    _calendarEventType = TypesAndDescriptorsCache.GetCache().GetValue("CalendarEventType", _calendarEventTypeId);
                    
                return _calendarEventType;
            }
            set
            {
                _calendarEventType = value;
                _calendarEventTypeId = default(int);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "CalendarEventType", new LookupColumnDetails { PropertyName = "CalendarEventTypeId", LookupTypeName = "CalendarEventType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CalendarEventDescriptorId", CalendarEventDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICalendarEventDescriptor>
        {
            return this.SynchronizeTo((ICalendarEventDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICalendarEventDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCalendarEventTypeSupported = true;
        bool ICalendarEventDescriptorSynchronizationSourceSupport.IsCalendarEventTypeSupported 
        { 
            get { return _isCalendarEventTypeSupported; } 
            set { _isCalendarEventTypeSupported = value; }
        }

        private bool _isCodeValueSupported = true;
        bool ICalendarEventDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICalendarEventDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool ICalendarEventDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool ICalendarEventDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool ICalendarEventDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool ICalendarEventDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICalendarEventDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CalendarEventType

namespace EdFi.Ods.Entities.NHibernate.CalendarEventTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CalendarEventType table of the CalendarEventType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CalendarEventType : AggregateRootWithCompositeKey, 
        ICalendarEventType, ICalendarEventTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICalendarEventTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CalendarEventTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CalendarEventTypeId", CalendarEventTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICalendarEventType>
        {
            return this.SynchronizeTo((ICalendarEventType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICalendarEventType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICalendarEventTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICalendarEventTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICalendarEventTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CareerPathwayType

namespace EdFi.Ods.Entities.NHibernate.CareerPathwayTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CareerPathwayType table of the CareerPathwayType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CareerPathwayType : AggregateRootWithCompositeKey, 
        ICareerPathwayType, ICareerPathwayTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICareerPathwayTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CareerPathwayTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CareerPathwayTypeId", CareerPathwayTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICareerPathwayType>
        {
            return this.SynchronizeTo((ICareerPathwayType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICareerPathwayType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICareerPathwayTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICareerPathwayTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICareerPathwayTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CharterApprovalAgencyType

namespace EdFi.Ods.Entities.NHibernate.CharterApprovalAgencyTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CharterApprovalAgencyType table of the CharterApprovalAgencyType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CharterApprovalAgencyType : AggregateRootWithCompositeKey, 
        ICharterApprovalAgencyType, ICharterApprovalAgencyTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICharterApprovalAgencyTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CharterApprovalAgencyTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CharterApprovalAgencyTypeId", CharterApprovalAgencyTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICharterApprovalAgencyType>
        {
            return this.SynchronizeTo((ICharterApprovalAgencyType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICharterApprovalAgencyType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICharterApprovalAgencyTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICharterApprovalAgencyTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICharterApprovalAgencyTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CharterStatusType

namespace EdFi.Ods.Entities.NHibernate.CharterStatusTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CharterStatusType table of the CharterStatusType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CharterStatusType : AggregateRootWithCompositeKey, 
        ICharterStatusType, ICharterStatusTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICharterStatusTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CharterStatusTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CharterStatusTypeId", CharterStatusTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICharterStatusType>
        {
            return this.SynchronizeTo((ICharterStatusType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICharterStatusType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICharterStatusTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICharterStatusTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICharterStatusTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CitizenshipStatusType

namespace EdFi.Ods.Entities.NHibernate.CitizenshipStatusTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CitizenshipStatusType table of the CitizenshipStatusType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CitizenshipStatusType : AggregateRootWithCompositeKey, 
        ICitizenshipStatusType, ICitizenshipStatusTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICitizenshipStatusTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CitizenshipStatusTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CitizenshipStatusTypeId", CitizenshipStatusTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICitizenshipStatusType>
        {
            return this.SynchronizeTo((ICitizenshipStatusType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICitizenshipStatusType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICitizenshipStatusTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICitizenshipStatusTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICitizenshipStatusTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: ClassPeriod

namespace EdFi.Ods.Entities.NHibernate.ClassPeriodAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.ClassPeriod table of the ClassPeriod aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class ClassPeriod : AggregateRootWithCompositeKey, IHasCascadableKeyValues,
        IClassPeriod, IClassPeriodRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IClassPeriodSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault]
        public virtual int SchoolId  { get; set; }
        [DomainSignature, RequiredWithNonDefault, StringLength(20), NoDangerousText]
        public virtual string ClassPeriodName  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("ClassPeriodName", ClassPeriodName);
            keyValues.Add("SchoolId", SchoolId);

            return keyValues;
        }

        /// <summary>
        /// Gets or sets the <see cref="OrderedDictionary"/> capturing the new key values that have
        /// not been modified directly on the entity.
        /// </summary>
        OrderedDictionary IHasCascadableKeyValues.NewKeyValues { get; set; }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IClassPeriod>
        {
            return this.SynchronizeTo((IClassPeriod)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IClassPeriod) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 
}
// Aggregate: ClassroomPositionDescriptor

namespace EdFi.Ods.Entities.NHibernate.ClassroomPositionDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.ClassroomPositionDescriptor table of the ClassroomPositionDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class ClassroomPositionDescriptor : DescriptorAggregate.Descriptor, 
        IClassroomPositionDescriptor, IClassroomPositionDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IClassroomPositionDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int ClassroomPositionDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        public virtual int? ClassroomPositionTypeId 
        {
            get
            {
                if (_classroomPositionTypeId == default(int?))
                    _classroomPositionTypeId = string.IsNullOrWhiteSpace(_classroomPositionType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("ClassroomPositionType", _classroomPositionType);

                return _classroomPositionTypeId;
            } 
            set
            {
                _classroomPositionTypeId = value;
                _classroomPositionType = null;
            }
        }

        private int? _classroomPositionTypeId;
        private string _classroomPositionType;

        public virtual string ClassroomPositionType
        {
            get
            {
                if (_classroomPositionType == null)
                    _classroomPositionType = _classroomPositionTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("ClassroomPositionType", _classroomPositionTypeId.Value);
                    
                return _classroomPositionType;
            }
            set
            {
                _classroomPositionType = value;
                _classroomPositionTypeId = default(int?);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "ClassroomPositionType", new LookupColumnDetails { PropertyName = "ClassroomPositionTypeId", LookupTypeName = "ClassroomPositionType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("ClassroomPositionDescriptorId", ClassroomPositionDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IClassroomPositionDescriptor>
        {
            return this.SynchronizeTo((IClassroomPositionDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IClassroomPositionDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isClassroomPositionTypeSupported = true;
        bool IClassroomPositionDescriptorSynchronizationSourceSupport.IsClassroomPositionTypeSupported 
        { 
            get { return _isClassroomPositionTypeSupported; } 
            set { _isClassroomPositionTypeSupported = value; }
        }

        private bool _isCodeValueSupported = true;
        bool IClassroomPositionDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IClassroomPositionDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool IClassroomPositionDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool IClassroomPositionDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool IClassroomPositionDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool IClassroomPositionDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IClassroomPositionDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: ClassroomPositionType

namespace EdFi.Ods.Entities.NHibernate.ClassroomPositionTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.ClassroomPositionType table of the ClassroomPositionType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class ClassroomPositionType : AggregateRootWithCompositeKey, 
        IClassroomPositionType, IClassroomPositionTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IClassroomPositionTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int ClassroomPositionTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("ClassroomPositionTypeId", ClassroomPositionTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IClassroomPositionType>
        {
            return this.SynchronizeTo((IClassroomPositionType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IClassroomPositionType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IClassroomPositionTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IClassroomPositionTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IClassroomPositionTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: Cohort

namespace EdFi.Ods.Entities.NHibernate.CohortAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.Cohort table of the Cohort aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class Cohort : AggregateRootWithCompositeKey, 
        ICohort, ICohortRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICohortSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        public Cohort()
        {
            CohortPrograms = new List<CohortProgram>();

        }
// restore warnings for inheritance from classes marked Obsolete
#pragma warning restore 612, 618 
               
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault, StringLength(20), NoDangerousText]
        public virtual string CohortIdentifier  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int EducationOrganizationId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        public virtual int? AcademicSubjectDescriptorId 
        {
            get
            {
                if (_academicSubjectDescriptorId == default(int?))
                    _academicSubjectDescriptorId = string.IsNullOrWhiteSpace(_academicSubjectDescriptor) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("AcademicSubjectDescriptor", _academicSubjectDescriptor);

                return _academicSubjectDescriptorId;
            } 
            set
            {
                _academicSubjectDescriptorId = value;
                _academicSubjectDescriptor = null;
            }
        }

        private int? _academicSubjectDescriptorId;
        private string _academicSubjectDescriptor;

        public virtual string AcademicSubjectDescriptor
        {
            get
            {
                if (_academicSubjectDescriptor == null)
                    _academicSubjectDescriptor = _academicSubjectDescriptorId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("AcademicSubjectDescriptor", _academicSubjectDescriptorId.Value);
                    
                return _academicSubjectDescriptor;
            }
            set
            {
                _academicSubjectDescriptor = value;
                _academicSubjectDescriptorId = default(int?);
            }
        }
        [StringLength(1024), NoDangerousText]
        public virtual string CohortDescription  { get; set; }
        public virtual int? CohortScopeTypeId 
        {
            get
            {
                if (_cohortScopeTypeId == default(int?))
                    _cohortScopeTypeId = string.IsNullOrWhiteSpace(_cohortScopeType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("CohortScopeType", _cohortScopeType);

                return _cohortScopeTypeId;
            } 
            set
            {
                _cohortScopeTypeId = value;
                _cohortScopeType = null;
            }
        }

        private int? _cohortScopeTypeId;
        private string _cohortScopeType;

        public virtual string CohortScopeType
        {
            get
            {
                if (_cohortScopeType == null)
                    _cohortScopeType = _cohortScopeTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("CohortScopeType", _cohortScopeTypeId.Value);
                    
                return _cohortScopeType;
            }
            set
            {
                _cohortScopeType = value;
                _cohortScopeTypeId = default(int?);
            }
        }
        [RequiredWithNonDefault]
        public virtual int CohortTypeId 
        {
            get
            {
                if (_cohortTypeId == default(int))
                    _cohortTypeId = TypesAndDescriptorsCache.GetCache().GetId("CohortType", _cohortType);

                return _cohortTypeId;
            } 
            set
            {
                _cohortTypeId = value;
                _cohortType = null;
            }
        }

        private int _cohortTypeId;
        private string _cohortType;

        public virtual string CohortType
        {
            get
            {
                if (_cohortType == null)
                    _cohortType = TypesAndDescriptorsCache.GetCache().GetValue("CohortType", _cohortTypeId);
                    
                return _cohortType;
            }
            set
            {
                _cohortType = value;
                _cohortTypeId = default(int);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------

        private IList<CohortProgram> _cohortPrograms;
        private IList<ICohortProgram> _cohortProgramsCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<CohortProgram> CohortPrograms
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _cohortPrograms)
                    if (item.Cohort == null)
                        item.Cohort = this;
                // -------------------------------------------------------------

                return _cohortPrograms;
            }
            set 
            { 
                _cohortPrograms = value;
                _cohortProgramsCovariant = new CovariantIListAdapter<ICohortProgram, CohortProgram>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<ICohortProgram> ICohort.CohortPrograms
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _cohortPrograms)
                    if (item.Cohort == null)
                        item.Cohort = this;
                // -------------------------------------------------------------

                return _cohortProgramsCovariant; 
            }
            set 
            { 
                CohortPrograms = new List<CohortProgram>(value.Cast<CohortProgram>()); 
            }
        }

        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
                { "CohortScopeType", new LookupColumnDetails { PropertyName = "CohortScopeTypeId", LookupTypeName = "CohortScopeType"} },
                { "CohortType", new LookupColumnDetails { PropertyName = "CohortTypeId", LookupTypeName = "CohortType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CohortIdentifier", CohortIdentifier);
            keyValues.Add("EducationOrganizationId", EducationOrganizationId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICohort>
        {
            return this.SynchronizeTo((ICohort)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICohort) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAcademicSubjectDescriptorSupported = true;
        bool ICohortSynchronizationSourceSupport.IsAcademicSubjectDescriptorSupported 
        { 
            get { return _isAcademicSubjectDescriptorSupported; } 
            set { _isAcademicSubjectDescriptorSupported = value; }
        }

        private bool _isCohortDescriptionSupported = true;
        bool ICohortSynchronizationSourceSupport.IsCohortDescriptionSupported 
        { 
            get { return _isCohortDescriptionSupported; } 
            set { _isCohortDescriptionSupported = value; }
        }

        private bool _isCohortProgramsSupported = true;
        bool ICohortSynchronizationSourceSupport.IsCohortProgramsSupported 
        { 
            get { return _isCohortProgramsSupported; } 
            set { _isCohortProgramsSupported = value; }
        }

        private bool _isCohortScopeTypeSupported = true;
        bool ICohortSynchronizationSourceSupport.IsCohortScopeTypeSupported 
        { 
            get { return _isCohortScopeTypeSupported; } 
            set { _isCohortScopeTypeSupported = value; }
        }

        private bool _isCohortTypeSupported = true;
        bool ICohortSynchronizationSourceSupport.IsCohortTypeSupported 
        { 
            get { return _isCohortTypeSupported; } 
            set { _isCohortTypeSupported = value; }
        }

        private Func<ICohortProgram, bool> _isCohortProgramIncluded;
        Func<ICohortProgram, bool> ICohortSynchronizationSourceSupport.IsCohortProgramIncluded
        { 
            get { return _isCohortProgramIncluded; } 
            set { _isCohortProgramIncluded = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CohortProgram table of the Cohort aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CohortProgram : EntityWithCompositeKey, IChildEntity, 
        ICohortProgram, ICohortProgramRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICohortProgramSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual Cohort Cohort { get; set; }

        ICohort ICohortProgram.Cohort
        {
            get { return Cohort; }
            set { Cohort = (Cohort) value; }
        }

        string ICohortProgramRecord.CohortIdentifier
        {
            get { return ((ICohortRecord) Cohort).CohortIdentifier; }
            set { ((ICohortRecord) Cohort).CohortIdentifier = value; }
        }


        int ICohortProgramRecord.EducationOrganizationId
        {
            get { return ((ICohortRecord) Cohort).EducationOrganizationId; }
            set { ((ICohortRecord) Cohort).EducationOrganizationId = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int ProgramEducationOrganizationId  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int ProgramTypeId 
        {
            get
            {
                if (_programTypeId == default(int))
                    _programTypeId = TypesAndDescriptorsCache.GetCache().GetId("ProgramType", _programType);

                return _programTypeId;
            } 
            set
            {
                _programTypeId = value;
                _programType = null;
            }
        }

        private int _programTypeId;
        private string _programType;

        public virtual string ProgramType
        {
            get
            {
                if (_programType == null)
                    _programType = TypesAndDescriptorsCache.GetCache().GetValue("ProgramType", _programTypeId);
                    
                return _programType;
            }
            set
            {
                _programType = value;
                _programTypeId = default(int);
            }
        }
        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string ProgramName  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "ProgramType", new LookupColumnDetails { PropertyName = "ProgramTypeId", LookupTypeName = "ProgramType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (Cohort as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("ProgramEducationOrganizationId", ProgramEducationOrganizationId);
            keyValues.Add("ProgramName", ProgramName);
            keyValues.Add("ProgramTypeId", ProgramTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICohortProgram>
        {
            return this.SynchronizeTo((ICohortProgram)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICohortProgram) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            Cohort = (Cohort) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 
}
// Aggregate: CohortScopeType

namespace EdFi.Ods.Entities.NHibernate.CohortScopeTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CohortScopeType table of the CohortScopeType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CohortScopeType : AggregateRootWithCompositeKey, 
        ICohortScopeType, ICohortScopeTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICohortScopeTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CohortScopeTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CohortScopeTypeId", CohortScopeTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICohortScopeType>
        {
            return this.SynchronizeTo((ICohortScopeType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICohortScopeType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICohortScopeTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICohortScopeTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICohortScopeTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CohortType

namespace EdFi.Ods.Entities.NHibernate.CohortTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CohortType table of the CohortType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CohortType : AggregateRootWithCompositeKey, 
        ICohortType, ICohortTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICohortTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CohortTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CohortTypeId", CohortTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICohortType>
        {
            return this.SynchronizeTo((ICohortType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICohortType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICohortTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICohortTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICohortTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CohortYearType

namespace EdFi.Ods.Entities.NHibernate.CohortYearTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CohortYearType table of the CohortYearType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CohortYearType : AggregateRootWithCompositeKey, 
        ICohortYearType, ICohortYearTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICohortYearTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CohortYearTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CohortYearTypeId", CohortYearTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICohortYearType>
        {
            return this.SynchronizeTo((ICohortYearType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICohortYearType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICohortYearTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICohortYearTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICohortYearTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: College

namespace EdFi.Ods.Entities.NHibernate.CollegeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the extension.College table of the College aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class College : AggregateRootWithCompositeKey, 
        ICollege, ICollegeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICollegeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault]
        public virtual int EducationOrganizationId  { get; set; }
        [DomainSignature, RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string FSAId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CarnegieClassification  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("EducationOrganizationId", EducationOrganizationId);
            keyValues.Add("FSAId", FSAId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICollege>
        {
            return this.SynchronizeTo((ICollege)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICollege) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCarnegieClassificationSupported = true;
        bool ICollegeSynchronizationSourceSupport.IsCarnegieClassificationSupported 
        { 
            get { return _isCarnegieClassificationSupported; } 
            set { _isCarnegieClassificationSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CollegeMajorType

namespace EdFi.Ods.Entities.NHibernate.CollegeMajorTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the extension.CollegeMajorType table of the CollegeMajorType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CollegeMajorType : AggregateRootWithCompositeKey, 
        ICollegeMajorType, ICollegeMajorTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICollegeMajorTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CollegeMajorTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CollegeMajorTypeId", CollegeMajorTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICollegeMajorType>
        {
            return this.SynchronizeTo((ICollegeMajorType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICollegeMajorType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICollegeMajorTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICollegeMajorTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICollegeMajorTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CollegeScholarshipApplicationStatusType

namespace EdFi.Ods.Entities.NHibernate.CollegeScholarshipApplicationStatusTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the extension.CollegeScholarshipApplicationStatusType table of the CollegeScholarshipApplicationStatusType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CollegeScholarshipApplicationStatusType : AggregateRootWithCompositeKey, 
        ICollegeScholarshipApplicationStatusType, ICollegeScholarshipApplicationStatusTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICollegeScholarshipApplicationStatusTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CollegeScholarshipApplicationStatusTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CollegeScholarshipApplicationStatusTypeId", CollegeScholarshipApplicationStatusTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICollegeScholarshipApplicationStatusType>
        {
            return this.SynchronizeTo((ICollegeScholarshipApplicationStatusType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICollegeScholarshipApplicationStatusType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICollegeScholarshipApplicationStatusTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICollegeScholarshipApplicationStatusTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICollegeScholarshipApplicationStatusTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CollegeSection

namespace EdFi.Ods.Entities.NHibernate.CollegeSectionAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the extension.CollegeSection table of the CollegeSection aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CollegeSection : AggregateRootWithCompositeKey, 
        ICollegeSection, ICollegeSectionRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICollegeSectionSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault, StringLength(20), NoDangerousText]
        public virtual string ClassPeriodName  { get; set; }
        [DomainSignature, RequiredWithNonDefault, StringLength(20), NoDangerousText]
        public virtual string ClassroomIdentificationCode  { get; set; }
        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string LocalCourseCode  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int SchoolId  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual short SchoolYear  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int SequenceOfCourse  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int TermDescriptorId 
        {
            get
            {
                if (_termDescriptorId == default(int))
                    _termDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("TermDescriptor", _termDescriptor);

                return _termDescriptorId;
            } 
            set
            {
                _termDescriptorId = value;
                _termDescriptor = null;
            }
        }

        private int _termDescriptorId;
        private string _termDescriptor;

        public virtual string TermDescriptor
        {
            get
            {
                if (_termDescriptor == null)
                    _termDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("TermDescriptor", _termDescriptorId);
                    
                return _termDescriptor;
            }
            set
            {
                _termDescriptor = value;
                _termDescriptorId = default(int);
            }
        }
        [DomainSignature, RequiredWithNonDefault, StringLength(255), NoDangerousText]
        public virtual string UniqueSectionCode  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [Range(typeof(decimal), "-99.999", "99.999")]
        public virtual decimal? AvailableCredits  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "TermDescriptor", new LookupColumnDetails { PropertyName = "TermDescriptorId", LookupTypeName = "TermDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("ClassPeriodName", ClassPeriodName);
            keyValues.Add("ClassroomIdentificationCode", ClassroomIdentificationCode);
            keyValues.Add("LocalCourseCode", LocalCourseCode);
            keyValues.Add("SchoolId", SchoolId);
            keyValues.Add("SchoolYear", SchoolYear);
            keyValues.Add("SequenceOfCourse", SequenceOfCourse);
            keyValues.Add("TermDescriptorId", TermDescriptorId);
            keyValues.Add("UniqueSectionCode", UniqueSectionCode);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICollegeSection>
        {
            return this.SynchronizeTo((ICollegeSection)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICollegeSection) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAvailableCreditsSupported = true;
        bool ICollegeSectionSynchronizationSourceSupport.IsAvailableCreditsSupported 
        { 
            get { return _isAvailableCreditsSupported; } 
            set { _isAvailableCreditsSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CompetencyLevelDescriptor

namespace EdFi.Ods.Entities.NHibernate.CompetencyLevelDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CompetencyLevelDescriptor table of the CompetencyLevelDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CompetencyLevelDescriptor : DescriptorAggregate.Descriptor, 
        ICompetencyLevelDescriptor, ICompetencyLevelDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICompetencyLevelDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CompetencyLevelDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        public virtual int? PerformanceBaseConversionTypeId 
        {
            get
            {
                if (_performanceBaseConversionTypeId == default(int?))
                    _performanceBaseConversionTypeId = string.IsNullOrWhiteSpace(_performanceBaseConversionType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("PerformanceBaseConversionType", _performanceBaseConversionType);

                return _performanceBaseConversionTypeId;
            } 
            set
            {
                _performanceBaseConversionTypeId = value;
                _performanceBaseConversionType = null;
            }
        }

        private int? _performanceBaseConversionTypeId;
        private string _performanceBaseConversionType;

        public virtual string PerformanceBaseConversionType
        {
            get
            {
                if (_performanceBaseConversionType == null)
                    _performanceBaseConversionType = _performanceBaseConversionTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("PerformanceBaseConversionType", _performanceBaseConversionTypeId.Value);
                    
                return _performanceBaseConversionType;
            }
            set
            {
                _performanceBaseConversionType = value;
                _performanceBaseConversionTypeId = default(int?);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "PerformanceBaseConversionType", new LookupColumnDetails { PropertyName = "PerformanceBaseConversionTypeId", LookupTypeName = "PerformanceBaseConversionType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CompetencyLevelDescriptorId", CompetencyLevelDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICompetencyLevelDescriptor>
        {
            return this.SynchronizeTo((ICompetencyLevelDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICompetencyLevelDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICompetencyLevelDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICompetencyLevelDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool ICompetencyLevelDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool ICompetencyLevelDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool ICompetencyLevelDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPerformanceBaseConversionTypeSupported = true;
        bool ICompetencyLevelDescriptorSynchronizationSourceSupport.IsPerformanceBaseConversionTypeSupported 
        { 
            get { return _isPerformanceBaseConversionTypeSupported; } 
            set { _isPerformanceBaseConversionTypeSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool ICompetencyLevelDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICompetencyLevelDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CompetencyObjective

namespace EdFi.Ods.Entities.NHibernate.CompetencyObjectiveAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CompetencyObjective table of the CompetencyObjective aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CompetencyObjective : AggregateRootWithCompositeKey, 
        ICompetencyObjective, ICompetencyObjectiveRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICompetencyObjectiveSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string Objective  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int ObjectiveGradeLevelDescriptorId 
        {
            get
            {
                if (_objectiveGradeLevelDescriptorId == default(int))
                    _objectiveGradeLevelDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("GradeLevelDescriptor", _objectiveGradeLevelDescriptor);

                return _objectiveGradeLevelDescriptorId;
            } 
            set
            {
                _objectiveGradeLevelDescriptorId = value;
                _objectiveGradeLevelDescriptor = null;
            }
        }

        private int _objectiveGradeLevelDescriptorId;
        private string _objectiveGradeLevelDescriptor;

        public virtual string ObjectiveGradeLevelDescriptor
        {
            get
            {
                if (_objectiveGradeLevelDescriptor == null)
                    _objectiveGradeLevelDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("GradeLevelDescriptor", _objectiveGradeLevelDescriptorId);
                    
                return _objectiveGradeLevelDescriptor;
            }
            set
            {
                _objectiveGradeLevelDescriptor = value;
                _objectiveGradeLevelDescriptorId = default(int);
            }
        }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int EducationOrganizationId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [StringLength(60), NoDangerousText]
        public virtual string CompetencyObjectiveId  { get; set; }
        [StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [StringLength(150), NoDangerousText]
        public virtual string SuccessCriteria  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "ObjectiveGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "ObjectiveGradeLevelDescriptorId", LookupTypeName = "ObjectiveGradeLevelDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("EducationOrganizationId", EducationOrganizationId);
            keyValues.Add("Objective", Objective);
            keyValues.Add("ObjectiveGradeLevelDescriptorId", ObjectiveGradeLevelDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICompetencyObjective>
        {
            return this.SynchronizeTo((ICompetencyObjective)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICompetencyObjective) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCompetencyObjectiveIdSupported = true;
        bool ICompetencyObjectiveSynchronizationSourceSupport.IsCompetencyObjectiveIdSupported 
        { 
            get { return _isCompetencyObjectiveIdSupported; } 
            set { _isCompetencyObjectiveIdSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICompetencyObjectiveSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isSuccessCriteriaSupported = true;
        bool ICompetencyObjectiveSynchronizationSourceSupport.IsSuccessCriteriaSupported 
        { 
            get { return _isSuccessCriteriaSupported; } 
            set { _isSuccessCriteriaSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: ContentClassType

namespace EdFi.Ods.Entities.NHibernate.ContentClassTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.ContentClassType table of the ContentClassType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class ContentClassType : AggregateRootWithCompositeKey, 
        IContentClassType, IContentClassTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IContentClassTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int ContentClassTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("ContentClassTypeId", ContentClassTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IContentClassType>
        {
            return this.SynchronizeTo((IContentClassType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IContentClassType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IContentClassTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IContentClassTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IContentClassTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: ContinuationOfServicesReasonDescriptor

namespace EdFi.Ods.Entities.NHibernate.ContinuationOfServicesReasonDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.ContinuationOfServicesReasonDescriptor table of the ContinuationOfServicesReasonDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class ContinuationOfServicesReasonDescriptor : DescriptorAggregate.Descriptor, 
        IContinuationOfServicesReasonDescriptor, IContinuationOfServicesReasonDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IContinuationOfServicesReasonDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int ContinuationOfServicesReasonDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault]
        public virtual int ContinuationOfServicesReasonTypeId 
        {
            get
            {
                if (_continuationOfServicesReasonTypeId == default(int))
                    _continuationOfServicesReasonTypeId = TypesAndDescriptorsCache.GetCache().GetId("ContinuationOfServicesReasonType", _continuationOfServicesReasonType);

                return _continuationOfServicesReasonTypeId;
            } 
            set
            {
                _continuationOfServicesReasonTypeId = value;
                _continuationOfServicesReasonType = null;
            }
        }

        private int _continuationOfServicesReasonTypeId;
        private string _continuationOfServicesReasonType;

        public virtual string ContinuationOfServicesReasonType
        {
            get
            {
                if (_continuationOfServicesReasonType == null)
                    _continuationOfServicesReasonType = TypesAndDescriptorsCache.GetCache().GetValue("ContinuationOfServicesReasonType", _continuationOfServicesReasonTypeId);
                    
                return _continuationOfServicesReasonType;
            }
            set
            {
                _continuationOfServicesReasonType = value;
                _continuationOfServicesReasonTypeId = default(int);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "ContinuationOfServicesReasonType", new LookupColumnDetails { PropertyName = "ContinuationOfServicesReasonTypeId", LookupTypeName = "ContinuationOfServicesReasonType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("ContinuationOfServicesReasonDescriptorId", ContinuationOfServicesReasonDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IContinuationOfServicesReasonDescriptor>
        {
            return this.SynchronizeTo((IContinuationOfServicesReasonDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IContinuationOfServicesReasonDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IContinuationOfServicesReasonDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isContinuationOfServicesReasonTypeSupported = true;
        bool IContinuationOfServicesReasonDescriptorSynchronizationSourceSupport.IsContinuationOfServicesReasonTypeSupported 
        { 
            get { return _isContinuationOfServicesReasonTypeSupported; } 
            set { _isContinuationOfServicesReasonTypeSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IContinuationOfServicesReasonDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool IContinuationOfServicesReasonDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool IContinuationOfServicesReasonDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool IContinuationOfServicesReasonDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool IContinuationOfServicesReasonDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IContinuationOfServicesReasonDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: ContinuationOfServicesReasonType

namespace EdFi.Ods.Entities.NHibernate.ContinuationOfServicesReasonTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.ContinuationOfServicesReasonType table of the ContinuationOfServicesReasonType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class ContinuationOfServicesReasonType : AggregateRootWithCompositeKey, 
        IContinuationOfServicesReasonType, IContinuationOfServicesReasonTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IContinuationOfServicesReasonTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int ContinuationOfServicesReasonTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("ContinuationOfServicesReasonTypeId", ContinuationOfServicesReasonTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IContinuationOfServicesReasonType>
        {
            return this.SynchronizeTo((IContinuationOfServicesReasonType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IContinuationOfServicesReasonType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IContinuationOfServicesReasonTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IContinuationOfServicesReasonTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IContinuationOfServicesReasonTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: ContractedStaff

namespace EdFi.Ods.Entities.NHibernate.ContractedStaffAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.ContractedStaff table of the ContractedStaff aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class ContractedStaff : AggregateRootWithCompositeKey, 
        IContractedStaff, IContractedStaffRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IContractedStaffSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [Display(Name="StaffUniqueId")]
        [DomainSignature, RequiredWithNonDefault]
        public virtual int StaffUSI 
        {
            get
            {
                if (_staffUSI == default(int))
                    _staffUSI = PersonUniqueIdToUsiCache.GetCache().GetUsi("Staff", _staffUniqueId);

                return _staffUSI;
            } 
            set
            {
                _staffUSI = value;
            }
        }

        private int _staffUSI;
        private string _staffUniqueId;

        public virtual string StaffUniqueId
        {
            get
            {
                if (_staffUniqueId == null)
                    _staffUniqueId = PersonUniqueIdToUsiCache.GetCache().GetUniqueId("Staff", _staffUSI);
                    
                return _staffUniqueId;
            }
            set
            {
                _staffUniqueId = value;
            }
        }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int EducationOrganizationId  { get; set; }
        [DomainSignature, RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string AccountNumber  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int FiscalYear  { get; set; }
        [DomainSignature, RequiredWithNonDefault, SqlServerDateTimeRange]
        public virtual DateTime AsOfDate 
        {
            get { return _asOfDate; }
            //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
            set { _asOfDate = new DateTime(value.Year, value.Month, value.Day); }
        }

        private DateTime _asOfDate;
        
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [Range(typeof(decimal), "-999999999999999.9999", "999999999999999.9999")]
        public virtual decimal AmountToDate  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("AccountNumber", AccountNumber);
            keyValues.Add("AsOfDate", AsOfDate);
            keyValues.Add("EducationOrganizationId", EducationOrganizationId);
            keyValues.Add("FiscalYear", FiscalYear);
            keyValues.Add("StaffUSI", StaffUSI);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IContractedStaff>
        {
            return this.SynchronizeTo((IContractedStaff)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IContractedStaff) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAmountToDateSupported = true;
        bool IContractedStaffSynchronizationSourceSupport.IsAmountToDateSupported 
        { 
            get { return _isAmountToDateSupported; } 
            set { _isAmountToDateSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CostRateType

namespace EdFi.Ods.Entities.NHibernate.CostRateTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CostRateType table of the CostRateType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CostRateType : AggregateRootWithCompositeKey, 
        ICostRateType, ICostRateTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICostRateTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CostRateTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CostRateTypeId", CostRateTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICostRateType>
        {
            return this.SynchronizeTo((ICostRateType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICostRateType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICostRateTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICostRateTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICostRateTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CountryDescriptor

namespace EdFi.Ods.Entities.NHibernate.CountryDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CountryDescriptor table of the CountryDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CountryDescriptor : DescriptorAggregate.Descriptor, 
        ICountryDescriptor, ICountryDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICountryDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CountryDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CountryDescriptorId", CountryDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICountryDescriptor>
        {
            return this.SynchronizeTo((ICountryDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICountryDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICountryDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICountryDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool ICountryDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool ICountryDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool ICountryDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool ICountryDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICountryDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: Course

namespace EdFi.Ods.Entities.NHibernate.CourseAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.Course table of the Course aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class Course : AggregateRootWithCompositeKey, 
        ICourse, ICourseRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        public Course()
        {
            CourseCompetencyLevels = new List<CourseCompetencyLevel>();
            CourseIdentificationCodes = new List<CourseIdentificationCode>();
            CourseLearningObjectives = new List<CourseLearningObjective>();
            CourseLearningStandards = new List<CourseLearningStandard>();
            CourseLevelCharacteristics = new List<CourseLevelCharacteristic>();
            CourseOfferedGradeLevels = new List<CourseOfferedGradeLevel>();

        }
// restore warnings for inheritance from classes marked Obsolete
#pragma warning restore 612, 618 
               
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault]
        public virtual int EducationOrganizationId  { get; set; }
        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string CourseCode  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        public virtual int? AcademicSubjectDescriptorId 
        {
            get
            {
                if (_academicSubjectDescriptorId == default(int?))
                    _academicSubjectDescriptorId = string.IsNullOrWhiteSpace(_academicSubjectDescriptor) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("AcademicSubjectDescriptor", _academicSubjectDescriptor);

                return _academicSubjectDescriptorId;
            } 
            set
            {
                _academicSubjectDescriptorId = value;
                _academicSubjectDescriptor = null;
            }
        }

        private int? _academicSubjectDescriptorId;
        private string _academicSubjectDescriptor;

        public virtual string AcademicSubjectDescriptor
        {
            get
            {
                if (_academicSubjectDescriptor == null)
                    _academicSubjectDescriptor = _academicSubjectDescriptorId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("AcademicSubjectDescriptor", _academicSubjectDescriptorId.Value);
                    
                return _academicSubjectDescriptor;
            }
            set
            {
                _academicSubjectDescriptor = value;
                _academicSubjectDescriptorId = default(int?);
            }
        }
        public virtual int? CareerPathwayTypeId 
        {
            get
            {
                if (_careerPathwayTypeId == default(int?))
                    _careerPathwayTypeId = string.IsNullOrWhiteSpace(_careerPathwayType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("CareerPathwayType", _careerPathwayType);

                return _careerPathwayTypeId;
            } 
            set
            {
                _careerPathwayTypeId = value;
                _careerPathwayType = null;
            }
        }

        private int? _careerPathwayTypeId;
        private string _careerPathwayType;

        public virtual string CareerPathwayType
        {
            get
            {
                if (_careerPathwayType == null)
                    _careerPathwayType = _careerPathwayTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("CareerPathwayType", _careerPathwayTypeId.Value);
                    
                return _careerPathwayType;
            }
            set
            {
                _careerPathwayType = value;
                _careerPathwayTypeId = default(int?);
            }
        }
        public virtual int? CourseDefinedByTypeId 
        {
            get
            {
                if (_courseDefinedByTypeId == default(int?))
                    _courseDefinedByTypeId = string.IsNullOrWhiteSpace(_courseDefinedByType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("CourseDefinedByType", _courseDefinedByType);

                return _courseDefinedByTypeId;
            } 
            set
            {
                _courseDefinedByTypeId = value;
                _courseDefinedByType = null;
            }
        }

        private int? _courseDefinedByTypeId;
        private string _courseDefinedByType;

        public virtual string CourseDefinedByType
        {
            get
            {
                if (_courseDefinedByType == null)
                    _courseDefinedByType = _courseDefinedByTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("CourseDefinedByType", _courseDefinedByTypeId.Value);
                    
                return _courseDefinedByType;
            }
            set
            {
                _courseDefinedByType = value;
                _courseDefinedByTypeId = default(int?);
            }
        }
        [StringLength(1024), NoDangerousText]
        public virtual string CourseDescription  { get; set; }
        public virtual int? CourseGPAApplicabilityTypeId 
        {
            get
            {
                if (_courseGPAApplicabilityTypeId == default(int?))
                    _courseGPAApplicabilityTypeId = string.IsNullOrWhiteSpace(_courseGPAApplicabilityType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("CourseGPAApplicabilityType", _courseGPAApplicabilityType);

                return _courseGPAApplicabilityTypeId;
            } 
            set
            {
                _courseGPAApplicabilityTypeId = value;
                _courseGPAApplicabilityType = null;
            }
        }

        private int? _courseGPAApplicabilityTypeId;
        private string _courseGPAApplicabilityType;

        public virtual string CourseGPAApplicabilityType
        {
            get
            {
                if (_courseGPAApplicabilityType == null)
                    _courseGPAApplicabilityType = _courseGPAApplicabilityTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("CourseGPAApplicabilityType", _courseGPAApplicabilityTypeId.Value);
                    
                return _courseGPAApplicabilityType;
            }
            set
            {
                _courseGPAApplicabilityType = value;
                _courseGPAApplicabilityTypeId = default(int?);
            }
        }
        [RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string CourseTitle  { get; set; }
        [SqlServerDateTimeRange]
        public virtual DateTime? DateCourseAdopted 
        {
            get { return _dateCourseAdopted; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _dateCourseAdopted = null;
                } else
                {
                    var given = (DateTime) value;
                    _dateCourseAdopted = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _dateCourseAdopted;
        
        public virtual bool? HighSchoolCourseRequirement  { get; set; }
        [Range(typeof(decimal), "-9999999.99", "9999999.99")]
        public virtual decimal? MaximumAvailableCreditConversion  { get; set; }
        [Range(typeof(decimal), "-9999999.99", "9999999.99")]
        public virtual decimal? MaximumAvailableCredits  { get; set; }
        public virtual int? MaximumAvailableCreditTypeId 
        {
            get
            {
                if (_maximumAvailableCreditTypeId == default(int?))
                    _maximumAvailableCreditTypeId = string.IsNullOrWhiteSpace(_maximumAvailableCreditType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("CreditType", _maximumAvailableCreditType);

                return _maximumAvailableCreditTypeId;
            } 
            set
            {
                _maximumAvailableCreditTypeId = value;
                _maximumAvailableCreditType = null;
            }
        }

        private int? _maximumAvailableCreditTypeId;
        private string _maximumAvailableCreditType;

        public virtual string MaximumAvailableCreditType
        {
            get
            {
                if (_maximumAvailableCreditType == null)
                    _maximumAvailableCreditType = _maximumAvailableCreditTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("CreditType", _maximumAvailableCreditTypeId.Value);
                    
                return _maximumAvailableCreditType;
            }
            set
            {
                _maximumAvailableCreditType = value;
                _maximumAvailableCreditTypeId = default(int?);
            }
        }
        [Range(typeof(decimal), "-9999999.99", "9999999.99")]
        public virtual decimal? MinimumAvailableCreditConversion  { get; set; }
        [Range(typeof(decimal), "-9999999.99", "9999999.99")]
        public virtual decimal? MinimumAvailableCredits  { get; set; }
        public virtual int? MinimumAvailableCreditTypeId 
        {
            get
            {
                if (_minimumAvailableCreditTypeId == default(int?))
                    _minimumAvailableCreditTypeId = string.IsNullOrWhiteSpace(_minimumAvailableCreditType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("CreditType", _minimumAvailableCreditType);

                return _minimumAvailableCreditTypeId;
            } 
            set
            {
                _minimumAvailableCreditTypeId = value;
                _minimumAvailableCreditType = null;
            }
        }

        private int? _minimumAvailableCreditTypeId;
        private string _minimumAvailableCreditType;

        public virtual string MinimumAvailableCreditType
        {
            get
            {
                if (_minimumAvailableCreditType == null)
                    _minimumAvailableCreditType = _minimumAvailableCreditTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("CreditType", _minimumAvailableCreditTypeId.Value);
                    
                return _minimumAvailableCreditType;
            }
            set
            {
                _minimumAvailableCreditType = value;
                _minimumAvailableCreditTypeId = default(int?);
            }
        }
        public virtual int NumberOfParts  { get; set; }
        public virtual int? TimeRequiredForCompletion  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------

        private IList<CourseCompetencyLevel> _courseCompetencyLevels;
        private IList<ICourseCompetencyLevel> _courseCompetencyLevelsCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<CourseCompetencyLevel> CourseCompetencyLevels
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseCompetencyLevels)
                    if (item.Course == null)
                        item.Course = this;
                // -------------------------------------------------------------

                return _courseCompetencyLevels;
            }
            set 
            { 
                _courseCompetencyLevels = value;
                _courseCompetencyLevelsCovariant = new CovariantIListAdapter<ICourseCompetencyLevel, CourseCompetencyLevel>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<ICourseCompetencyLevel> ICourse.CourseCompetencyLevels
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseCompetencyLevels)
                    if (item.Course == null)
                        item.Course = this;
                // -------------------------------------------------------------

                return _courseCompetencyLevelsCovariant; 
            }
            set 
            { 
                CourseCompetencyLevels = new List<CourseCompetencyLevel>(value.Cast<CourseCompetencyLevel>()); 
            }
        }


        private IList<CourseIdentificationCode> _courseIdentificationCodes;
        private IList<ICourseIdentificationCode> _courseIdentificationCodesCovariant;
        [RequiredCollection]
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<CourseIdentificationCode> CourseIdentificationCodes
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseIdentificationCodes)
                    if (item.Course == null)
                        item.Course = this;
                // -------------------------------------------------------------

                return _courseIdentificationCodes;
            }
            set 
            { 
                _courseIdentificationCodes = value;
                _courseIdentificationCodesCovariant = new CovariantIListAdapter<ICourseIdentificationCode, CourseIdentificationCode>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<ICourseIdentificationCode> ICourse.CourseIdentificationCodes
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseIdentificationCodes)
                    if (item.Course == null)
                        item.Course = this;
                // -------------------------------------------------------------

                return _courseIdentificationCodesCovariant; 
            }
            set 
            { 
                CourseIdentificationCodes = new List<CourseIdentificationCode>(value.Cast<CourseIdentificationCode>()); 
            }
        }


        private IList<CourseLearningObjective> _courseLearningObjectives;
        private IList<ICourseLearningObjective> _courseLearningObjectivesCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<CourseLearningObjective> CourseLearningObjectives
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseLearningObjectives)
                    if (item.Course == null)
                        item.Course = this;
                // -------------------------------------------------------------

                return _courseLearningObjectives;
            }
            set 
            { 
                _courseLearningObjectives = value;
                _courseLearningObjectivesCovariant = new CovariantIListAdapter<ICourseLearningObjective, CourseLearningObjective>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<ICourseLearningObjective> ICourse.CourseLearningObjectives
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseLearningObjectives)
                    if (item.Course == null)
                        item.Course = this;
                // -------------------------------------------------------------

                return _courseLearningObjectivesCovariant; 
            }
            set 
            { 
                CourseLearningObjectives = new List<CourseLearningObjective>(value.Cast<CourseLearningObjective>()); 
            }
        }


        private IList<CourseLearningStandard> _courseLearningStandards;
        private IList<ICourseLearningStandard> _courseLearningStandardsCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<CourseLearningStandard> CourseLearningStandards
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseLearningStandards)
                    if (item.Course == null)
                        item.Course = this;
                // -------------------------------------------------------------

                return _courseLearningStandards;
            }
            set 
            { 
                _courseLearningStandards = value;
                _courseLearningStandardsCovariant = new CovariantIListAdapter<ICourseLearningStandard, CourseLearningStandard>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<ICourseLearningStandard> ICourse.CourseLearningStandards
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseLearningStandards)
                    if (item.Course == null)
                        item.Course = this;
                // -------------------------------------------------------------

                return _courseLearningStandardsCovariant; 
            }
            set 
            { 
                CourseLearningStandards = new List<CourseLearningStandard>(value.Cast<CourseLearningStandard>()); 
            }
        }


        private IList<CourseLevelCharacteristic> _courseLevelCharacteristics;
        private IList<ICourseLevelCharacteristic> _courseLevelCharacteristicsCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<CourseLevelCharacteristic> CourseLevelCharacteristics
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseLevelCharacteristics)
                    if (item.Course == null)
                        item.Course = this;
                // -------------------------------------------------------------

                return _courseLevelCharacteristics;
            }
            set 
            { 
                _courseLevelCharacteristics = value;
                _courseLevelCharacteristicsCovariant = new CovariantIListAdapter<ICourseLevelCharacteristic, CourseLevelCharacteristic>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<ICourseLevelCharacteristic> ICourse.CourseLevelCharacteristics
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseLevelCharacteristics)
                    if (item.Course == null)
                        item.Course = this;
                // -------------------------------------------------------------

                return _courseLevelCharacteristicsCovariant; 
            }
            set 
            { 
                CourseLevelCharacteristics = new List<CourseLevelCharacteristic>(value.Cast<CourseLevelCharacteristic>()); 
            }
        }


        private IList<CourseOfferedGradeLevel> _courseOfferedGradeLevels;
        private IList<ICourseOfferedGradeLevel> _courseOfferedGradeLevelsCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<CourseOfferedGradeLevel> CourseOfferedGradeLevels
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseOfferedGradeLevels)
                    if (item.Course == null)
                        item.Course = this;
                // -------------------------------------------------------------

                return _courseOfferedGradeLevels;
            }
            set 
            { 
                _courseOfferedGradeLevels = value;
                _courseOfferedGradeLevelsCovariant = new CovariantIListAdapter<ICourseOfferedGradeLevel, CourseOfferedGradeLevel>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<ICourseOfferedGradeLevel> ICourse.CourseOfferedGradeLevels
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseOfferedGradeLevels)
                    if (item.Course == null)
                        item.Course = this;
                // -------------------------------------------------------------

                return _courseOfferedGradeLevelsCovariant; 
            }
            set 
            { 
                CourseOfferedGradeLevels = new List<CourseOfferedGradeLevel>(value.Cast<CourseOfferedGradeLevel>()); 
            }
        }

        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
                { "CareerPathwayType", new LookupColumnDetails { PropertyName = "CareerPathwayTypeId", LookupTypeName = "CareerPathwayType"} },
                { "CourseDefinedByType", new LookupColumnDetails { PropertyName = "CourseDefinedByTypeId", LookupTypeName = "CourseDefinedByType"} },
                { "CourseGPAApplicabilityType", new LookupColumnDetails { PropertyName = "CourseGPAApplicabilityTypeId", LookupTypeName = "CourseGPAApplicabilityType"} },
                { "MaximumAvailableCreditType", new LookupColumnDetails { PropertyName = "MaximumAvailableCreditTypeId", LookupTypeName = "MaximumAvailableCreditType"} },
                { "MinimumAvailableCreditType", new LookupColumnDetails { PropertyName = "MinimumAvailableCreditTypeId", LookupTypeName = "MinimumAvailableCreditType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CourseCode", CourseCode);
            keyValues.Add("EducationOrganizationId", EducationOrganizationId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourse>
        {
            return this.SynchronizeTo((ICourse)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourse) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAcademicSubjectDescriptorSupported = true;
        bool ICourseSynchronizationSourceSupport.IsAcademicSubjectDescriptorSupported 
        { 
            get { return _isAcademicSubjectDescriptorSupported; } 
            set { _isAcademicSubjectDescriptorSupported = value; }
        }

        private bool _isCareerPathwayTypeSupported = true;
        bool ICourseSynchronizationSourceSupport.IsCareerPathwayTypeSupported 
        { 
            get { return _isCareerPathwayTypeSupported; } 
            set { _isCareerPathwayTypeSupported = value; }
        }

        private bool _isCourseCompetencyLevelsSupported = true;
        bool ICourseSynchronizationSourceSupport.IsCourseCompetencyLevelsSupported 
        { 
            get { return _isCourseCompetencyLevelsSupported; } 
            set { _isCourseCompetencyLevelsSupported = value; }
        }

        private bool _isCourseDefinedByTypeSupported = true;
        bool ICourseSynchronizationSourceSupport.IsCourseDefinedByTypeSupported 
        { 
            get { return _isCourseDefinedByTypeSupported; } 
            set { _isCourseDefinedByTypeSupported = value; }
        }

        private bool _isCourseDescriptionSupported = true;
        bool ICourseSynchronizationSourceSupport.IsCourseDescriptionSupported 
        { 
            get { return _isCourseDescriptionSupported; } 
            set { _isCourseDescriptionSupported = value; }
        }

        private bool _isCourseGPAApplicabilityTypeSupported = true;
        bool ICourseSynchronizationSourceSupport.IsCourseGPAApplicabilityTypeSupported 
        { 
            get { return _isCourseGPAApplicabilityTypeSupported; } 
            set { _isCourseGPAApplicabilityTypeSupported = value; }
        }

        private bool _isCourseIdentificationCodesSupported = true;
        bool ICourseSynchronizationSourceSupport.IsCourseIdentificationCodesSupported 
        { 
            get { return _isCourseIdentificationCodesSupported; } 
            set { _isCourseIdentificationCodesSupported = value; }
        }

        private bool _isCourseLearningObjectivesSupported = true;
        bool ICourseSynchronizationSourceSupport.IsCourseLearningObjectivesSupported 
        { 
            get { return _isCourseLearningObjectivesSupported; } 
            set { _isCourseLearningObjectivesSupported = value; }
        }

        private bool _isCourseLearningStandardsSupported = true;
        bool ICourseSynchronizationSourceSupport.IsCourseLearningStandardsSupported 
        { 
            get { return _isCourseLearningStandardsSupported; } 
            set { _isCourseLearningStandardsSupported = value; }
        }

        private bool _isCourseLevelCharacteristicsSupported = true;
        bool ICourseSynchronizationSourceSupport.IsCourseLevelCharacteristicsSupported 
        { 
            get { return _isCourseLevelCharacteristicsSupported; } 
            set { _isCourseLevelCharacteristicsSupported = value; }
        }

        private bool _isCourseOfferedGradeLevelsSupported = true;
        bool ICourseSynchronizationSourceSupport.IsCourseOfferedGradeLevelsSupported 
        { 
            get { return _isCourseOfferedGradeLevelsSupported; } 
            set { _isCourseOfferedGradeLevelsSupported = value; }
        }

        private bool _isCourseTitleSupported = true;
        bool ICourseSynchronizationSourceSupport.IsCourseTitleSupported 
        { 
            get { return _isCourseTitleSupported; } 
            set { _isCourseTitleSupported = value; }
        }

        private bool _isDateCourseAdoptedSupported = true;
        bool ICourseSynchronizationSourceSupport.IsDateCourseAdoptedSupported 
        { 
            get { return _isDateCourseAdoptedSupported; } 
            set { _isDateCourseAdoptedSupported = value; }
        }

        private bool _isHighSchoolCourseRequirementSupported = true;
        bool ICourseSynchronizationSourceSupport.IsHighSchoolCourseRequirementSupported 
        { 
            get { return _isHighSchoolCourseRequirementSupported; } 
            set { _isHighSchoolCourseRequirementSupported = value; }
        }

        private bool _isMaximumAvailableCreditConversionSupported = true;
        bool ICourseSynchronizationSourceSupport.IsMaximumAvailableCreditConversionSupported 
        { 
            get { return _isMaximumAvailableCreditConversionSupported; } 
            set { _isMaximumAvailableCreditConversionSupported = value; }
        }

        private bool _isMaximumAvailableCreditsSupported = true;
        bool ICourseSynchronizationSourceSupport.IsMaximumAvailableCreditsSupported 
        { 
            get { return _isMaximumAvailableCreditsSupported; } 
            set { _isMaximumAvailableCreditsSupported = value; }
        }

        private bool _isMaximumAvailableCreditTypeSupported = true;
        bool ICourseSynchronizationSourceSupport.IsMaximumAvailableCreditTypeSupported 
        { 
            get { return _isMaximumAvailableCreditTypeSupported; } 
            set { _isMaximumAvailableCreditTypeSupported = value; }
        }

        private bool _isMinimumAvailableCreditConversionSupported = true;
        bool ICourseSynchronizationSourceSupport.IsMinimumAvailableCreditConversionSupported 
        { 
            get { return _isMinimumAvailableCreditConversionSupported; } 
            set { _isMinimumAvailableCreditConversionSupported = value; }
        }

        private bool _isMinimumAvailableCreditsSupported = true;
        bool ICourseSynchronizationSourceSupport.IsMinimumAvailableCreditsSupported 
        { 
            get { return _isMinimumAvailableCreditsSupported; } 
            set { _isMinimumAvailableCreditsSupported = value; }
        }

        private bool _isMinimumAvailableCreditTypeSupported = true;
        bool ICourseSynchronizationSourceSupport.IsMinimumAvailableCreditTypeSupported 
        { 
            get { return _isMinimumAvailableCreditTypeSupported; } 
            set { _isMinimumAvailableCreditTypeSupported = value; }
        }

        private bool _isNumberOfPartsSupported = true;
        bool ICourseSynchronizationSourceSupport.IsNumberOfPartsSupported 
        { 
            get { return _isNumberOfPartsSupported; } 
            set { _isNumberOfPartsSupported = value; }
        }

        private bool _isTimeRequiredForCompletionSupported = true;
        bool ICourseSynchronizationSourceSupport.IsTimeRequiredForCompletionSupported 
        { 
            get { return _isTimeRequiredForCompletionSupported; } 
            set { _isTimeRequiredForCompletionSupported = value; }
        }

        private Func<ICourseCompetencyLevel, bool> _isCourseCompetencyLevelIncluded;
        Func<ICourseCompetencyLevel, bool> ICourseSynchronizationSourceSupport.IsCourseCompetencyLevelIncluded
        { 
            get { return _isCourseCompetencyLevelIncluded; } 
            set { _isCourseCompetencyLevelIncluded = value; }
        }

        private Func<ICourseIdentificationCode, bool> _isCourseIdentificationCodeIncluded;
        Func<ICourseIdentificationCode, bool> ICourseSynchronizationSourceSupport.IsCourseIdentificationCodeIncluded
        { 
            get { return _isCourseIdentificationCodeIncluded; } 
            set { _isCourseIdentificationCodeIncluded = value; }
        }

        private Func<ICourseLearningObjective, bool> _isCourseLearningObjectiveIncluded;
        Func<ICourseLearningObjective, bool> ICourseSynchronizationSourceSupport.IsCourseLearningObjectiveIncluded
        { 
            get { return _isCourseLearningObjectiveIncluded; } 
            set { _isCourseLearningObjectiveIncluded = value; }
        }

        private Func<ICourseLearningStandard, bool> _isCourseLearningStandardIncluded;
        Func<ICourseLearningStandard, bool> ICourseSynchronizationSourceSupport.IsCourseLearningStandardIncluded
        { 
            get { return _isCourseLearningStandardIncluded; } 
            set { _isCourseLearningStandardIncluded = value; }
        }

        private Func<ICourseLevelCharacteristic, bool> _isCourseLevelCharacteristicIncluded;
        Func<ICourseLevelCharacteristic, bool> ICourseSynchronizationSourceSupport.IsCourseLevelCharacteristicIncluded
        { 
            get { return _isCourseLevelCharacteristicIncluded; } 
            set { _isCourseLevelCharacteristicIncluded = value; }
        }

        private Func<ICourseOfferedGradeLevel, bool> _isCourseOfferedGradeLevelIncluded;
        Func<ICourseOfferedGradeLevel, bool> ICourseSynchronizationSourceSupport.IsCourseOfferedGradeLevelIncluded
        { 
            get { return _isCourseOfferedGradeLevelIncluded; } 
            set { _isCourseOfferedGradeLevelIncluded = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseIdentificationCode table of the Course aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseIdentificationCode : EntityWithCompositeKey, IChildEntity, 
        ICourseIdentificationCode, ICourseIdentificationCodeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseIdentificationCodeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual Course Course { get; set; }

        ICourse ICourseIdentificationCode.Course
        {
            get { return Course; }
            set { Course = (Course) value; }
        }

        int ICourseIdentificationCodeRecord.EducationOrganizationId
        {
            get { return ((ICourseRecord) Course).EducationOrganizationId; }
            set { ((ICourseRecord) Course).EducationOrganizationId = value; }
        }


        string ICourseIdentificationCodeRecord.CourseCode
        {
            get { return ((ICourseRecord) Course).CourseCode; }
            set { ((ICourseRecord) Course).CourseCode = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int CourseIdentificationSystemDescriptorId 
        {
            get
            {
                if (_courseIdentificationSystemDescriptorId == default(int))
                    _courseIdentificationSystemDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("CourseIdentificationSystemDescriptor", _courseIdentificationSystemDescriptor);

                return _courseIdentificationSystemDescriptorId;
            } 
            set
            {
                _courseIdentificationSystemDescriptorId = value;
                _courseIdentificationSystemDescriptor = null;
            }
        }

        private int _courseIdentificationSystemDescriptorId;
        private string _courseIdentificationSystemDescriptor;

        public virtual string CourseIdentificationSystemDescriptor
        {
            get
            {
                if (_courseIdentificationSystemDescriptor == null)
                    _courseIdentificationSystemDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("CourseIdentificationSystemDescriptor", _courseIdentificationSystemDescriptorId);
                    
                return _courseIdentificationSystemDescriptor;
            }
            set
            {
                _courseIdentificationSystemDescriptor = value;
                _courseIdentificationSystemDescriptorId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [StringLength(60), NoDangerousText]
        public virtual string AssigningOrganizationIdentificationCode  { get; set; }
        [RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string IdentificationCode  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "CourseIdentificationSystemDescriptor", new LookupColumnDetails { PropertyName = "CourseIdentificationSystemDescriptorId", LookupTypeName = "CourseIdentificationSystemDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (Course as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("CourseIdentificationSystemDescriptorId", CourseIdentificationSystemDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseIdentificationCode>
        {
            return this.SynchronizeTo((ICourseIdentificationCode)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseIdentificationCode) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            Course = (Course) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAssigningOrganizationIdentificationCodeSupported = true;
        bool ICourseIdentificationCodeSynchronizationSourceSupport.IsAssigningOrganizationIdentificationCodeSupported 
        { 
            get { return _isAssigningOrganizationIdentificationCodeSupported; } 
            set { _isAssigningOrganizationIdentificationCodeSupported = value; }
        }

        private bool _isIdentificationCodeSupported = true;
        bool ICourseIdentificationCodeSynchronizationSourceSupport.IsIdentificationCodeSupported 
        { 
            get { return _isIdentificationCodeSupported; } 
            set { _isIdentificationCodeSupported = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseOfferedGradeLevel table of the Course aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseOfferedGradeLevel : EntityWithCompositeKey, IChildEntity, 
        ICourseOfferedGradeLevel, ICourseOfferedGradeLevelRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseOfferedGradeLevelSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual Course Course { get; set; }

        ICourse ICourseOfferedGradeLevel.Course
        {
            get { return Course; }
            set { Course = (Course) value; }
        }

        int ICourseOfferedGradeLevelRecord.EducationOrganizationId
        {
            get { return ((ICourseRecord) Course).EducationOrganizationId; }
            set { ((ICourseRecord) Course).EducationOrganizationId = value; }
        }


        string ICourseOfferedGradeLevelRecord.CourseCode
        {
            get { return ((ICourseRecord) Course).CourseCode; }
            set { ((ICourseRecord) Course).CourseCode = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int GradeLevelDescriptorId 
        {
            get
            {
                if (_gradeLevelDescriptorId == default(int))
                    _gradeLevelDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("GradeLevelDescriptor", _gradeLevelDescriptor);

                return _gradeLevelDescriptorId;
            } 
            set
            {
                _gradeLevelDescriptorId = value;
                _gradeLevelDescriptor = null;
            }
        }

        private int _gradeLevelDescriptorId;
        private string _gradeLevelDescriptor;

        public virtual string GradeLevelDescriptor
        {
            get
            {
                if (_gradeLevelDescriptor == null)
                    _gradeLevelDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("GradeLevelDescriptor", _gradeLevelDescriptorId);
                    
                return _gradeLevelDescriptor;
            }
            set
            {
                _gradeLevelDescriptor = value;
                _gradeLevelDescriptorId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "GradeLevelDescriptor", new LookupColumnDetails { PropertyName = "GradeLevelDescriptorId", LookupTypeName = "GradeLevelDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (Course as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("GradeLevelDescriptorId", GradeLevelDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseOfferedGradeLevel>
        {
            return this.SynchronizeTo((ICourseOfferedGradeLevel)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseOfferedGradeLevel) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            Course = (Course) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseLearningObjective table of the Course aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseLearningObjective : EntityWithCompositeKey, IChildEntity, 
        ICourseLearningObjective, ICourseLearningObjectiveRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseLearningObjectiveSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual Course Course { get; set; }

        ICourse ICourseLearningObjective.Course
        {
            get { return Course; }
            set { Course = (Course) value; }
        }

        int ICourseLearningObjectiveRecord.EducationOrganizationId
        {
            get { return ((ICourseRecord) Course).EducationOrganizationId; }
            set { ((ICourseRecord) Course).EducationOrganizationId = value; }
        }


        string ICourseLearningObjectiveRecord.CourseCode
        {
            get { return ((ICourseRecord) Course).CourseCode; }
            set { ((ICourseRecord) Course).CourseCode = value; }
        }


        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string Objective  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int AcademicSubjectDescriptorId 
        {
            get
            {
                if (_academicSubjectDescriptorId == default(int))
                    _academicSubjectDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("AcademicSubjectDescriptor", _academicSubjectDescriptor);

                return _academicSubjectDescriptorId;
            } 
            set
            {
                _academicSubjectDescriptorId = value;
                _academicSubjectDescriptor = null;
            }
        }

        private int _academicSubjectDescriptorId;
        private string _academicSubjectDescriptor;

        public virtual string AcademicSubjectDescriptor
        {
            get
            {
                if (_academicSubjectDescriptor == null)
                    _academicSubjectDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("AcademicSubjectDescriptor", _academicSubjectDescriptorId);
                    
                return _academicSubjectDescriptor;
            }
            set
            {
                _academicSubjectDescriptor = value;
                _academicSubjectDescriptorId = default(int);
            }
        }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int ObjectiveGradeLevelDescriptorId 
        {
            get
            {
                if (_objectiveGradeLevelDescriptorId == default(int))
                    _objectiveGradeLevelDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("GradeLevelDescriptor", _objectiveGradeLevelDescriptor);

                return _objectiveGradeLevelDescriptorId;
            } 
            set
            {
                _objectiveGradeLevelDescriptorId = value;
                _objectiveGradeLevelDescriptor = null;
            }
        }

        private int _objectiveGradeLevelDescriptorId;
        private string _objectiveGradeLevelDescriptor;

        public virtual string ObjectiveGradeLevelDescriptor
        {
            get
            {
                if (_objectiveGradeLevelDescriptor == null)
                    _objectiveGradeLevelDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("GradeLevelDescriptor", _objectiveGradeLevelDescriptorId);
                    
                return _objectiveGradeLevelDescriptor;
            }
            set
            {
                _objectiveGradeLevelDescriptor = value;
                _objectiveGradeLevelDescriptorId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
                { "ObjectiveGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "ObjectiveGradeLevelDescriptorId", LookupTypeName = "ObjectiveGradeLevelDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (Course as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("AcademicSubjectDescriptorId", AcademicSubjectDescriptorId);
            keyValues.Add("Objective", Objective);
            keyValues.Add("ObjectiveGradeLevelDescriptorId", ObjectiveGradeLevelDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseLearningObjective>
        {
            return this.SynchronizeTo((ICourseLearningObjective)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseLearningObjective) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            Course = (Course) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseLearningStandard table of the Course aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseLearningStandard : EntityWithCompositeKey, IChildEntity, 
        ICourseLearningStandard, ICourseLearningStandardRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseLearningStandardSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual Course Course { get; set; }

        ICourse ICourseLearningStandard.Course
        {
            get { return Course; }
            set { Course = (Course) value; }
        }

        int ICourseLearningStandardRecord.EducationOrganizationId
        {
            get { return ((ICourseRecord) Course).EducationOrganizationId; }
            set { ((ICourseRecord) Course).EducationOrganizationId = value; }
        }


        string ICourseLearningStandardRecord.CourseCode
        {
            get { return ((ICourseRecord) Course).CourseCode; }
            set { ((ICourseRecord) Course).CourseCode = value; }
        }


        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string LearningStandardId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (Course as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("LearningStandardId", LearningStandardId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseLearningStandard>
        {
            return this.SynchronizeTo((ICourseLearningStandard)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseLearningStandard) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            Course = (Course) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseLevelCharacteristic table of the Course aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseLevelCharacteristic : EntityWithCompositeKey, IChildEntity, 
        ICourseLevelCharacteristic, ICourseLevelCharacteristicRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseLevelCharacteristicSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual Course Course { get; set; }

        ICourse ICourseLevelCharacteristic.Course
        {
            get { return Course; }
            set { Course = (Course) value; }
        }

        int ICourseLevelCharacteristicRecord.EducationOrganizationId
        {
            get { return ((ICourseRecord) Course).EducationOrganizationId; }
            set { ((ICourseRecord) Course).EducationOrganizationId = value; }
        }


        string ICourseLevelCharacteristicRecord.CourseCode
        {
            get { return ((ICourseRecord) Course).CourseCode; }
            set { ((ICourseRecord) Course).CourseCode = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int CourseLevelCharacteristicTypeId 
        {
            get
            {
                if (_courseLevelCharacteristicTypeId == default(int))
                    _courseLevelCharacteristicTypeId = TypesAndDescriptorsCache.GetCache().GetId("CourseLevelCharacteristicType", _courseLevelCharacteristicType);

                return _courseLevelCharacteristicTypeId;
            } 
            set
            {
                _courseLevelCharacteristicTypeId = value;
                _courseLevelCharacteristicType = null;
            }
        }

        private int _courseLevelCharacteristicTypeId;
        private string _courseLevelCharacteristicType;

        public virtual string CourseLevelCharacteristicType
        {
            get
            {
                if (_courseLevelCharacteristicType == null)
                    _courseLevelCharacteristicType = TypesAndDescriptorsCache.GetCache().GetValue("CourseLevelCharacteristicType", _courseLevelCharacteristicTypeId);
                    
                return _courseLevelCharacteristicType;
            }
            set
            {
                _courseLevelCharacteristicType = value;
                _courseLevelCharacteristicTypeId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "CourseLevelCharacteristicType", new LookupColumnDetails { PropertyName = "CourseLevelCharacteristicTypeId", LookupTypeName = "CourseLevelCharacteristicType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (Course as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("CourseLevelCharacteristicTypeId", CourseLevelCharacteristicTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseLevelCharacteristic>
        {
            return this.SynchronizeTo((ICourseLevelCharacteristic)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseLevelCharacteristic) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            Course = (Course) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseCompetencyLevel table of the Course aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseCompetencyLevel : EntityWithCompositeKey, IChildEntity, 
        ICourseCompetencyLevel, ICourseCompetencyLevelRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseCompetencyLevelSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual Course Course { get; set; }

        ICourse ICourseCompetencyLevel.Course
        {
            get { return Course; }
            set { Course = (Course) value; }
        }

        int ICourseCompetencyLevelRecord.EducationOrganizationId
        {
            get { return ((ICourseRecord) Course).EducationOrganizationId; }
            set { ((ICourseRecord) Course).EducationOrganizationId = value; }
        }


        string ICourseCompetencyLevelRecord.CourseCode
        {
            get { return ((ICourseRecord) Course).CourseCode; }
            set { ((ICourseRecord) Course).CourseCode = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int CompetencyLevelDescriptorId 
        {
            get
            {
                if (_competencyLevelDescriptorId == default(int))
                    _competencyLevelDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("CompetencyLevelDescriptor", _competencyLevelDescriptor);

                return _competencyLevelDescriptorId;
            } 
            set
            {
                _competencyLevelDescriptorId = value;
                _competencyLevelDescriptor = null;
            }
        }

        private int _competencyLevelDescriptorId;
        private string _competencyLevelDescriptor;

        public virtual string CompetencyLevelDescriptor
        {
            get
            {
                if (_competencyLevelDescriptor == null)
                    _competencyLevelDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("CompetencyLevelDescriptor", _competencyLevelDescriptorId);
                    
                return _competencyLevelDescriptor;
            }
            set
            {
                _competencyLevelDescriptor = value;
                _competencyLevelDescriptorId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "CompetencyLevelDescriptor", new LookupColumnDetails { PropertyName = "CompetencyLevelDescriptorId", LookupTypeName = "CompetencyLevelDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (Course as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("CompetencyLevelDescriptorId", CompetencyLevelDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseCompetencyLevel>
        {
            return this.SynchronizeTo((ICourseCompetencyLevel)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseCompetencyLevel) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            Course = (Course) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 
}
// Aggregate: CourseAttemptResultType

namespace EdFi.Ods.Entities.NHibernate.CourseAttemptResultTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseAttemptResultType table of the CourseAttemptResultType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseAttemptResultType : AggregateRootWithCompositeKey, 
        ICourseAttemptResultType, ICourseAttemptResultTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseAttemptResultTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CourseAttemptResultTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CourseAttemptResultTypeId", CourseAttemptResultTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseAttemptResultType>
        {
            return this.SynchronizeTo((ICourseAttemptResultType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseAttemptResultType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICourseAttemptResultTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICourseAttemptResultTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICourseAttemptResultTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CourseDefinedByType

namespace EdFi.Ods.Entities.NHibernate.CourseDefinedByTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseDefinedByType table of the CourseDefinedByType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseDefinedByType : AggregateRootWithCompositeKey, 
        ICourseDefinedByType, ICourseDefinedByTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseDefinedByTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CourseDefinedByTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CourseDefinedByTypeId", CourseDefinedByTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseDefinedByType>
        {
            return this.SynchronizeTo((ICourseDefinedByType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseDefinedByType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICourseDefinedByTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICourseDefinedByTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICourseDefinedByTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CourseGPAApplicabilityType

namespace EdFi.Ods.Entities.NHibernate.CourseGPAApplicabilityTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseGPAApplicabilityType table of the CourseGPAApplicabilityType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseGPAApplicabilityType : AggregateRootWithCompositeKey, 
        ICourseGPAApplicabilityType, ICourseGPAApplicabilityTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseGPAApplicabilityTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CourseGPAApplicabilityTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CourseGPAApplicabilityTypeId", CourseGPAApplicabilityTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseGPAApplicabilityType>
        {
            return this.SynchronizeTo((ICourseGPAApplicabilityType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseGPAApplicabilityType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICourseGPAApplicabilityTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICourseGPAApplicabilityTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICourseGPAApplicabilityTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CourseIdentificationSystemDescriptor

namespace EdFi.Ods.Entities.NHibernate.CourseIdentificationSystemDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseIdentificationSystemDescriptor table of the CourseIdentificationSystemDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseIdentificationSystemDescriptor : DescriptorAggregate.Descriptor, 
        ICourseIdentificationSystemDescriptor, ICourseIdentificationSystemDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseIdentificationSystemDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CourseIdentificationSystemDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        public virtual int? CourseIdentificationSystemTypeId 
        {
            get
            {
                if (_courseIdentificationSystemTypeId == default(int?))
                    _courseIdentificationSystemTypeId = string.IsNullOrWhiteSpace(_courseIdentificationSystemType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("CourseIdentificationSystemType", _courseIdentificationSystemType);

                return _courseIdentificationSystemTypeId;
            } 
            set
            {
                _courseIdentificationSystemTypeId = value;
                _courseIdentificationSystemType = null;
            }
        }

        private int? _courseIdentificationSystemTypeId;
        private string _courseIdentificationSystemType;

        public virtual string CourseIdentificationSystemType
        {
            get
            {
                if (_courseIdentificationSystemType == null)
                    _courseIdentificationSystemType = _courseIdentificationSystemTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("CourseIdentificationSystemType", _courseIdentificationSystemTypeId.Value);
                    
                return _courseIdentificationSystemType;
            }
            set
            {
                _courseIdentificationSystemType = value;
                _courseIdentificationSystemTypeId = default(int?);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "CourseIdentificationSystemType", new LookupColumnDetails { PropertyName = "CourseIdentificationSystemTypeId", LookupTypeName = "CourseIdentificationSystemType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CourseIdentificationSystemDescriptorId", CourseIdentificationSystemDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseIdentificationSystemDescriptor>
        {
            return this.SynchronizeTo((ICourseIdentificationSystemDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseIdentificationSystemDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICourseIdentificationSystemDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isCourseIdentificationSystemTypeSupported = true;
        bool ICourseIdentificationSystemDescriptorSynchronizationSourceSupport.IsCourseIdentificationSystemTypeSupported 
        { 
            get { return _isCourseIdentificationSystemTypeSupported; } 
            set { _isCourseIdentificationSystemTypeSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICourseIdentificationSystemDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool ICourseIdentificationSystemDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool ICourseIdentificationSystemDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool ICourseIdentificationSystemDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool ICourseIdentificationSystemDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICourseIdentificationSystemDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CourseIdentificationSystemType

namespace EdFi.Ods.Entities.NHibernate.CourseIdentificationSystemTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseIdentificationSystemType table of the CourseIdentificationSystemType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseIdentificationSystemType : AggregateRootWithCompositeKey, 
        ICourseIdentificationSystemType, ICourseIdentificationSystemTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseIdentificationSystemTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CourseIdentificationSystemTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CourseIdentificationSystemTypeId", CourseIdentificationSystemTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseIdentificationSystemType>
        {
            return this.SynchronizeTo((ICourseIdentificationSystemType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseIdentificationSystemType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICourseIdentificationSystemTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICourseIdentificationSystemTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICourseIdentificationSystemTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CourseLevelCharacteristicType

namespace EdFi.Ods.Entities.NHibernate.CourseLevelCharacteristicTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseLevelCharacteristicType table of the CourseLevelCharacteristicType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseLevelCharacteristicType : AggregateRootWithCompositeKey, 
        ICourseLevelCharacteristicType, ICourseLevelCharacteristicTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseLevelCharacteristicTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CourseLevelCharacteristicTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CourseLevelCharacteristicTypeId", CourseLevelCharacteristicTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseLevelCharacteristicType>
        {
            return this.SynchronizeTo((ICourseLevelCharacteristicType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseLevelCharacteristicType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICourseLevelCharacteristicTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICourseLevelCharacteristicTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICourseLevelCharacteristicTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CourseOffering

namespace EdFi.Ods.Entities.NHibernate.CourseOfferingAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseOffering table of the CourseOffering aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseOffering : AggregateRootWithCompositeKey, 
        ICourseOffering, ICourseOfferingRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseOfferingSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        public CourseOffering()
        {
            CourseOfferingCurriculumUseds = new List<CourseOfferingCurriculumUsed>();

        }
// restore warnings for inheritance from classes marked Obsolete
#pragma warning restore 612, 618 
               
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string LocalCourseCode  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int SchoolId  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual short SchoolYear  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int TermDescriptorId 
        {
            get
            {
                if (_termDescriptorId == default(int))
                    _termDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("TermDescriptor", _termDescriptor);

                return _termDescriptorId;
            } 
            set
            {
                _termDescriptorId = value;
                _termDescriptor = null;
            }
        }

        private int _termDescriptorId;
        private string _termDescriptor;

        public virtual string TermDescriptor
        {
            get
            {
                if (_termDescriptor == null)
                    _termDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("TermDescriptor", _termDescriptorId);
                    
                return _termDescriptor;
            }
            set
            {
                _termDescriptor = value;
                _termDescriptorId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string CourseCode  { get; set; }
        [RequiredWithNonDefault]
        public virtual int EducationOrganizationId  { get; set; }
        public virtual int? InstructionalTimePlanned  { get; set; }
        [StringLength(60), NoDangerousText]
        public virtual string LocalCourseTitle  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------

        private IList<CourseOfferingCurriculumUsed> _courseOfferingCurriculumUseds;
        private IList<ICourseOfferingCurriculumUsed> _courseOfferingCurriculumUsedsCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<CourseOfferingCurriculumUsed> CourseOfferingCurriculumUseds
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseOfferingCurriculumUseds)
                    if (item.CourseOffering == null)
                        item.CourseOffering = this;
                // -------------------------------------------------------------

                return _courseOfferingCurriculumUseds;
            }
            set 
            { 
                _courseOfferingCurriculumUseds = value;
                _courseOfferingCurriculumUsedsCovariant = new CovariantIListAdapter<ICourseOfferingCurriculumUsed, CourseOfferingCurriculumUsed>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<ICourseOfferingCurriculumUsed> ICourseOffering.CourseOfferingCurriculumUseds
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseOfferingCurriculumUseds)
                    if (item.CourseOffering == null)
                        item.CourseOffering = this;
                // -------------------------------------------------------------

                return _courseOfferingCurriculumUsedsCovariant; 
            }
            set 
            { 
                CourseOfferingCurriculumUseds = new List<CourseOfferingCurriculumUsed>(value.Cast<CourseOfferingCurriculumUsed>()); 
            }
        }

        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "TermDescriptor", new LookupColumnDetails { PropertyName = "TermDescriptorId", LookupTypeName = "TermDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("LocalCourseCode", LocalCourseCode);
            keyValues.Add("SchoolId", SchoolId);
            keyValues.Add("SchoolYear", SchoolYear);
            keyValues.Add("TermDescriptorId", TermDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseOffering>
        {
            return this.SynchronizeTo((ICourseOffering)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseOffering) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCourseCodeSupported = true;
        bool ICourseOfferingSynchronizationSourceSupport.IsCourseCodeSupported 
        { 
            get { return _isCourseCodeSupported; } 
            set { _isCourseCodeSupported = value; }
        }

        private bool _isCourseOfferingCurriculumUsedsSupported = true;
        bool ICourseOfferingSynchronizationSourceSupport.IsCourseOfferingCurriculumUsedsSupported 
        { 
            get { return _isCourseOfferingCurriculumUsedsSupported; } 
            set { _isCourseOfferingCurriculumUsedsSupported = value; }
        }

        private bool _isEducationOrganizationIdSupported = true;
        bool ICourseOfferingSynchronizationSourceSupport.IsEducationOrganizationIdSupported 
        { 
            get { return _isEducationOrganizationIdSupported; } 
            set { _isEducationOrganizationIdSupported = value; }
        }

        private bool _isInstructionalTimePlannedSupported = true;
        bool ICourseOfferingSynchronizationSourceSupport.IsInstructionalTimePlannedSupported 
        { 
            get { return _isInstructionalTimePlannedSupported; } 
            set { _isInstructionalTimePlannedSupported = value; }
        }

        private bool _isLocalCourseTitleSupported = true;
        bool ICourseOfferingSynchronizationSourceSupport.IsLocalCourseTitleSupported 
        { 
            get { return _isLocalCourseTitleSupported; } 
            set { _isLocalCourseTitleSupported = value; }
        }

        private Func<ICourseOfferingCurriculumUsed, bool> _isCourseOfferingCurriculumUsedIncluded;
        Func<ICourseOfferingCurriculumUsed, bool> ICourseOfferingSynchronizationSourceSupport.IsCourseOfferingCurriculumUsedIncluded
        { 
            get { return _isCourseOfferingCurriculumUsedIncluded; } 
            set { _isCourseOfferingCurriculumUsedIncluded = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseOfferingCurriculumUsed table of the CourseOffering aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseOfferingCurriculumUsed : EntityWithCompositeKey, IChildEntity, 
        ICourseOfferingCurriculumUsed, ICourseOfferingCurriculumUsedRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseOfferingCurriculumUsedSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual CourseOffering CourseOffering { get; set; }

        ICourseOffering ICourseOfferingCurriculumUsed.CourseOffering
        {
            get { return CourseOffering; }
            set { CourseOffering = (CourseOffering) value; }
        }

        string ICourseOfferingCurriculumUsedRecord.LocalCourseCode
        {
            get { return ((ICourseOfferingRecord) CourseOffering).LocalCourseCode; }
            set { ((ICourseOfferingRecord) CourseOffering).LocalCourseCode = value; }
        }


        int ICourseOfferingCurriculumUsedRecord.SchoolId
        {
            get { return ((ICourseOfferingRecord) CourseOffering).SchoolId; }
            set { ((ICourseOfferingRecord) CourseOffering).SchoolId = value; }
        }


        short ICourseOfferingCurriculumUsedRecord.SchoolYear
        {
            get { return ((ICourseOfferingRecord) CourseOffering).SchoolYear; }
            set { ((ICourseOfferingRecord) CourseOffering).SchoolYear = value; }
        }


        int ICourseOfferingCurriculumUsedRecord.TermDescriptorId
        {
            get { return ((ICourseOfferingRecord) CourseOffering).TermDescriptorId; }
            set { ((ICourseOfferingRecord) CourseOffering).TermDescriptorId = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int CurriculumUsedTypeId 
        {
            get
            {
                if (_curriculumUsedTypeId == default(int))
                    _curriculumUsedTypeId = TypesAndDescriptorsCache.GetCache().GetId("CurriculumUsedType", _curriculumUsedType);

                return _curriculumUsedTypeId;
            } 
            set
            {
                _curriculumUsedTypeId = value;
                _curriculumUsedType = null;
            }
        }

        private int _curriculumUsedTypeId;
        private string _curriculumUsedType;

        public virtual string CurriculumUsedType
        {
            get
            {
                if (_curriculumUsedType == null)
                    _curriculumUsedType = TypesAndDescriptorsCache.GetCache().GetValue("CurriculumUsedType", _curriculumUsedTypeId);
                    
                return _curriculumUsedType;
            }
            set
            {
                _curriculumUsedType = value;
                _curriculumUsedTypeId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "CurriculumUsedType", new LookupColumnDetails { PropertyName = "CurriculumUsedTypeId", LookupTypeName = "CurriculumUsedType"} },
                { "TermDescriptor", new LookupColumnDetails { PropertyName = "TermDescriptorId", LookupTypeName = "TermDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (CourseOffering as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("CurriculumUsedTypeId", CurriculumUsedTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseOfferingCurriculumUsed>
        {
            return this.SynchronizeTo((ICourseOfferingCurriculumUsed)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseOfferingCurriculumUsed) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            CourseOffering = (CourseOffering) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        // -----------------------------------------
    } 
}
// Aggregate: CourseRepeatCodeType

namespace EdFi.Ods.Entities.NHibernate.CourseRepeatCodeTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseRepeatCodeType table of the CourseRepeatCodeType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseRepeatCodeType : AggregateRootWithCompositeKey, 
        ICourseRepeatCodeType, ICourseRepeatCodeTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseRepeatCodeTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CourseRepeatCodeTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CourseRepeatCodeTypeId", CourseRepeatCodeTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseRepeatCodeType>
        {
            return this.SynchronizeTo((ICourseRepeatCodeType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseRepeatCodeType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICourseRepeatCodeTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICourseRepeatCodeTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICourseRepeatCodeTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CourseTranscript

namespace EdFi.Ods.Entities.NHibernate.CourseTranscriptAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseTranscript table of the CourseTranscript aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseTranscript : AggregateRootWithCompositeKey, 
        ICourseTranscript, ICourseTranscriptRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseTranscriptSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        public CourseTranscript()
        {
            CourseTranscriptEarnedAdditionalCredits = new List<CourseTranscriptEarnedAdditionalCredits>();

        }
// restore warnings for inheritance from classes marked Obsolete
#pragma warning restore 612, 618 
               
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, RequiredWithNonDefault]
        public virtual int CourseAttemptResultTypeId 
        {
            get
            {
                if (_courseAttemptResultTypeId == default(int))
                    _courseAttemptResultTypeId = TypesAndDescriptorsCache.GetCache().GetId("CourseAttemptResultType", _courseAttemptResultType);

                return _courseAttemptResultTypeId;
            } 
            set
            {
                _courseAttemptResultTypeId = value;
                _courseAttemptResultType = null;
            }
        }

        private int _courseAttemptResultTypeId;
        private string _courseAttemptResultType;

        public virtual string CourseAttemptResultType
        {
            get
            {
                if (_courseAttemptResultType == null)
                    _courseAttemptResultType = TypesAndDescriptorsCache.GetCache().GetValue("CourseAttemptResultType", _courseAttemptResultTypeId);
                    
                return _courseAttemptResultType;
            }
            set
            {
                _courseAttemptResultType = value;
                _courseAttemptResultTypeId = default(int);
            }
        }
        [Display(Name="StudentUniqueId")]
        [DomainSignature, RequiredWithNonDefault]
        public virtual int StudentUSI 
        {
            get
            {
                if (_studentUSI == default(int))
                    _studentUSI = PersonUniqueIdToUsiCache.GetCache().GetUsi("Student", _studentUniqueId);

                return _studentUSI;
            } 
            set
            {
                _studentUSI = value;
            }
        }

        private int _studentUSI;
        private string _studentUniqueId;

        public virtual string StudentUniqueId
        {
            get
            {
                if (_studentUniqueId == null)
                    _studentUniqueId = PersonUniqueIdToUsiCache.GetCache().GetUniqueId("Student", _studentUSI);
                    
                return _studentUniqueId;
            }
            set
            {
                _studentUniqueId = value;
            }
        }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int EducationOrganizationId  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int CourseEducationOrganizationId  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual short SchoolYear  { get; set; }
        [DomainSignature, RequiredWithNonDefault]
        public virtual int TermDescriptorId 
        {
            get
            {
                if (_termDescriptorId == default(int))
                    _termDescriptorId = TypesAndDescriptorsCache.GetCache().GetId("TermDescriptor", _termDescriptor);

                return _termDescriptorId;
            } 
            set
            {
                _termDescriptorId = value;
                _termDescriptor = null;
            }
        }

        private int _termDescriptorId;
        private string _termDescriptor;

        public virtual string TermDescriptor
        {
            get
            {
                if (_termDescriptor == null)
                    _termDescriptor = TypesAndDescriptorsCache.GetCache().GetValue("TermDescriptor", _termDescriptorId);
                    
                return _termDescriptor;
            }
            set
            {
                _termDescriptor = value;
                _termDescriptorId = default(int);
            }
        }
        [DomainSignature, RequiredWithNonDefault, StringLength(60), NoDangerousText]
        public virtual string CourseCode  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [StringLength(60), NoDangerousText]
        public virtual string AlternativeCourseCode  { get; set; }
        [StringLength(60), NoDangerousText]
        public virtual string AlternativeCourseTitle  { get; set; }
        [Range(typeof(decimal), "-9999999.99", "9999999.99")]
        public virtual decimal? AttemptedCreditConversion  { get; set; }
        [Range(typeof(decimal), "-9999999.99", "9999999.99")]
        public virtual decimal? AttemptedCredits  { get; set; }
        public virtual int? AttemptedCreditTypeId 
        {
            get
            {
                if (_attemptedCreditTypeId == default(int?))
                    _attemptedCreditTypeId = string.IsNullOrWhiteSpace(_attemptedCreditType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("CreditType", _attemptedCreditType);

                return _attemptedCreditTypeId;
            } 
            set
            {
                _attemptedCreditTypeId = value;
                _attemptedCreditType = null;
            }
        }

        private int? _attemptedCreditTypeId;
        private string _attemptedCreditType;

        public virtual string AttemptedCreditType
        {
            get
            {
                if (_attemptedCreditType == null)
                    _attemptedCreditType = _attemptedCreditTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("CreditType", _attemptedCreditTypeId.Value);
                    
                return _attemptedCreditType;
            }
            set
            {
                _attemptedCreditType = value;
                _attemptedCreditTypeId = default(int?);
            }
        }
        public virtual int? CourseRepeatCodeTypeId 
        {
            get
            {
                if (_courseRepeatCodeTypeId == default(int?))
                    _courseRepeatCodeTypeId = string.IsNullOrWhiteSpace(_courseRepeatCodeType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("CourseRepeatCodeType", _courseRepeatCodeType);

                return _courseRepeatCodeTypeId;
            } 
            set
            {
                _courseRepeatCodeTypeId = value;
                _courseRepeatCodeType = null;
            }
        }

        private int? _courseRepeatCodeTypeId;
        private string _courseRepeatCodeType;

        public virtual string CourseRepeatCodeType
        {
            get
            {
                if (_courseRepeatCodeType == null)
                    _courseRepeatCodeType = _courseRepeatCodeTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("CourseRepeatCodeType", _courseRepeatCodeTypeId.Value);
                    
                return _courseRepeatCodeType;
            }
            set
            {
                _courseRepeatCodeType = value;
                _courseRepeatCodeTypeId = default(int?);
            }
        }
        [StringLength(60), NoDangerousText]
        public virtual string CourseTitle  { get; set; }
        [Range(typeof(decimal), "-9999999.99", "9999999.99")]
        public virtual decimal? EarnedCreditConversion  { get; set; }
        [Range(typeof(decimal), "-9999999.99", "9999999.99")]
        public virtual decimal EarnedCredits  { get; set; }
        public virtual int? EarnedCreditTypeId 
        {
            get
            {
                if (_earnedCreditTypeId == default(int?))
                    _earnedCreditTypeId = string.IsNullOrWhiteSpace(_earnedCreditType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("CreditType", _earnedCreditType);

                return _earnedCreditTypeId;
            } 
            set
            {
                _earnedCreditTypeId = value;
                _earnedCreditType = null;
            }
        }

        private int? _earnedCreditTypeId;
        private string _earnedCreditType;

        public virtual string EarnedCreditType
        {
            get
            {
                if (_earnedCreditType == null)
                    _earnedCreditType = _earnedCreditTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("CreditType", _earnedCreditTypeId.Value);
                    
                return _earnedCreditType;
            }
            set
            {
                _earnedCreditType = value;
                _earnedCreditTypeId = default(int?);
            }
        }
        [StringLength(20), NoDangerousText]
        public virtual string FinalLetterGradeEarned  { get; set; }
        [Range(typeof(decimal), "-9999999.99", "9999999.99")]
        public virtual decimal? FinalNumericGradeEarned  { get; set; }
        public virtual int? MethodCreditEarnedTypeId 
        {
            get
            {
                if (_methodCreditEarnedTypeId == default(int?))
                    _methodCreditEarnedTypeId = string.IsNullOrWhiteSpace(_methodCreditEarnedType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("MethodCreditEarnedType", _methodCreditEarnedType);

                return _methodCreditEarnedTypeId;
            } 
            set
            {
                _methodCreditEarnedTypeId = value;
                _methodCreditEarnedType = null;
            }
        }

        private int? _methodCreditEarnedTypeId;
        private string _methodCreditEarnedType;

        public virtual string MethodCreditEarnedType
        {
            get
            {
                if (_methodCreditEarnedType == null)
                    _methodCreditEarnedType = _methodCreditEarnedTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("MethodCreditEarnedType", _methodCreditEarnedTypeId.Value);
                    
                return _methodCreditEarnedType;
            }
            set
            {
                _methodCreditEarnedType = value;
                _methodCreditEarnedTypeId = default(int?);
            }
        }
        public virtual int? SchoolId  { get; set; }
        public virtual int? WhenTakenGradeLevelDescriptorId 
        {
            get
            {
                if (_whenTakenGradeLevelDescriptorId == default(int?))
                    _whenTakenGradeLevelDescriptorId = string.IsNullOrWhiteSpace(_whenTakenGradeLevelDescriptor) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("GradeLevelDescriptor", _whenTakenGradeLevelDescriptor);

                return _whenTakenGradeLevelDescriptorId;
            } 
            set
            {
                _whenTakenGradeLevelDescriptorId = value;
                _whenTakenGradeLevelDescriptor = null;
            }
        }

        private int? _whenTakenGradeLevelDescriptorId;
        private string _whenTakenGradeLevelDescriptor;

        public virtual string WhenTakenGradeLevelDescriptor
        {
            get
            {
                if (_whenTakenGradeLevelDescriptor == null)
                    _whenTakenGradeLevelDescriptor = _whenTakenGradeLevelDescriptorId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("GradeLevelDescriptor", _whenTakenGradeLevelDescriptorId.Value);
                    
                return _whenTakenGradeLevelDescriptor;
            }
            set
            {
                _whenTakenGradeLevelDescriptor = value;
                _whenTakenGradeLevelDescriptorId = default(int?);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------

        private IList<CourseTranscriptEarnedAdditionalCredits> _courseTranscriptEarnedAdditionalCredits;
        private IList<ICourseTranscriptEarnedAdditionalCredits> _courseTranscriptEarnedAdditionalCreditsCovariant;
        [ValidateEnumerable, NoDuplicateMembers]
        public virtual IList<CourseTranscriptEarnedAdditionalCredits> CourseTranscriptEarnedAdditionalCredits
        {
            get
            {
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseTranscriptEarnedAdditionalCredits)
                    if (item.CourseTranscript == null)
                        item.CourseTranscript = this;
                // -------------------------------------------------------------

                return _courseTranscriptEarnedAdditionalCredits;
            }
            set 
            { 
                _courseTranscriptEarnedAdditionalCredits = value;
                _courseTranscriptEarnedAdditionalCreditsCovariant = new CovariantIListAdapter<ICourseTranscriptEarnedAdditionalCredits, CourseTranscriptEarnedAdditionalCredits>(value);
            }
        }

        // Covariant version, visible only on the interface
        IList<ICourseTranscriptEarnedAdditionalCredits> ICourseTranscript.CourseTranscriptEarnedAdditionalCredits
        {
            get 
            { 
                // -------------------------------------------------------------
                // On-demand deserialization logic to attach reverse reference of children
                // due to ServiceStack's lack of [OnDeserialized] attribute support.
                // Back-reference is required by NHibernate for persistence.
                // -------------------------------------------------------------
                foreach (var item in _courseTranscriptEarnedAdditionalCredits)
                    if (item.CourseTranscript == null)
                        item.CourseTranscript = this;
                // -------------------------------------------------------------

                return _courseTranscriptEarnedAdditionalCreditsCovariant; 
            }
            set 
            { 
                CourseTranscriptEarnedAdditionalCredits = new List<CourseTranscriptEarnedAdditionalCredits>(value.Cast<CourseTranscriptEarnedAdditionalCredits>()); 
            }
        }

        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AttemptedCreditType", new LookupColumnDetails { PropertyName = "AttemptedCreditTypeId", LookupTypeName = "AttemptedCreditType"} },
                { "CourseAttemptResultType", new LookupColumnDetails { PropertyName = "CourseAttemptResultTypeId", LookupTypeName = "CourseAttemptResultType"} },
                { "CourseRepeatCodeType", new LookupColumnDetails { PropertyName = "CourseRepeatCodeTypeId", LookupTypeName = "CourseRepeatCodeType"} },
                { "EarnedCreditType", new LookupColumnDetails { PropertyName = "EarnedCreditTypeId", LookupTypeName = "EarnedCreditType"} },
                { "MethodCreditEarnedType", new LookupColumnDetails { PropertyName = "MethodCreditEarnedTypeId", LookupTypeName = "MethodCreditEarnedType"} },
                { "TermDescriptor", new LookupColumnDetails { PropertyName = "TermDescriptorId", LookupTypeName = "TermDescriptor"} },
                { "WhenTakenGradeLevelDescriptor", new LookupColumnDetails { PropertyName = "WhenTakenGradeLevelDescriptorId", LookupTypeName = "WhenTakenGradeLevelDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CourseAttemptResultTypeId", CourseAttemptResultTypeId);
            keyValues.Add("CourseCode", CourseCode);
            keyValues.Add("CourseEducationOrganizationId", CourseEducationOrganizationId);
            keyValues.Add("EducationOrganizationId", EducationOrganizationId);
            keyValues.Add("SchoolYear", SchoolYear);
            keyValues.Add("StudentUSI", StudentUSI);
            keyValues.Add("TermDescriptorId", TermDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseTranscript>
        {
            return this.SynchronizeTo((ICourseTranscript)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseTranscript) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAlternativeCourseCodeSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsAlternativeCourseCodeSupported 
        { 
            get { return _isAlternativeCourseCodeSupported; } 
            set { _isAlternativeCourseCodeSupported = value; }
        }

        private bool _isAlternativeCourseTitleSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsAlternativeCourseTitleSupported 
        { 
            get { return _isAlternativeCourseTitleSupported; } 
            set { _isAlternativeCourseTitleSupported = value; }
        }

        private bool _isAttemptedCreditConversionSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsAttemptedCreditConversionSupported 
        { 
            get { return _isAttemptedCreditConversionSupported; } 
            set { _isAttemptedCreditConversionSupported = value; }
        }

        private bool _isAttemptedCreditsSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsAttemptedCreditsSupported 
        { 
            get { return _isAttemptedCreditsSupported; } 
            set { _isAttemptedCreditsSupported = value; }
        }

        private bool _isAttemptedCreditTypeSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsAttemptedCreditTypeSupported 
        { 
            get { return _isAttemptedCreditTypeSupported; } 
            set { _isAttemptedCreditTypeSupported = value; }
        }

        private bool _isCourseRepeatCodeTypeSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsCourseRepeatCodeTypeSupported 
        { 
            get { return _isCourseRepeatCodeTypeSupported; } 
            set { _isCourseRepeatCodeTypeSupported = value; }
        }

        private bool _isCourseTitleSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsCourseTitleSupported 
        { 
            get { return _isCourseTitleSupported; } 
            set { _isCourseTitleSupported = value; }
        }

        private bool _isCourseTranscriptEarnedAdditionalCreditsSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsCourseTranscriptEarnedAdditionalCreditsSupported 
        { 
            get { return _isCourseTranscriptEarnedAdditionalCreditsSupported; } 
            set { _isCourseTranscriptEarnedAdditionalCreditsSupported = value; }
        }

        private bool _isEarnedCreditConversionSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsEarnedCreditConversionSupported 
        { 
            get { return _isEarnedCreditConversionSupported; } 
            set { _isEarnedCreditConversionSupported = value; }
        }

        private bool _isEarnedCreditsSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsEarnedCreditsSupported 
        { 
            get { return _isEarnedCreditsSupported; } 
            set { _isEarnedCreditsSupported = value; }
        }

        private bool _isEarnedCreditTypeSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsEarnedCreditTypeSupported 
        { 
            get { return _isEarnedCreditTypeSupported; } 
            set { _isEarnedCreditTypeSupported = value; }
        }

        private bool _isFinalLetterGradeEarnedSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsFinalLetterGradeEarnedSupported 
        { 
            get { return _isFinalLetterGradeEarnedSupported; } 
            set { _isFinalLetterGradeEarnedSupported = value; }
        }

        private bool _isFinalNumericGradeEarnedSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsFinalNumericGradeEarnedSupported 
        { 
            get { return _isFinalNumericGradeEarnedSupported; } 
            set { _isFinalNumericGradeEarnedSupported = value; }
        }

        private bool _isMethodCreditEarnedTypeSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsMethodCreditEarnedTypeSupported 
        { 
            get { return _isMethodCreditEarnedTypeSupported; } 
            set { _isMethodCreditEarnedTypeSupported = value; }
        }

        private bool _isSchoolIdSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsSchoolIdSupported 
        { 
            get { return _isSchoolIdSupported; } 
            set { _isSchoolIdSupported = value; }
        }

        private bool _isWhenTakenGradeLevelDescriptorSupported = true;
        bool ICourseTranscriptSynchronizationSourceSupport.IsWhenTakenGradeLevelDescriptorSupported 
        { 
            get { return _isWhenTakenGradeLevelDescriptorSupported; } 
            set { _isWhenTakenGradeLevelDescriptorSupported = value; }
        }

        private Func<ICourseTranscriptEarnedAdditionalCredits, bool> _isCourseTranscriptEarnedAdditionalCreditsIncluded;
        Func<ICourseTranscriptEarnedAdditionalCredits, bool> ICourseTranscriptSynchronizationSourceSupport.IsCourseTranscriptEarnedAdditionalCreditsIncluded
        { 
            get { return _isCourseTranscriptEarnedAdditionalCreditsIncluded; } 
            set { _isCourseTranscriptEarnedAdditionalCreditsIncluded = value; }
        }

        // -----------------------------------------
    } 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CourseTranscriptEarnedAdditionalCredits table of the CourseTranscript aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CourseTranscriptEarnedAdditionalCredits : EntityWithCompositeKey, IChildEntity, 
        ICourseTranscriptEarnedAdditionalCredits, ICourseTranscriptEarnedAdditionalCreditsRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICourseTranscriptEarnedAdditionalCreditsSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature, JsonIgnore, IgnoreDataMember]
        public virtual CourseTranscript CourseTranscript { get; set; }

        ICourseTranscript ICourseTranscriptEarnedAdditionalCredits.CourseTranscript
        {
            get { return CourseTranscript; }
            set { CourseTranscript = (CourseTranscript) value; }
        }

        int ICourseTranscriptEarnedAdditionalCreditsRecord.CourseAttemptResultTypeId
        {
            get { return ((ICourseTranscriptRecord) CourseTranscript).CourseAttemptResultTypeId; }
            set { ((ICourseTranscriptRecord) CourseTranscript).CourseAttemptResultTypeId = value; }
        }


        int ICourseTranscriptEarnedAdditionalCreditsRecord.StudentUSI
        {
            get { return ((ICourseTranscriptRecord) CourseTranscript).StudentUSI; }
            set { ((ICourseTranscriptRecord) CourseTranscript).StudentUSI = value; }
        }


        int ICourseTranscriptEarnedAdditionalCreditsRecord.EducationOrganizationId
        {
            get { return ((ICourseTranscriptRecord) CourseTranscript).EducationOrganizationId; }
            set { ((ICourseTranscriptRecord) CourseTranscript).EducationOrganizationId = value; }
        }


        int ICourseTranscriptEarnedAdditionalCreditsRecord.CourseEducationOrganizationId
        {
            get { return ((ICourseTranscriptRecord) CourseTranscript).CourseEducationOrganizationId; }
            set { ((ICourseTranscriptRecord) CourseTranscript).CourseEducationOrganizationId = value; }
        }


        short ICourseTranscriptEarnedAdditionalCreditsRecord.SchoolYear
        {
            get { return ((ICourseTranscriptRecord) CourseTranscript).SchoolYear; }
            set { ((ICourseTranscriptRecord) CourseTranscript).SchoolYear = value; }
        }


        int ICourseTranscriptEarnedAdditionalCreditsRecord.TermDescriptorId
        {
            get { return ((ICourseTranscriptRecord) CourseTranscript).TermDescriptorId; }
            set { ((ICourseTranscriptRecord) CourseTranscript).TermDescriptorId = value; }
        }


        string ICourseTranscriptEarnedAdditionalCreditsRecord.CourseCode
        {
            get { return ((ICourseTranscriptRecord) CourseTranscript).CourseCode; }
            set { ((ICourseTranscriptRecord) CourseTranscript).CourseCode = value; }
        }


        [DomainSignature, RequiredWithNonDefault]
        public virtual int AdditionalCreditTypeId 
        {
            get
            {
                if (_additionalCreditTypeId == default(int))
                    _additionalCreditTypeId = TypesAndDescriptorsCache.GetCache().GetId("AdditionalCreditType", _additionalCreditType);

                return _additionalCreditTypeId;
            } 
            set
            {
                _additionalCreditTypeId = value;
                _additionalCreditType = null;
            }
        }

        private int _additionalCreditTypeId;
        private string _additionalCreditType;

        public virtual string AdditionalCreditType
        {
            get
            {
                if (_additionalCreditType == null)
                    _additionalCreditType = TypesAndDescriptorsCache.GetCache().GetValue("AdditionalCreditType", _additionalCreditTypeId);
                    
                return _additionalCreditType;
            }
            set
            {
                _additionalCreditType = value;
                _additionalCreditTypeId = default(int);
            }
        }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [Range(typeof(decimal), "-9999999.99", "9999999.99")]
        public virtual decimal Credits  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AdditionalCreditType", new LookupColumnDetails { PropertyName = "AdditionalCreditTypeId", LookupTypeName = "AdditionalCreditType"} },
                { "CourseAttemptResultType", new LookupColumnDetails { PropertyName = "CourseAttemptResultTypeId", LookupTypeName = "CourseAttemptResultType"} },
                { "TermDescriptor", new LookupColumnDetails { PropertyName = "TermDescriptorId", LookupTypeName = "TermDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Get parent key values
            var keyValues = (CourseTranscript as IHasPrimaryKeyValues).GetPrimaryKeyValues();

            // Add current key values
            keyValues.Add("AdditionalCreditTypeId", AdditionalCreditTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICourseTranscriptEarnedAdditionalCredits>
        {
            return this.SynchronizeTo((ICourseTranscriptEarnedAdditionalCredits)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICourseTranscriptEarnedAdditionalCredits) target, null);
        }

        void IChildEntity.SetParent(object value) //, string context)
        {
            CourseTranscript = (CourseTranscript) value;
        }

        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCreditsSupported = true;
        bool ICourseTranscriptEarnedAdditionalCreditsSynchronizationSourceSupport.IsCreditsSupported 
        { 
            get { return _isCreditsSupported; } 
            set { _isCreditsSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CredentialFieldDescriptor

namespace EdFi.Ods.Entities.NHibernate.CredentialFieldDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CredentialFieldDescriptor table of the CredentialFieldDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CredentialFieldDescriptor : DescriptorAggregate.Descriptor, 
        ICredentialFieldDescriptor, ICredentialFieldDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICredentialFieldDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CredentialFieldDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        public virtual int? AcademicSubjectDescriptorId 
        {
            get
            {
                if (_academicSubjectDescriptorId == default(int?))
                    _academicSubjectDescriptorId = string.IsNullOrWhiteSpace(_academicSubjectDescriptor) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("AcademicSubjectDescriptor", _academicSubjectDescriptor);

                return _academicSubjectDescriptorId;
            } 
            set
            {
                _academicSubjectDescriptorId = value;
                _academicSubjectDescriptor = null;
            }
        }

        private int? _academicSubjectDescriptorId;
        private string _academicSubjectDescriptor;

        public virtual string AcademicSubjectDescriptor
        {
            get
            {
                if (_academicSubjectDescriptor == null)
                    _academicSubjectDescriptor = _academicSubjectDescriptorId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("AcademicSubjectDescriptor", _academicSubjectDescriptorId.Value);
                    
                return _academicSubjectDescriptor;
            }
            set
            {
                _academicSubjectDescriptor = value;
                _academicSubjectDescriptorId = default(int?);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "AcademicSubjectDescriptor", new LookupColumnDetails { PropertyName = "AcademicSubjectDescriptorId", LookupTypeName = "AcademicSubjectDescriptor"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CredentialFieldDescriptorId", CredentialFieldDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICredentialFieldDescriptor>
        {
            return this.SynchronizeTo((ICredentialFieldDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICredentialFieldDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isAcademicSubjectDescriptorSupported = true;
        bool ICredentialFieldDescriptorSynchronizationSourceSupport.IsAcademicSubjectDescriptorSupported 
        { 
            get { return _isAcademicSubjectDescriptorSupported; } 
            set { _isAcademicSubjectDescriptorSupported = value; }
        }

        private bool _isCodeValueSupported = true;
        bool ICredentialFieldDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICredentialFieldDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool ICredentialFieldDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool ICredentialFieldDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool ICredentialFieldDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool ICredentialFieldDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICredentialFieldDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CredentialType

namespace EdFi.Ods.Entities.NHibernate.CredentialTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CredentialType table of the CredentialType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CredentialType : AggregateRootWithCompositeKey, 
        ICredentialType, ICredentialTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICredentialTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CredentialTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CredentialTypeId", CredentialTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICredentialType>
        {
            return this.SynchronizeTo((ICredentialType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICredentialType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICredentialTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICredentialTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICredentialTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CreditType

namespace EdFi.Ods.Entities.NHibernate.CreditTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CreditType table of the CreditType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CreditType : AggregateRootWithCompositeKey, 
        ICreditType, ICreditTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICreditTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CreditTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CreditTypeId", CreditTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICreditType>
        {
            return this.SynchronizeTo((ICreditType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICreditType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICreditTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICreditTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICreditTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: CurriculumUsedType

namespace EdFi.Ods.Entities.NHibernate.CurriculumUsedTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.CurriculumUsedType table of the CurriculumUsedType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class CurriculumUsedType : AggregateRootWithCompositeKey, 
        ICurriculumUsedType, ICurriculumUsedTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, ICurriculumUsedTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int CurriculumUsedTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("CurriculumUsedTypeId", CurriculumUsedTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<ICurriculumUsedType>
        {
            return this.SynchronizeTo((ICurriculumUsedType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((ICurriculumUsedType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool ICurriculumUsedTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool ICurriculumUsedTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool ICurriculumUsedTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: DeliveryMethodType

namespace EdFi.Ods.Entities.NHibernate.DeliveryMethodTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.DeliveryMethodType table of the DeliveryMethodType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class DeliveryMethodType : AggregateRootWithCompositeKey, 
        IDeliveryMethodType, IDeliveryMethodTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IDeliveryMethodTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int DeliveryMethodTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("DeliveryMethodTypeId", DeliveryMethodTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IDeliveryMethodType>
        {
            return this.SynchronizeTo((IDeliveryMethodType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IDeliveryMethodType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IDeliveryMethodTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IDeliveryMethodTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IDeliveryMethodTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: Descriptor

namespace EdFi.Ods.Entities.NHibernate.DescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.Descriptor table of the Descriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public abstract class Descriptor : AggregateRootWithCompositeKey, 
        IDescriptor, IDescriptorRecord, IHasPrimaryKeyValues, IHasNonPrimaryKeyUniqueValues, IHasLookupColumnPropertyMap
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        public virtual int DescriptorId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [SqlServerDateTimeRange]
        public virtual DateTime? EffectiveBeginDate 
        {
            get { return _effectiveBeginDate; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _effectiveBeginDate = null;
                } else
                {
                    var given = (DateTime) value;
                    _effectiveBeginDate = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _effectiveBeginDate;
        
        [SqlServerDateTimeRange]
        public virtual DateTime? EffectiveEndDate 
        {
            get { return _effectiveEndDate; }
            set 
            { 
                //This is only stored as a Date in the DB and NHibernate will retrieve it using the default (local) DateTime.Kind.  We must ensure it is set consistently for any equality/change evaluation.
                if(value == null)
                {
                    _effectiveEndDate = null;
                } else
                {
                    var given = (DateTime) value;
                    _effectiveEndDate = new DateTime(given.Year, given.Month, given.Day);
                }
            }
        }

        private DateTime? _effectiveEndDate;
        
        [RequiredWithNonDefault, StringLength(255), NoDangerousText]
        public virtual string Namespace  { get; set; }
        public virtual int? PriorDescriptorId  { get; set; }
        [RequiredWithNonDefault, StringLength(75), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("DescriptorId", DescriptorId);

            return keyValues;
        }

        // Provide primary key information
        OrderedDictionary IHasNonPrimaryKeyUniqueValues.GetNonPrimaryUniqueKeyValues()
        {
            // Initialize a new dictionary to hold the key values
            var keyValues = new OrderedDictionary();
            keyValues.Add("Namespace", Namespace);
            keyValues.Add("CodeValue", CodeValue);
            return keyValues;
        }
        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

    } 
}
// Aggregate: DiagnosisDescriptor

namespace EdFi.Ods.Entities.NHibernate.DiagnosisDescriptorAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.DiagnosisDescriptor table of the DiagnosisDescriptor aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class DiagnosisDescriptor : DescriptorAggregate.Descriptor, 
        IDiagnosisDescriptor, IDiagnosisDescriptorRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IDiagnosisDescriptorSynchronizationSourceSupport, IEdFiDescriptor
    {
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int DiagnosisDescriptorId 
        {
            get { return base.DescriptorId; }
            set { base.DescriptorId = value; }
        }
        
        // -------------------------------------------------------------

        // =============================================================
        //                      Inherited Properties
        // -------------------------------------------------------------
        string IDescriptor.CodeValue 
        { 
            get { return CodeValue; } 
            set { CodeValue = value; }
        }
        string IDescriptor.Description 
        { 
            get { return Description; } 
            set { Description = value; }
        }
        DateTime? IDescriptor.EffectiveBeginDate 
        { 
            get { return EffectiveBeginDate; } 
            set { EffectiveBeginDate = value; }
        }
        DateTime? IDescriptor.EffectiveEndDate 
        { 
            get { return EffectiveEndDate; } 
            set { EffectiveEndDate = value; }
        }
        string IDescriptor.Namespace 
        { 
            get { return Namespace; } 
            set { Namespace = value; }
        }
        int? IDescriptor.PriorDescriptorId 
        { 
            get { return PriorDescriptorId; } 
            set { PriorDescriptorId = value; }
        }
        string IDescriptor.ShortDescription 
        { 
            get { return ShortDescription; } 
            set { ShortDescription = value; }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        public virtual int? DiagnosisTypeId 
        {
            get
            {
                if (_diagnosisTypeId == default(int?))
                    _diagnosisTypeId = string.IsNullOrWhiteSpace(_diagnosisType) ? default(int?) : TypesAndDescriptorsCache.GetCache().GetId("DiagnosisType", _diagnosisType);

                return _diagnosisTypeId;
            } 
            set
            {
                _diagnosisTypeId = value;
                _diagnosisType = null;
            }
        }

        private int? _diagnosisTypeId;
        private string _diagnosisType;

        public virtual string DiagnosisType
        {
            get
            {
                if (_diagnosisType == null)
                    _diagnosisType = _diagnosisTypeId == null ? null : TypesAndDescriptorsCache.GetCache().GetValue("DiagnosisType", _diagnosisTypeId.Value);
                    
                return _diagnosisType;
            }
            set
            {
                _diagnosisType = value;
                _diagnosisTypeId = default(int?);
            }
        }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
                { "DiagnosisType", new LookupColumnDetails { PropertyName = "DiagnosisTypeId", LookupTypeName = "DiagnosisType"} },
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("DiagnosisDescriptorId", DiagnosisDescriptorId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IDiagnosisDescriptor>
        {
            return this.SynchronizeTo((IDiagnosisDescriptor)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IDiagnosisDescriptor) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IDiagnosisDescriptorSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IDiagnosisDescriptorSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isDiagnosisTypeSupported = true;
        bool IDiagnosisDescriptorSynchronizationSourceSupport.IsDiagnosisTypeSupported 
        { 
            get { return _isDiagnosisTypeSupported; } 
            set { _isDiagnosisTypeSupported = value; }
        }

        private bool _isEffectiveBeginDateSupported = true;
        bool IDiagnosisDescriptorSynchronizationSourceSupport.IsEffectiveBeginDateSupported 
        { 
            get { return _isEffectiveBeginDateSupported; } 
            set { _isEffectiveBeginDateSupported = value; }
        }

        private bool _isEffectiveEndDateSupported = true;
        bool IDiagnosisDescriptorSynchronizationSourceSupport.IsEffectiveEndDateSupported 
        { 
            get { return _isEffectiveEndDateSupported; } 
            set { _isEffectiveEndDateSupported = value; }
        }

        private bool _isNamespaceSupported = true;
        bool IDiagnosisDescriptorSynchronizationSourceSupport.IsNamespaceSupported 
        { 
            get { return _isNamespaceSupported; } 
            set { _isNamespaceSupported = value; }
        }

        private bool _isPriorDescriptorIdSupported = true;
        bool IDiagnosisDescriptorSynchronizationSourceSupport.IsPriorDescriptorIdSupported 
        { 
            get { return _isPriorDescriptorIdSupported; } 
            set { _isPriorDescriptorIdSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IDiagnosisDescriptorSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: DiagnosisType

namespace EdFi.Ods.Entities.NHibernate.DiagnosisTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.DiagnosisType table of the DiagnosisType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class DiagnosisType : AggregateRootWithCompositeKey, 
        IDiagnosisType, IDiagnosisTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IDiagnosisTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int DiagnosisTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("DiagnosisTypeId", DiagnosisTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IDiagnosisType>
        {
            return this.SynchronizeTo((IDiagnosisType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IDiagnosisType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IDiagnosisTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IDiagnosisTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IDiagnosisTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: DiplomaLevelType

namespace EdFi.Ods.Entities.NHibernate.DiplomaLevelTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.DiplomaLevelType table of the DiplomaLevelType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class DiplomaLevelType : AggregateRootWithCompositeKey, 
        IDiplomaLevelType, IDiplomaLevelTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IDiplomaLevelTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int DiplomaLevelTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("DiplomaLevelTypeId", DiplomaLevelTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IDiplomaLevelType>
        {
            return this.SynchronizeTo((IDiplomaLevelType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IDiplomaLevelType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IDiplomaLevelTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IDiplomaLevelTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IDiplomaLevelTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: DiplomaType

namespace EdFi.Ods.Entities.NHibernate.DiplomaTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.DiplomaType table of the DiplomaType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class DiplomaType : AggregateRootWithCompositeKey, 
        IDiplomaType, IDiplomaTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IDiplomaTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int DiplomaTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [RequiredWithNonDefault, StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [RequiredWithNonDefault, StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("DiplomaTypeId", DiplomaTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IDiplomaType>
        {
            return this.SynchronizeTo((IDiplomaType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IDiplomaType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IDiplomaTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IDiplomaTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IDiplomaTypeSynchronizationSourceSupport.IsShortDescriptionSupported 
        { 
            get { return _isShortDescriptionSupported; } 
            set { _isShortDescriptionSupported = value; }
        }

        // -----------------------------------------
    } 
}
// Aggregate: DisabilityCategoryType

namespace EdFi.Ods.Entities.NHibernate.DisabilityCategoryTypeAggregate
{ 

// disable warnings for inheritance from classes marked Obsolete within this generated code only
#pragma warning disable 612, 618 

    /// <summary>
    /// A class which represents the edfi.DisabilityCategoryType table of the DisabilityCategoryType aggregate in the ODS database.
    /// </summary>
    [Serializable]
    public class DisabilityCategoryType : AggregateRootWithCompositeKey, 
        IDisabilityCategoryType, IDisabilityCategoryTypeRecord, IHasPrimaryKeyValues, IHasLookupColumnPropertyMap, IDisabilityCategoryTypeSynchronizationSourceSupport
    {
        public void SuspendReferenceAssignmentCheck() { }
        
        
        // -------------------------------------------------------------

        // =============================================================
        //                         Primary Key
        // -------------------------------------------------------------
        [DomainSignature]
        public virtual int DisabilityCategoryTypeId  { get; set; }
        // -------------------------------------------------------------


        // =============================================================
        //                          Properties
        // -------------------------------------------------------------
        [StringLength(50), NoDangerousText]
        public virtual string CodeValue  { get; set; }
        [StringLength(1024), NoDangerousText]
        public virtual string Description  { get; set; }
        [RequiredWithNonDefault, StringLength(450), NoDangerousText]
        public virtual string ShortDescription  { get; set; }
        // -------------------------------------------------------------

        // =============================================================
        //                          Collections
        // -------------------------------------------------------------
        // -------------------------------------------------------------

        // Provide lookup property map
        private static readonly Dictionary<string, LookupColumnDetails> _idPropertyByLookupProperty = new Dictionary<string, LookupColumnDetails>(StringComparer.InvariantCultureIgnoreCase)
            {
            };

        Dictionary<string, LookupColumnDetails> IHasLookupColumnPropertyMap.IdPropertyByLookupProperty
        {
            get { return _idPropertyByLookupProperty; }
        }

        // Provide primary key information
        OrderedDictionary IHasPrimaryKeyValues.GetPrimaryKeyValues()
        {
            // Initialize a new dictionary to hold the key values            
            var keyValues = new OrderedDictionary();

            // Add current key values
            keyValues.Add("DisabilityCategoryTypeId", DisabilityCategoryTypeId);

            return keyValues;
        }

        #region Overrides for Equals() and GetHashCode()
        public override bool Equals(object obj)
        {
            var compareTo = obj as IHasPrimaryKeyValues;

            if (ReferenceEquals(this, compareTo))
                return true;

            if (compareTo == null)
                return false;

            var theseKeys = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();
            var thoseKeys = compareTo.GetPrimaryKeyValues();

            foreach (DictionaryEntry entry in theseKeys)
            {
                if (!entry.Value.Equals(thoseKeys[entry.Key]))
                    return false;
            }

            return true;
        }

        private const int HashMultiplier = 31; // or 33, 37, 39, 41

        public override int GetHashCode()
        {
            unchecked
            {
                var keyValues = (this as IHasPrimaryKeyValues).GetPrimaryKeyValues();

                if (keyValues.Count == 0)
                    return base.GetHashCode();

                int hashCode = this.GetType().GetHashCode();

                foreach (DictionaryEntry entry in keyValues)
                {
                    if (entry.Value == null)
                        continue;

                    hashCode = (hashCode*HashMultiplier) ^ entry.Value.GetHashCode();
                }

                return hashCode;
            }
        }
        #endregion

        bool ISynchronizable.Synchronize(object target) // ISynchronizable<IDisabilityCategoryType>
        {
            return this.SynchronizeTo((IDisabilityCategoryType)target);
        }

        void IMappable.Map(object target)
        {
            this.MapTo((IDisabilityCategoryType) target, null);
        }


        // =========================================
        //        Synchronization Support
        // -----------------------------------------

        private bool _isCodeValueSupported = true;
        bool IDisabilityCategoryTypeSynchronizationSourceSupport.IsCodeValueSupported 
        { 
            get { return _isCodeValueSupported; } 
            set { _isCodeValueSupported = value; }
        }

        private bool _isDescriptionSupported = true;
        bool IDisabilityCategoryTypeSynchronizationSourceSupport.IsDescriptionSupported 
        { 
            get { return _isDescriptionSupported; } 
            set { _isDescriptionSupported = value; }
        }

        private bool _isShortDescriptionSupported = true;
        bool IDisabilityCategoryTypeSynchronizationSourceSupport