text:
@implementation DSError

+(DSError *)mergePushFailed {
  return [[DSError alloc] initWithDomain: @"com.DynamoService.mergrPushError" code: 1 userInfo: nil];
}

+(DSError *)forcePushFailed {
  return [[DSError alloc] initWithDomain: @"com.DynamoService.forcePushConflict" code: 2 userInfo: nil];
}

+(DSError *)pullFailed {
  return [[DSError alloc] initWithDomain: @"com.DynamoService.pullError" code: 3 userInfo: nil];
}

+(DSError *)remoteDataNil {
  return [[DSError alloc] initWithDomain: @"com.DynamoService.remoteDataNil" code: 4 userInfo: nil];
}

+(DSError *)noInternet {
  return [[DSError alloc] initWithDomain: @"com.DynamoService.noInternet" code: 5 userInfo: nil];
}

@end


text:
<resources>
    <string name="app_name">Otto Sample</string>
    <string name="move_location">Move Location</string>
    <string name="clear_location">Clear History</string>
</resources>

redpajama_set_name: RedPajamaGithub


text:
//------------------------------------------------------------------------------
// <autogenerated>
//     This code was generated by a tool.
//     Runtime Version: 1.1.4322.573
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </autogenerated>
//------------------------------------------------------------------------------

namespace HWD {
    using System;
    using System.Data;
    using System.Xml;
    using System.Runtime.Serialization;

    [Serializable()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Diagnostics.DebuggerStepThrough()]
    [System.ComponentModel.ToolboxItem(true)]
    public class userData : DataSet {

        private LWDDataTable tableLWD;

        private SWDDataTable tableSWD;

        private KWDDataTable tableKWD;

        private HWDDataTable tableHWD;

        private MWDDataTable tableMWD;

        private HotFixDataTable tableHotFix;

        public userData() {
            this.InitClass();
            System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += schemaChangedHandler;
            this.Relations.CollectionChanged += schemaChangedHandler;
        }

        protected userData(SerializationInfo info, StreamingContext context) {
            string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
            if ((strSchema != null)) {
                DataSet ds = new DataSet();
                ds.ReadXmlSchema(new XmlTextReader(new System.IO.StringReader(strSchema)));
                if ((ds.Tables["LWD"] != null)) {
                    this.Tables.Add(new LWDDataTable(ds.Tables["LWD"]));
                }
                if ((ds.Tables["SWD"] != null)) {
                    this.Tables.Add(new SWDDataTable(ds.Tables["SWD"]));
                }
                if ((ds.Tables["KWD"] != null)) {
                    this.Tables.Add(new KWDDataTable(ds.Tables["KWD"]));
                }
                if ((ds.Tables["HWD"] != null)) {
                    this.Tables.Add(new HWDDataTable(ds.Tables["HWD"]));
                }
                if ((ds.Tables["MWD"] != null)) {
                    this.Tables.Add(new MWDDataTable(ds.Tables["MWD"]));
                }
                if ((ds.Tables["HotFix"] != null)) {
                    this.Tables.Add(new HotFixDataTable(ds.Tables["HotFix"]));
                }
                this.DataSetName = ds.DataSetName;
                this.Prefix = ds.Prefix;
                this.Namespace = ds.Namespace;
                this.Locale = ds.Locale;
                this.CaseSensitive = ds.CaseSensitive;
                this.EnforceConstraints = ds.EnforceConstraints;
                this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
                this.InitVars();
            }
            else {
                this.InitClass();
            }
            this.GetSerializationData(info, context);
            System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += schemaChangedHandler;
            this.Relations.CollectionChanged += schemaChangedHandler;
        }

        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public LWDDataTable LWD {
            get {
                return this.tableLWD;
            }
        }

        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public SWDDataTable SWD {
            get {
                return this.tableSWD;
            }
        }

        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public KWDDataTable KWD {
            get {
                return this.tableKWD;
            }
        }

        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public HWDDataTable HWD {
            get {
                return this.tableHWD;
            }
        }

        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public MWDDataTable MWD {
            get {
                return this.tableMWD;
            }
        }

        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public HotFixDataTable HotFix {
            get {
                return this.tableHotFix;
            }
        }

        public override DataSet Clone() {
            userData cln = ((userData)(base.Clone()));
            cln.InitVars();
            return cln;
        }

        protected override bool ShouldSerializeTables() {
            return false;
        }

        protected override bool ShouldSerializeRelations() {
            return false;
        }

        protected override void ReadXmlSerializable(XmlReader reader) {
            this.Reset();
            DataSet ds = new DataSet();
            ds.ReadXml(reader);
            if ((ds.Tables["LWD"] != null)) {
                this.Tables.Add(new LWDDataTable(ds.Tables["LWD"]));
            }
            if ((ds.Tables["SWD"] != null)) {
                this.Tables.Add(new SWDDataTable(ds.Tables["SWD"]));
            }
            if ((ds.Tables["KWD"] != null)) {
                this.Tables.Add(new KWDDataTable(ds.Tables["KWD"]));
            }
            if ((ds.Tables["HWD"] != null)) {
                this.Tables.Add(new HWDDataTable(ds.Tables["HWD"]));
            }
            if ((ds.Tables["MWD"] != null)) {
                this.Tables.Add(new MWDDataTable(ds.Tables["MWD"]));
            }
            if ((ds.Tables["HotFix"] != null)) {
                this.Tables.Add(new HotFixDataTable(ds.Tables["HotFix"]));
            }
            this.DataSetName = ds.DataSetName;
            this.Prefix = ds.Prefix;
            this.Namespace = ds.Namespace;
            this.Locale = ds.Locale;
            this.CaseSensitive = ds.CaseSensitive;
            this.EnforceConstraints = ds.EnforceConstraints;
            this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
            this.InitVars();
        }

        protected override System.Xml.Schema.XmlSchema GetSchemaSerializable() {
            System.IO.MemoryStream stream = new System.IO.MemoryStream();
            this.WriteXmlSchema(new XmlTextWriter(stream, null));
            stream.Position = 0;
            return System.Xml.Schema.XmlSchema.Read(new XmlTextReader(stream), null);
        }

        internal void InitVars() {
            this.tableLWD = ((LWDDataTable)(this.Tables["LWD"]));
            if ((this.tableLWD != null)) {
                this.tableLWD.InitVars();
            }
            this.tableSWD = ((SWDDataTable)(this.Tables["SWD"]));
            if ((this.tableSWD != null)) {
                this.tableSWD.InitVars();
            }
            this.tableKWD = ((KWDDataTable)(this.Tables["KWD"]));
            if ((this.tableKWD != null)) {
                this.tableKWD.InitVars();
            }
            this.tableHWD = ((HWDDataTable)(this.Tables["HWD"]));
            if ((this.tableHWD != null)) {
                this.tableHWD.InitVars();
            }
            this.tableMWD = ((MWDDataTable)(this.Tables["MWD"]));
            if ((this.tableMWD != null)) {
                this.tableMWD.InitVars();
            }
            this.tableHotFix = ((HotFixDataTable)(this.Tables["HotFix"]));
            if ((this.tableHotFix != null)) {
                this.tableHotFix.InitVars();
            }
        }

        private void InitClass() {
            this.DataSetName = "userData";
            this.Prefix = "";
            this.Namespace = "http://www.tempuri.org/userData.xsd";
            this.Locale = new System.Globalization.CultureInfo("es-MX");
            this.CaseSensitive = false;
            this.EnforceConstraints = true;
            this.tableLWD = new LWDDataTable();
            this.Tables.Add(this.tableLWD);
            this.tableSWD = new SWDDataTable();
            this.Tables.Add(this.tableSWD);
            this.tableKWD = new KWDDataTable();
            this.Tables.Add(this.tableKWD);
            this.tableHWD = new HWDDataTable();
            this.Tables.Add(this.tableHWD);
            this.tableMWD = new MWDDataTable();
            this.Tables.Add(this.tableMWD);
            this.tableHotFix = new HotFixDataTable();
            this.Tables.Add(this.tableHotFix);
        }

        private bool ShouldSerializeLWD() {
            return false;
        }

        private bool ShouldSerializeSWD() {
            return false;
        }

        private bool ShouldSerializeKWD() {
            return false;
        }

        private bool ShouldSerializeHWD() {
            return false;
        }

        private bool ShouldSerializeMWD() {
            return false;
        }

        private bool ShouldSerializeHotFix() {
            return false;
        }

        private void SchemaChanged(object sender, System.ComponentModel.CollectionChangeEventArgs e) {
            if ((e.Action == System.ComponentModel.CollectionChangeAction.Remove)) {
                this.InitVars();
            }
        }

        public delegate void LWDRowChangeEventHandler(object sender, LWDRowChangeEvent e);

        public delegate void SWDRowChangeEventHandler(object sender, SWDRowChangeEvent e);

        public delegate void KWDRowChangeEventHandler(object sender, KWDRowChangeEvent e);

        public delegate void HWDRowChangeEventHandler(object sender, HWDRowChangeEvent e);

        public delegate void MWDRowChangeEventHandler(object sender, MWDRowChangeEvent e);

        public delegate void HotFixRowChangeEventHandler(object sender, HotFixRowChangeEvent e);

        [System.Diagnostics.DebuggerStepThrough()]
        public class LWDDataTable : DataTable, System.Collections.IEnumerable {

            private DataColumn columnIDLocation;

            private DataColumn columnLocationName;

            internal LWDDataTable() :
                    base("LWD") {
                this.InitClass();
            }

            internal LWDDataTable(DataTable table) :
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }

            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }

            internal DataColumn IDLocationColumn {
                get {
                    return this.columnIDLocation;
                }
            }

            internal DataColumn LocationNameColumn {
                get {
                    return this.columnLocationName;
                }
            }

            public LWDRow this[int index] {
                get {
                    return ((LWDRow)(this.Rows[index]));
                }
            }

            public event LWDRowChangeEventHandler LWDRowChanged;

            public event LWDRowChangeEventHandler LWDRowChanging;

            public event LWDRowChangeEventHandler LWDRowDeleted;

            public event LWDRowChangeEventHandler LWDRowDeleting;

            public void AddLWDRow(LWDRow row) {
                this.Rows.Add(row);
            }

            public LWDRow AddLWDRow(string LocationName) {
                LWDRow rowLWDRow = ((LWDRow)(this.NewRow()));
                rowLWDRow.ItemArray = new object[] {
                        null,
                        LocationName};
                this.Rows.Add(rowLWDRow);
                return rowLWDRow;
            }

            public LWDRow FindByIDLocation(int IDLocation) {
                return ((LWDRow)(this.Rows.Find(new object[] {
                            IDLocation})));
            }

            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }

            public override DataTable Clone() {
                LWDDataTable cln = ((LWDDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }

            protected override DataTable CreateInstance() {
                return new LWDDataTable();
            }

            internal void InitVars() {
                this.columnIDLocation = this.Columns["IDLocation"];
                this.columnLocationName = this.Columns["LocationName"];
            }

            private void InitClass() {
                this.columnIDLocation = new DataColumn("IDLocation", typeof(int), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnIDLocation);
                this.columnLocationName = new DataColumn("LocationName", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnLocationName);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnIDLocation}, true));
                this.columnIDLocation.AutoIncrement = true;
                this.columnIDLocation.AllowDBNull = false;
                this.columnIDLocation.ReadOnly = true;
                this.columnIDLocation.Unique = true;
            }

            public LWDRow NewLWDRow() {
                return ((LWDRow)(this.NewRow()));
            }

            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new LWDRow(builder);
            }

            protected override System.Type GetRowType() {
                return typeof(LWDRow);
            }

            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.LWDRowChanged != null)) {
                    this.LWDRowChanged(this, new LWDRowChangeEvent(((LWDRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.LWDRowChanging != null)) {
                    this.LWDRowChanging(this, new LWDRowChangeEvent(((LWDRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.LWDRowDeleted != null)) {
                    this.LWDRowDeleted(this, new LWDRowChangeEvent(((LWDRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.LWDRowDeleting != null)) {
                    this.LWDRowDeleting(this, new LWDRowChangeEvent(((LWDRow)(e.Row)), e.Action));
                }
            }

            public void RemoveLWDRow(LWDRow row) {
                this.Rows.Remove(row);
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class LWDRow : DataRow {

            private LWDDataTable tableLWD;

            internal LWDRow(DataRowBuilder rb) :
                    base(rb) {
                this.tableLWD = ((LWDDataTable)(this.Table));
            }

            public int IDLocation {
                get {
                    return ((int)(this[this.tableLWD.IDLocationColumn]));
                }
                set {
                    this[this.tableLWD.IDLocationColumn] = value;
                }
            }

            public string LocationName {
                get {
                    try {
                        return ((string)(this[this.tableLWD.LocationNameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableLWD.LocationNameColumn] = value;
                }
            }

            public bool IsLocationNameNull() {
                return this.IsNull(this.tableLWD.LocationNameColumn);
            }

            public void SetLocationNameNull() {
                this[this.tableLWD.LocationNameColumn] = System.Convert.DBNull;
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class LWDRowChangeEvent : EventArgs {

            private LWDRow eventRow;

            private DataRowAction eventAction;

            public LWDRowChangeEvent(LWDRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }

            public LWDRow Row {
                get {
                    return this.eventRow;
                }
            }

            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class SWDDataTable : DataTable, System.Collections.IEnumerable {

            private DataColumn columnID;

            private DataColumn columnComputerName;

            private DataColumn columnSoftwareName;

            private DataColumn columnVersion;

            private DataColumn columnVendor;

            internal SWDDataTable() :
                    base("SWD") {
                this.InitClass();
            }

            internal SWDDataTable(DataTable table) :
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }

            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }

            internal DataColumn IDColumn {
                get {
                    return this.columnID;
                }
            }

            internal DataColumn ComputerNameColumn {
                get {
                    return this.columnComputerName;
                }
            }

            internal DataColumn SoftwareNameColumn {
                get {
                    return this.columnSoftwareName;
                }
            }

            internal DataColumn VersionColumn {
                get {
                    return this.columnVersion;
                }
            }

            internal DataColumn VendorColumn {
                get {
                    return this.columnVendor;
                }
            }

            public SWDRow this[int index] {
                get {
                    return ((SWDRow)(this.Rows[index]));
                }
            }

            public event SWDRowChangeEventHandler SWDRowChanged;

            public event SWDRowChangeEventHandler SWDRowChanging;

            public event SWDRowChangeEventHandler SWDRowDeleted;

            public event SWDRowChangeEventHandler SWDRowDeleting;

            public void AddSWDRow(SWDRow row) {
                this.Rows.Add(row);
            }

            public SWDRow AddSWDRow(string ComputerName, string SoftwareName, string Version, string Vendor) {
                SWDRow rowSWDRow = ((SWDRow)(this.NewRow()));
                rowSWDRow.ItemArray = new object[] {
                        null,
                        ComputerName,
                        SoftwareName,
                        Version,
                        Vendor};
                this.Rows.Add(rowSWDRow);
                return rowSWDRow;
            }

            public SWDRow FindByID(int ID) {
                return ((SWDRow)(this.Rows.Find(new object[] {
                            ID})));
            }

            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }

            public override DataTable Clone() {
                SWDDataTable cln = ((SWDDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }

            protected override DataTable CreateInstance() {
                return new SWDDataTable();
            }

            internal void InitVars() {
                this.columnID = this.Columns["ID"];
                this.columnComputerName = this.Columns["ComputerName"];
                this.columnSoftwareName = this.Columns["SoftwareName"];
                this.columnVersion = this.Columns["Version"];
                this.columnVendor = this.Columns["Vendor"];
            }

            private void InitClass() {
                this.columnID = new DataColumn("ID", typeof(int), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnID);
                this.columnComputerName = new DataColumn("ComputerName", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnComputerName);
                this.columnSoftwareName = new DataColumn("SoftwareName", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnSoftwareName);
                this.columnVersion = new DataColumn("Version", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnVersion);
                this.columnVendor = new DataColumn("Vendor", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnVendor);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnID}, true));
                this.columnID.AutoIncrement = true;
                this.columnID.AllowDBNull = false;
                this.columnID.ReadOnly = true;
                this.columnID.Unique = true;
                this.columnComputerName.AllowDBNull = false;
                this.columnSoftwareName.AllowDBNull = false;
            }

            public SWDRow NewSWDRow() {
                return ((SWDRow)(this.NewRow()));
            }

            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new SWDRow(builder);
            }

            protected override System.Type GetRowType() {
                return typeof(SWDRow);
            }

            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.SWDRowChanged != null)) {
                    this.SWDRowChanged(this, new SWDRowChangeEvent(((SWDRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.SWDRowChanging != null)) {
                    this.SWDRowChanging(this, new SWDRowChangeEvent(((SWDRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.SWDRowDeleted != null)) {
                    this.SWDRowDeleted(this, new SWDRowChangeEvent(((SWDRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.SWDRowDeleting != null)) {
                    this.SWDRowDeleting(this, new SWDRowChangeEvent(((SWDRow)(e.Row)), e.Action));
                }
            }

            public void RemoveSWDRow(SWDRow row) {
                this.Rows.Remove(row);
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class SWDRow : DataRow {

            private SWDDataTable tableSWD;

            internal SWDRow(DataRowBuilder rb) :
                    base(rb) {
                this.tableSWD = ((SWDDataTable)(this.Table));
            }

            public int ID {
                get {
                    return ((int)(this[this.tableSWD.IDColumn]));
                }
                set {
                    this[this.tableSWD.IDColumn] = value;
                }
            }

            public string ComputerName {
                get {
                    return ((string)(this[this.tableSWD.ComputerNameColumn]));
                }
                set {
                    this[this.tableSWD.ComputerNameColumn] = value;
                }
            }

            public string SoftwareName {
                get {
                    return ((string)(this[this.tableSWD.SoftwareNameColumn]));
                }
                set {
                    this[this.tableSWD.SoftwareNameColumn] = value;
                }
            }

            public string Version {
                get {
                    try {
                        return ((string)(this[this.tableSWD.VersionColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableSWD.VersionColumn] = value;
                }
            }

            public string Vendor {
                get {
                    try {
                        return ((string)(this[this.tableSWD.VendorColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableSWD.VendorColumn] = value;
                }
            }

            public bool IsVersionNull() {
                return this.IsNull(this.tableSWD.VersionColumn);
            }

            public void SetVersionNull() {
                this[this.tableSWD.VersionColumn] = System.Convert.DBNull;
            }

            public bool IsVendorNull() {
                return this.IsNull(this.tableSWD.VendorColumn);
            }

            public void SetVendorNull() {
                this[this.tableSWD.VendorColumn] = System.Convert.DBNull;
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class SWDRowChangeEvent : EventArgs {

            private SWDRow eventRow;

            private DataRowAction eventAction;

            public SWDRowChangeEvent(SWDRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }

            public SWDRow Row {
                get {
                    return this.eventRow;
                }
            }

            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class KWDDataTable : DataTable, System.Collections.IEnumerable {

            private DataColumn columnIDKind;

            private DataColumn columnKindName;

            internal KWDDataTable() :
                    base("KWD") {
                this.InitClass();
            }

            internal KWDDataTable(DataTable table) :
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }

            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }

            internal DataColumn IDKindColumn {
                get {
                    return this.columnIDKind;
                }
            }

            internal DataColumn KindNameColumn {
                get {
                    return this.columnKindName;
                }
            }

            public KWDRow this[int index] {
                get {
                    return ((KWDRow)(this.Rows[index]));
                }
            }

            public event KWDRowChangeEventHandler KWDRowChanged;

            public event KWDRowChangeEventHandler KWDRowChanging;

            public event KWDRowChangeEventHandler KWDRowDeleted;

            public event KWDRowChangeEventHandler KWDRowDeleting;

            public void AddKWDRow(KWDRow row) {
                this.Rows.Add(row);
            }

            public KWDRow AddKWDRow(string KindName) {
                KWDRow rowKWDRow = ((KWDRow)(this.NewRow()));
                rowKWDRow.ItemArray = new object[] {
                        null,
                        KindName};
                this.Rows.Add(rowKWDRow);
                return rowKWDRow;
            }

            public KWDRow FindByIDKind(int IDKind) {
                return ((KWDRow)(this.Rows.Find(new object[] {
                            IDKind})));
            }

            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }

            public override DataTable Clone() {
                KWDDataTable cln = ((KWDDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }

            protected override DataTable CreateInstance() {
                return new KWDDataTable();
            }

            internal void InitVars() {
                this.columnIDKind = this.Columns["IDKind"];
                this.columnKindName = this.Columns["KindName"];
            }

            private void InitClass() {
                this.columnIDKind = new DataColumn("IDKind", typeof(int), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnIDKind);
                this.columnKindName = new DataColumn("KindName", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnKindName);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnIDKind}, true));
                this.columnIDKind.AutoIncrement = true;
                this.columnIDKind.AllowDBNull = false;
                this.columnIDKind.ReadOnly = true;
                this.columnIDKind.Unique = true;
            }

            public KWDRow NewKWDRow() {
                return ((KWDRow)(this.NewRow()));
            }

            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new KWDRow(builder);
            }

            protected override System.Type GetRowType() {
                return typeof(KWDRow);
            }

            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.KWDRowChanged != null)) {
                    this.KWDRowChanged(this, new KWDRowChangeEvent(((KWDRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.KWDRowChanging != null)) {
                    this.KWDRowChanging(this, new KWDRowChangeEvent(((KWDRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.KWDRowDeleted != null)) {
                    this.KWDRowDeleted(this, new KWDRowChangeEvent(((KWDRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.KWDRowDeleting != null)) {
                    this.KWDRowDeleting(this, new KWDRowChangeEvent(((KWDRow)(e.Row)), e.Action));
                }
            }

            public void RemoveKWDRow(KWDRow row) {
                this.Rows.Remove(row);
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class KWDRow : DataRow {

            private KWDDataTable tableKWD;

            internal KWDRow(DataRowBuilder rb) :
                    base(rb) {
                this.tableKWD = ((KWDDataTable)(this.Table));
            }

            public int IDKind {
                get {
                    return ((int)(this[this.tableKWD.IDKindColumn]));
                }
                set {
                    this[this.tableKWD.IDKindColumn] = value;
                }
            }

            public string KindName {
                get {
                    try {
                        return ((string)(this[this.tableKWD.KindNameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableKWD.KindNameColumn] = value;
                }
            }

            public bool IsKindNameNull() {
                return this.IsNull(this.tableKWD.KindNameColumn);
            }

            public void SetKindNameNull() {
                this[this.tableKWD.KindNameColumn] = System.Convert.DBNull;
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class KWDRowChangeEvent : EventArgs {

            private KWDRow eventRow;

            private DataRowAction eventAction;

            public KWDRowChangeEvent(KWDRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }

            public KWDRow Row {
                get {
                    return this.eventRow;
                }
            }

            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class HWDDataTable : DataTable, System.Collections.IEnumerable {

            private DataColumn columnID;

            private DataColumn columnComputerName;

            private DataColumn columnOS;

            private DataColumn columnUsername;

            private DataColumn columnManufacturer;

            private DataColumn columnModel;

            private DataColumn columnSerialNumber;

            private DataColumn columnRAM;

            private DataColumn columnProcessor;

            private DataColumn columnIDKind;

            private DataColumn columnIDLocation;

            private DataColumn columnStatus;

            private DataColumn columnNotes;

            internal HWDDataTable() :
                    base("HWD") {
                this.InitClass();
            }

            internal HWDDataTable(DataTable table) :
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }

            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }

            internal DataColumn IDColumn {
                get {
                    return this.columnID;
                }
            }

            internal DataColumn ComputerNameColumn {
                get {
                    return this.columnComputerName;
                }
            }

            internal DataColumn OSColumn {
                get {
                    return this.columnOS;
                }
            }

            internal DataColumn UsernameColumn {
                get {
                    return this.columnUsername;
                }
            }

            internal DataColumn ManufacturerColumn {
                get {
                    return this.columnManufacturer;
                }
            }

            internal DataColumn ModelColumn {
                get {
                    return this.columnModel;
                }
            }

            internal DataColumn SerialNumberColumn {
                get {
                    return this.columnSerialNumber;
                }
            }

            internal DataColumn RAMColumn {
                get {
                    return this.columnRAM;
                }
            }

            internal DataColumn ProcessorColumn {
                get {
                    return this.columnProcessor;
                }
            }

            internal DataColumn IDKindColumn {
                get {
                    return this.columnIDKind;
                }
            }

            internal DataColumn IDLocationColumn {
                get {
                    return this.columnIDLocation;
                }
            }

            internal DataColumn StatusColumn {
                get {
                    return this.columnStatus;
                }
            }

            internal DataColumn NotesColumn {
                get {
                    return this.columnNotes;
                }
            }

            public HWDRow this[int index] {
                get {
                    return ((HWDRow)(this.Rows[index]));
                }
            }

            public event HWDRowChangeEventHandler HWDRowChanged;

            public event HWDRowChangeEventHandler HWDRowChanging;

            public event HWDRowChangeEventHandler HWDRowDeleted;

            public event HWDRowChangeEventHandler HWDRowDeleting;

            public void AddHWDRow(HWDRow row) {
                this.Rows.Add(row);
            }

            public HWDRow AddHWDRow(string ComputerName, string OS, string Username, string Manufacturer, string Model, string SerialNumber, string RAM, string Processor, int IDKind, int IDLocation, bool Status, string Notes) {
                HWDRow rowHWDRow = ((HWDRow)(this.NewRow()));
                rowHWDRow.ItemArray = new object[] {
                        null,
                        ComputerName,
                        OS,
                        Username,
                        Manufacturer,
                        Model,
                        SerialNumber,
                        RAM,
                        Processor,
                        IDKind,
                        IDLocation,
                        Status,
                        Notes};
                this.Rows.Add(rowHWDRow);
                return rowHWDRow;
            }

            public HWDRow FindByComputerName(string ComputerName) {
                return ((HWDRow)(this.Rows.Find(new object[] {
                            ComputerName})));
            }

            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }

            public override DataTable Clone() {
                HWDDataTable cln = ((HWDDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }

            protected override DataTable CreateInstance() {
                return new HWDDataTable();
            }

            internal void InitVars() {
                this.columnID = this.Columns["ID"];
                this.columnComputerName = this.Columns["ComputerName"];
                this.columnOS = this.Columns["OS"];
                this.columnUsername = this.Columns["Username"];
                this.columnManufacturer = this.Columns["Manufacturer"];
                this.columnModel = this.Columns["Model"];
                this.columnSerialNumber = this.Columns["SerialNumber"];
                this.columnRAM = this.Columns["RAM"];
                this.columnProcessor = this.Columns["Processor"];
                this.columnIDKind = this.Columns["IDKind"];
                this.columnIDLocation = this.Columns["IDLocation"];
                this.columnStatus = this.Columns["Status"];
                this.columnNotes = this.Columns["Notes"];
            }

            private void InitClass() {
                this.columnID = new DataColumn("ID", typeof(int), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnID);
                this.columnComputerName = new DataColumn("ComputerName", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnComputerName);
                this.columnOS = new DataColumn("OS", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnOS);
                this.columnUsername = new DataColumn("Username", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnUsername);
                this.columnManufacturer = new DataColumn("Manufacturer", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnManufacturer);
                this.columnModel = new DataColumn("Model", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnModel);
                this.columnSerialNumber = new DataColumn("SerialNumber", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnSerialNumber);
                this.columnRAM = new DataColumn("RAM", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnRAM);
                this.columnProcessor = new DataColumn("Processor", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnProcessor);
                this.columnIDKind = new DataColumn("IDKind", typeof(int), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnIDKind);
                this.columnIDLocation = new DataColumn("IDLocation", typeof(int), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnIDLocation);
                this.columnStatus = new DataColumn("Status", typeof(bool), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnStatus);
                this.columnNotes = new DataColumn("Notes", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnNotes);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnComputerName}, true));
                this.columnID.AutoIncrement = true;
                this.columnID.AllowDBNull = false;
                this.columnID.ReadOnly = true;
                this.columnComputerName.AllowDBNull = false;
                this.columnComputerName.Unique = true;
            }

            public HWDRow NewHWDRow() {
                return ((HWDRow)(this.NewRow()));
            }

            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new HWDRow(builder);
            }

            protected override System.Type GetRowType() {
                return typeof(HWDRow);
            }

            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.HWDRowChanged != null)) {
                    this.HWDRowChanged(this, new HWDRowChangeEvent(((HWDRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.HWDRowChanging != null)) {
                    this.HWDRowChanging(this, new HWDRowChangeEvent(((HWDRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.HWDRowDeleted != null)) {
                    this.HWDRowDeleted(this, new HWDRowChangeEvent(((HWDRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.HWDRowDeleting != null)) {
                    this.HWDRowDeleting(this, new HWDRowChangeEvent(((HWDRow)(e.Row)), e.Action));
                }
            }

            public void RemoveHWDRow(HWDRow row) {
                this.Rows.Remove(row);
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class HWDRow : DataRow {

            private HWDDataTable tableHWD;

            internal HWDRow(DataRowBuilder rb) :
                    base(rb) {
                this.tableHWD = ((HWDDataTable)(this.Table));
            }

            public int ID {
                get {
                    return ((int)(this[this.tableHWD.IDColumn]));
                }
                set {
                    this[this.tableHWD.IDColumn] = value;
                }
            }

            public string ComputerName {
                get {
                    return ((string)(this[this.tableHWD.ComputerNameColumn]));
                }
                set {
                    this[this.tableHWD.ComputerNameColumn] = value;
                }
            }

            public string OS {
                get {
                    try {
                        return ((string)(this[this.tableHWD.OSColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHWD.OSColumn] = value;
                }
            }

            public string Username {
                get {
                    try {
                        return ((string)(this[this.tableHWD.UsernameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHWD.UsernameColumn] = value;
                }
            }

            public string Manufacturer {
                get {
                    try {
                        return ((string)(this[this.tableHWD.ManufacturerColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHWD.ManufacturerColumn] = value;
                }
            }

            public string Model {
                get {
                    try {
                        return ((string)(this[this.tableHWD.ModelColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHWD.ModelColumn] = value;
                }
            }

            public string SerialNumber {
                get {
                    try {
                        return ((string)(this[this.tableHWD.SerialNumberColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHWD.SerialNumberColumn] = value;
                }
            }

            public string RAM {
                get {
                    try {
                        return ((string)(this[this.tableHWD.RAMColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHWD.RAMColumn] = value;
                }
            }

            public string Processor {
                get {
                    try {
                        return ((string)(this[this.tableHWD.ProcessorColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHWD.ProcessorColumn] = value;
                }
            }

            public int IDKind {
                get {
                    try {
                        return ((int)(this[this.tableHWD.IDKindColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHWD.IDKindColumn] = value;
                }
            }

            public int IDLocation {
                get {
                    try {
                        return ((int)(this[this.tableHWD.IDLocationColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHWD.IDLocationColumn] = value;
                }
            }

            public bool Status {
                get {
                    try {
                        return ((bool)(this[this.tableHWD.StatusColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHWD.StatusColumn] = value;
                }
            }

            public string Notes {
                get {
                    try {
                        return ((string)(this[this.tableHWD.NotesColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHWD.NotesColumn] = value;
                }
            }

            public bool IsOSNull() {
                return this.IsNull(this.tableHWD.OSColumn);
            }

            public void SetOSNull() {
                this[this.tableHWD.OSColumn] = System.Convert.DBNull;
            }

            public bool IsUsernameNull() {
                return this.IsNull(this.tableHWD.UsernameColumn);
            }

            public void SetUsernameNull() {
                this[this.tableHWD.UsernameColumn] = System.Convert.DBNull;
            }

            public bool IsManufacturerNull() {
                return this.IsNull(this.tableHWD.ManufacturerColumn);
            }

            public void SetManufacturerNull() {
                this[this.tableHWD.ManufacturerColumn] = System.Convert.DBNull;
            }

            public bool IsModelNull() {
                return this.IsNull(this.tableHWD.ModelColumn);
            }

            public void SetModelNull() {
                this[this.tableHWD.ModelColumn] = System.Convert.DBNull;
            }

            public bool IsSerialNumberNull() {
                return this.IsNull(this.tableHWD.SerialNumberColumn);
            }

            public void SetSerialNumberNull() {
                this[this.tableHWD.SerialNumberColumn] = System.Convert.DBNull;
            }

            public bool IsRAMNull() {
                return this.IsNull(this.tableHWD.RAMColumn);
            }

            public void SetRAMNull() {
                this[this.tableHWD.RAMColumn] = System.Convert.DBNull;
            }

            public bool IsProcessorNull() {
                return this.IsNull(this.tableHWD.ProcessorColumn);
            }

            public void SetProcessorNull() {
                this[this.tableHWD.ProcessorColumn] = System.Convert.DBNull;
            }

            public bool IsIDKindNull() {
                return this.IsNull(this.tableHWD.IDKindColumn);
            }

            public void SetIDKindNull() {
                this[this.tableHWD.IDKindColumn] = System.Convert.DBNull;
            }

            public bool IsIDLocationNull() {
                return this.IsNull(this.tableHWD.IDLocationColumn);
            }

            public void SetIDLocationNull() {
                this[this.tableHWD.IDLocationColumn] = System.Convert.DBNull;
            }

            public bool IsStatusNull() {
                return this.IsNull(this.tableHWD.StatusColumn);
            }

            public void SetStatusNull() {
                this[this.tableHWD.StatusColumn] = System.Convert.DBNull;
            }

            public bool IsNotesNull() {
                return this.IsNull(this.tableHWD.NotesColumn);
            }

            public void SetNotesNull() {
                this[this.tableHWD.NotesColumn] = System.Convert.DBNull;
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class HWDRowChangeEvent : EventArgs {

            private HWDRow eventRow;

            private DataRowAction eventAction;

            public HWDRowChangeEvent(HWDRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }

            public HWDRow Row {
                get {
                    return this.eventRow;
                }
            }

            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class MWDDataTable : DataTable, System.Collections.IEnumerable {

            private DataColumn columnComputerName;

            private DataColumn columnUserName;

            private DataColumn columnItemCaption;

            internal MWDDataTable() :
                    base("MWD") {
                this.InitClass();
            }

            internal MWDDataTable(DataTable table) :
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }

            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }

            internal DataColumn ComputerNameColumn {
                get {
                    return this.columnComputerName;
                }
            }

            internal DataColumn UserNameColumn {
                get {
                    return this.columnUserName;
                }
            }

            internal DataColumn ItemCaptionColumn {
                get {
                    return this.columnItemCaption;
                }
            }

            public MWDRow this[int index] {
                get {
                    return ((MWDRow)(this.Rows[index]));
                }
            }

            public event MWDRowChangeEventHandler MWDRowChanged;

            public event MWDRowChangeEventHandler MWDRowChanging;

            public event MWDRowChangeEventHandler MWDRowDeleted;

            public event MWDRowChangeEventHandler MWDRowDeleting;

            public void AddMWDRow(MWDRow row) {
                this.Rows.Add(row);
            }

            public MWDRow AddMWDRow(string ComputerName, string UserName, string ItemCaption) {
                MWDRow rowMWDRow = ((MWDRow)(this.NewRow()));
                rowMWDRow.ItemArray = new object[] {
                        ComputerName,
                        UserName,
                        ItemCaption};
                this.Rows.Add(rowMWDRow);
                return rowMWDRow;
            }

            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }

            public override DataTable Clone() {
                MWDDataTable cln = ((MWDDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }

            protected override DataTable CreateInstance() {
                return new MWDDataTable();
            }

            internal void InitVars() {
                this.columnComputerName = this.Columns["ComputerName"];
                this.columnUserName = this.Columns["UserName"];
                this.columnItemCaption = this.Columns["ItemCaption"];
            }

            private void InitClass() {
                this.columnComputerName = new DataColumn("ComputerName", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnComputerName);
                this.columnUserName = new DataColumn("UserName", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnUserName);
                this.columnItemCaption = new DataColumn("ItemCaption", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnItemCaption);
            }

            public MWDRow NewMWDRow() {
                return ((MWDRow)(this.NewRow()));
            }

            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new MWDRow(builder);
            }

            protected override System.Type GetRowType() {
                return typeof(MWDRow);
            }

            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.MWDRowChanged != null)) {
                    this.MWDRowChanged(this, new MWDRowChangeEvent(((MWDRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.MWDRowChanging != null)) {
                    this.MWDRowChanging(this, new MWDRowChangeEvent(((MWDRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.MWDRowDeleted != null)) {
                    this.MWDRowDeleted(this, new MWDRowChangeEvent(((MWDRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.MWDRowDeleting != null)) {
                    this.MWDRowDeleting(this, new MWDRowChangeEvent(((MWDRow)(e.Row)), e.Action));
                }
            }

            public void RemoveMWDRow(MWDRow row) {
                this.Rows.Remove(row);
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class MWDRow : DataRow {

            private MWDDataTable tableMWD;

            internal MWDRow(DataRowBuilder rb) :
                    base(rb) {
                this.tableMWD = ((MWDDataTable)(this.Table));
            }

            public string ComputerName {
                get {
                    try {
                        return ((string)(this[this.tableMWD.ComputerNameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableMWD.ComputerNameColumn] = value;
                }
            }

            public string UserName {
                get {
                    try {
                        return ((string)(this[this.tableMWD.UserNameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableMWD.UserNameColumn] = value;
                }
            }

            public string ItemCaption {
                get {
                    try {
                        return ((string)(this[this.tableMWD.ItemCaptionColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableMWD.ItemCaptionColumn] = value;
                }
            }

            public bool IsComputerNameNull() {
                return this.IsNull(this.tableMWD.ComputerNameColumn);
            }

            public void SetComputerNameNull() {
                this[this.tableMWD.ComputerNameColumn] = System.Convert.DBNull;
            }

            public bool IsUserNameNull() {
                return this.IsNull(this.tableMWD.UserNameColumn);
            }

            public void SetUserNameNull() {
                this[this.tableMWD.UserNameColumn] = System.Convert.DBNull;
            }

            public bool IsItemCaptionNull() {
                return this.IsNull(this.tableMWD.ItemCaptionColumn);
            }

            public void SetItemCaptionNull() {
                this[this.tableMWD.ItemCaptionColumn] = System.Convert.DBNull;
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class MWDRowChangeEvent : EventArgs {

            private MWDRow eventRow;

            private DataRowAction eventAction;

            public MWDRowChangeEvent(MWDRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }

            public MWDRow Row {
                get {
                    return this.eventRow;
                }
            }

            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class HotFixDataTable : DataTable, System.Collections.IEnumerable {

            private DataColumn columnBulletinID;

            private DataColumn columnSummary;

            private DataColumn columnProduct;

            private DataColumn columnProductID;

            private DataColumn columnPatchLocation;

            internal HotFixDataTable() :
                    base("HotFix") {
                this.InitClass();
            }

            internal HotFixDataTable(DataTable table) :
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }

            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }

            internal DataColumn BulletinIDColumn {
                get {
                    return this.columnBulletinID;
                }
            }

            internal DataColumn SummaryColumn {
                get {
                    return this.columnSummary;
                }
            }

            internal DataColumn ProductColumn {
                get {
                    return this.columnProduct;
                }
            }

            internal DataColumn ProductIDColumn {
                get {
                    return this.columnProductID;
                }
            }

            internal DataColumn PatchLocationColumn {
                get {
                    return this.columnPatchLocation;
                }
            }

            public HotFixRow this[int index] {
                get {
                    return ((HotFixRow)(this.Rows[index]));
                }
            }

            public event HotFixRowChangeEventHandler HotFixRowChanged;

            public event HotFixRowChangeEventHandler HotFixRowChanging;

            public event HotFixRowChangeEventHandler HotFixRowDeleted;

            public event HotFixRowChangeEventHandler HotFixRowDeleting;

            public void AddHotFixRow(HotFixRow row) {
                this.Rows.Add(row);
            }

            public HotFixRow AddHotFixRow(string BulletinID, string Summary, string Product, string ProductID, string PatchLocation) {
                HotFixRow rowHotFixRow = ((HotFixRow)(this.NewRow()));
                rowHotFixRow.ItemArray = new object[] {
                        BulletinID,
                        Summary,
                        Product,
                        ProductID,
                        PatchLocation};
                this.Rows.Add(rowHotFixRow);
                return rowHotFixRow;
            }

            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }

            public override DataTable Clone() {
                HotFixDataTable cln = ((HotFixDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }

            protected override DataTable CreateInstance() {
                return new HotFixDataTable();
            }

            internal void InitVars() {
                this.columnBulletinID = this.Columns["BulletinID"];
                this.columnSummary = this.Columns["Summary"];
                this.columnProduct = this.Columns["Product"];
                this.columnProductID = this.Columns["ProductID"];
                this.columnPatchLocation = this.Columns["PatchLocation"];
            }

            private void InitClass() {
                this.columnBulletinID = new DataColumn("BulletinID", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnBulletinID);
                this.columnSummary = new DataColumn("Summary", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnSummary);
                this.columnProduct = new DataColumn("Product", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnProduct);
                this.columnProductID = new DataColumn("ProductID", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnProductID);
                this.columnPatchLocation = new DataColumn("PatchLocation", typeof(string), null, System.Data.MappingType.Element);
                this.Columns.Add(this.columnPatchLocation);
            }

            public HotFixRow NewHotFixRow() {
                return ((HotFixRow)(this.NewRow()));
            }

            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new HotFixRow(builder);
            }

            protected override System.Type GetRowType() {
                return typeof(HotFixRow);
            }

            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.HotFixRowChanged != null)) {
                    this.HotFixRowChanged(this, new HotFixRowChangeEvent(((HotFixRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.HotFixRowChanging != null)) {
                    this.HotFixRowChanging(this, new HotFixRowChangeEvent(((HotFixRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.HotFixRowDeleted != null)) {
                    this.HotFixRowDeleted(this, new HotFixRowChangeEvent(((HotFixRow)(e.Row)), e.Action));
                }
            }

            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.HotFixRowDeleting != null)) {
                    this.HotFixRowDeleting(this, new HotFixRowChangeEvent(((HotFixRow)(e.Row)), e.Action));
                }
            }

            public void RemoveHotFixRow(HotFixRow row) {
                this.Rows.Remove(row);
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class HotFixRow : DataRow {

            private HotFixDataTable tableHotFix;

            internal HotFixRow(DataRowBuilder rb) :
                    base(rb) {
                this.tableHotFix = ((HotFixDataTable)(this.Table));
            }

            public string BulletinID {
                get {
                    try {
                        return ((string)(this[this.tableHotFix.BulletinIDColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHotFix.BulletinIDColumn] = value;
                }
            }

            public string Summary {
                get {
                    try {
                        return ((string)(this[this.tableHotFix.SummaryColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHotFix.SummaryColumn] = value;
                }
            }

            public string Product {
                get {
                    try {
                        return ((string)(this[this.tableHotFix.ProductColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHotFix.ProductColumn] = value;
                }
            }

            public string ProductID {
                get {
                    try {
                        return ((string)(this[this.tableHotFix.ProductIDColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHotFix.ProductIDColumn] = value;
                }
            }

            public string PatchLocation {
                get {
                    try {
                        return ((string)(this[this.tableHotFix.PatchLocationColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableHotFix.PatchLocationColumn] = value;
                }
            }

            public bool IsBulletinIDNull() {
                return this.IsNull(this.tableHotFix.BulletinIDColumn);
            }

            public void SetBulletinIDNull() {
                this[this.tableHotFix.BulletinIDColumn] = System.Convert.DBNull;
            }

            public bool IsSummaryNull() {
                return this.IsNull(this.tableHotFix.SummaryColumn);
            }

            public void SetSummaryNull() {
                this[this.tableHotFix.SummaryColumn] = System.Convert.DBNull;
            }

            public bool IsProductNull() {
                return this.IsNull(this.tableHotFix.ProductColumn);
            }

            public void SetProductNull() {
                this[this.tableHotFix.ProductColumn] = System.Convert.DBNull;
            }

            public bool IsProductIDNull() {
                return this.IsNull(this.tableHotFix.ProductIDColumn);
            }

            public void SetProductIDNull() {
                this[this.tableHotFix.ProductIDColumn] = System.Convert.DBNull;
            }

            public bool IsPatchLocationNull() {
                return this.IsNull(this.tableHotFix.PatchLocationColumn);
            }

            public void SetPatchLocationNull() {
                this[this.tableHotFix.PatchLocationColumn] = System.Convert.DBNull;
            }
        }

        [System.Diagnostics.DebuggerStepThrough()]
        public class HotFixRowChangeEvent : EventArgs {

            private HotFixRow eventRow;

            private DataRowAction eventAction;

            public HotFixRowChangeEvent(HotFixRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }

            public HotFixRow Row {
                get {
                    return this.eventRow;
                }
            }

            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
    }
}