using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.Runtime.Serialization;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;

namespace SunRoxm.BizPeri.ReportDataSet.ReportDataSet
{
	[Serializable]
	[XmlRoot("dsUIFrmSalesMonthByPrincipal")]
	[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
	[XmlSchemaProvider("GetTypedDataSetSchema")]
	[HelpKeyword("vs.data.DataSet")]
	[DesignerCategory("code")]
	[ToolboxItem(true)]
	public class dsUIFrmSalesMonthByPrincipal : DataSet
	{
		public delegate void UIRowChangeEventHandler(object sender, UIRowChangeEvent e);

		public delegate void FrmSalesMonthByPrincipalRowChangeEventHandler(object sender, FrmSalesMonthByPrincipalRowChangeEvent e);

		[Serializable]
		[XmlSchemaProvider("GetTypedTableSchema")]
		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class UIDataTable : DataTable, IEnumerable
		{
			private DataColumn columnStartDate_SaleBill;

			private DataColumn columnEndDate_SaleBill;

			private DataColumn columnStartNo_SaleBill;

			private DataColumn columnEndNo_SaleBill;

			private DataColumn columnStartNo_Customer;

			private DataColumn columnEndNo_Customer;

			private DataColumn columnStartPrincipal_SaleBill;

			private DataColumn columnEndPrincipal_SaleBill;

			private DataColumn columnStartName_Location;

			private DataColumn columnEndName_Location;

			private DataColumn columnName_Creator;

			private DataColumn columnCreateDate;

			[DebuggerNonUserCode]
			public DataColumn StartDate_SaleBillColumn => columnStartDate_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn EndDate_SaleBillColumn => columnEndDate_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn StartNo_SaleBillColumn => columnStartNo_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn EndNo_SaleBillColumn => columnEndNo_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn StartNo_CustomerColumn => columnStartNo_Customer;

			[DebuggerNonUserCode]
			public DataColumn EndNo_CustomerColumn => columnEndNo_Customer;

			[DebuggerNonUserCode]
			public DataColumn StartPrincipal_SaleBillColumn => columnStartPrincipal_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn EndPrincipal_SaleBillColumn => columnEndPrincipal_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn StartName_LocationColumn => columnStartName_Location;

			[DebuggerNonUserCode]
			public DataColumn EndName_LocationColumn => columnEndName_Location;

			[DebuggerNonUserCode]
			public DataColumn Name_CreatorColumn => columnName_Creator;

			[DebuggerNonUserCode]
			public DataColumn CreateDateColumn => columnCreateDate;

			[DebuggerNonUserCode]
			[Browsable(false)]
			public int Count => base.Rows.Count;

			[DebuggerNonUserCode]
			public UIRow this[int index] => (UIRow)base.Rows[index];

			public event UIRowChangeEventHandler UIRowChanging;

			public event UIRowChangeEventHandler UIRowChanged;

			public event UIRowChangeEventHandler UIRowDeleting;

			public event UIRowChangeEventHandler UIRowDeleted;

			[DebuggerNonUserCode]
			public UIDataTable()
			{
				base.TableName = "UI";
				BeginInit();
				InitClass();
				EndInit();
			}

			[DebuggerNonUserCode]
			internal UIDataTable(DataTable table)
			{
				base.TableName = table.TableName;
				if (table.CaseSensitive != table.DataSet.CaseSensitive)
				{
					base.CaseSensitive = table.CaseSensitive;
				}
				if (table.Locale.ToString() != table.DataSet.Locale.ToString())
				{
					base.Locale = table.Locale;
				}
				if (table.Namespace != table.DataSet.Namespace)
				{
					base.Namespace = table.Namespace;
				}
				base.Prefix = table.Prefix;
				base.MinimumCapacity = table.MinimumCapacity;
			}

			[DebuggerNonUserCode]
			protected UIDataTable(SerializationInfo info, StreamingContext context)
				: base(info, context)
			{
				InitVars();
			}

			[DebuggerNonUserCode]
			public void AddUIRow(UIRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public UIRow AddUIRow(DateTime StartDate_SaleBill, DateTime EndDate_SaleBill, string StartNo_SaleBill, string EndNo_SaleBill, string StartNo_Customer, string EndNo_Customer, string StartPrincipal_SaleBill, string EndPrincipal_SaleBill, string StartName_Location, string EndName_Location, string Name_Creator, DateTime CreateDate)
			{
				UIRow uIRow = (UIRow)NewRow();
				uIRow.ItemArray = new object[12]
				{
					StartDate_SaleBill,
					EndDate_SaleBill,
					StartNo_SaleBill,
					EndNo_SaleBill,
					StartNo_Customer,
					EndNo_Customer,
					StartPrincipal_SaleBill,
					EndPrincipal_SaleBill,
					StartName_Location,
					EndName_Location,
					Name_Creator,
					CreateDate
				};
				base.Rows.Add(uIRow);
				return uIRow;
			}

			[DebuggerNonUserCode]
			public virtual IEnumerator GetEnumerator()
			{
				return base.Rows.GetEnumerator();
			}

			[DebuggerNonUserCode]
			public override DataTable Clone()
			{
				UIDataTable uIDataTable = (UIDataTable)base.Clone();
				uIDataTable.InitVars();
				return uIDataTable;
			}

			[DebuggerNonUserCode]
			protected override DataTable CreateInstance()
			{
				return new UIDataTable();
			}

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnStartDate_SaleBill = base.Columns["StartDate_SaleBill"];
				columnEndDate_SaleBill = base.Columns["EndDate_SaleBill"];
				columnStartNo_SaleBill = base.Columns["StartNo_SaleBill"];
				columnEndNo_SaleBill = base.Columns["EndNo_SaleBill"];
				columnStartNo_Customer = base.Columns["StartNo_Customer"];
				columnEndNo_Customer = base.Columns["EndNo_Customer"];
				columnStartPrincipal_SaleBill = base.Columns["StartPrincipal_SaleBill"];
				columnEndPrincipal_SaleBill = base.Columns["EndPrincipal_SaleBill"];
				columnStartName_Location = base.Columns["StartName_Location"];
				columnEndName_Location = base.Columns["EndName_Location"];
				columnName_Creator = base.Columns["Name_Creator"];
				columnCreateDate = base.Columns["CreateDate"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnStartDate_SaleBill = new DataColumn("StartDate_SaleBill", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnStartDate_SaleBill);
				columnEndDate_SaleBill = new DataColumn("EndDate_SaleBill", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnEndDate_SaleBill);
				columnStartNo_SaleBill = new DataColumn("StartNo_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnStartNo_SaleBill);
				columnEndNo_SaleBill = new DataColumn("EndNo_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnEndNo_SaleBill);
				columnStartNo_Customer = new DataColumn("StartNo_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnStartNo_Customer);
				columnEndNo_Customer = new DataColumn("EndNo_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnEndNo_Customer);
				columnStartPrincipal_SaleBill = new DataColumn("StartPrincipal_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnStartPrincipal_SaleBill);
				columnEndPrincipal_SaleBill = new DataColumn("EndPrincipal_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnEndPrincipal_SaleBill);
				columnStartName_Location = new DataColumn("StartName_Location", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnStartName_Location);
				columnEndName_Location = new DataColumn("EndName_Location", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnEndName_Location);
				columnName_Creator = new DataColumn("Name_Creator", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Creator);
				columnCreateDate = new DataColumn("CreateDate", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnCreateDate);
			}

			[DebuggerNonUserCode]
			public UIRow NewUIRow()
			{
				return (UIRow)NewRow();
			}

			[DebuggerNonUserCode]
			protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
			{
				return new UIRow(builder);
			}

			[DebuggerNonUserCode]
			protected override Type GetRowType()
			{
				return typeof(UIRow);
			}

			[DebuggerNonUserCode]
			protected override void OnRowChanged(DataRowChangeEventArgs e)
			{
				base.OnRowChanged(e);
				if (this.UIRowChanged != null)
				{
					this.UIRowChanged(this, new UIRowChangeEvent((UIRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			protected override void OnRowChanging(DataRowChangeEventArgs e)
			{
				base.OnRowChanging(e);
				if (this.UIRowChanging != null)
				{
					this.UIRowChanging(this, new UIRowChangeEvent((UIRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			protected override void OnRowDeleted(DataRowChangeEventArgs e)
			{
				base.OnRowDeleted(e);
				if (this.UIRowDeleted != null)
				{
					this.UIRowDeleted(this, new UIRowChangeEvent((UIRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			protected override void OnRowDeleting(DataRowChangeEventArgs e)
			{
				base.OnRowDeleting(e);
				if (this.UIRowDeleting != null)
				{
					this.UIRowDeleting(this, new UIRowChangeEvent((UIRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			public void RemoveUIRow(UIRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsUIFrmSalesMonthByPrincipal dsUIFrmSalesMonthByPrincipal = new dsUIFrmSalesMonthByPrincipal();
				xs.Add(dsUIFrmSalesMonthByPrincipal.GetSchemaSerializable());
				XmlSchemaAny xmlSchemaAny = new XmlSchemaAny();
				xmlSchemaAny.Namespace = "http://www.w3.org/2001/XMLSchema";
				xmlSchemaAny.MinOccurs = 0m;
				xmlSchemaAny.MaxOccurs = decimal.MaxValue;
				xmlSchemaAny.ProcessContents = XmlSchemaContentProcessing.Lax;
				xmlSchemaSequence.Items.Add(xmlSchemaAny);
				XmlSchemaAny xmlSchemaAny2 = new XmlSchemaAny();
				xmlSchemaAny2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
				xmlSchemaAny2.MinOccurs = 1m;
				xmlSchemaAny2.ProcessContents = XmlSchemaContentProcessing.Lax;
				xmlSchemaSequence.Items.Add(xmlSchemaAny2);
				XmlSchemaAttribute xmlSchemaAttribute = new XmlSchemaAttribute();
				xmlSchemaAttribute.Name = "namespace";
				xmlSchemaAttribute.FixedValue = dsUIFrmSalesMonthByPrincipal.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "UIDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				return xmlSchemaComplexType;
			}
		}

		[Serializable]
		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		[XmlSchemaProvider("GetTypedTableSchema")]
		public class FrmSalesMonthByPrincipalDataTable : DataTable, IEnumerable
		{
			private DataColumn columnPrincipal_SaleBill;

			private DataColumn columnType;

			private DataColumn columnNo_SaleBill;

			private DataColumn columnShortName_Customer;

			private DataColumn columnName_Location;

			private DataColumn columnCurrency_SaleBill;

			private DataColumn columnGoodsAmount_SaleBill;

			private DataColumn columnAmount_SaleBill;

			private DataColumn columnTaxAmount_SaleBill;

			private DataColumn columnTaxCurrency_SaleBill;

			private DataColumn columnDate_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn Principal_SaleBillColumn => columnPrincipal_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn TypeColumn => columnType;

			[DebuggerNonUserCode]
			public DataColumn No_SaleBillColumn => columnNo_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn ShortName_CustomerColumn => columnShortName_Customer;

			[DebuggerNonUserCode]
			public DataColumn Name_LocationColumn => columnName_Location;

			[DebuggerNonUserCode]
			public DataColumn Currency_SaleBillColumn => columnCurrency_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn GoodsAmount_SaleBillColumn => columnGoodsAmount_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn Amount_SaleBillColumn => columnAmount_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn TaxAmount_SaleBillColumn => columnTaxAmount_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn TaxCurrency_SaleBillColumn => columnTaxCurrency_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn Date_SaleBillColumn => columnDate_SaleBill;

			[Browsable(false)]
			[DebuggerNonUserCode]
			public int Count => base.Rows.Count;

			[DebuggerNonUserCode]
			public FrmSalesMonthByPrincipalRow this[int index] => (FrmSalesMonthByPrincipalRow)base.Rows[index];

			public event FrmSalesMonthByPrincipalRowChangeEventHandler FrmSalesMonthByPrincipalRowChanging;

			public event FrmSalesMonthByPrincipalRowChangeEventHandler FrmSalesMonthByPrincipalRowChanged;

			public event FrmSalesMonthByPrincipalRowChangeEventHandler FrmSalesMonthByPrincipalRowDeleting;

			public event FrmSalesMonthByPrincipalRowChangeEventHandler FrmSalesMonthByPrincipalRowDeleted;

			[DebuggerNonUserCode]
			public FrmSalesMonthByPrincipalDataTable()
			{
				base.TableName = "FrmSalesMonthByPrincipal";
				BeginInit();
				InitClass();
				EndInit();
			}

			[DebuggerNonUserCode]
			internal FrmSalesMonthByPrincipalDataTable(DataTable table)
			{
				base.TableName = table.TableName;
				if (table.CaseSensitive != table.DataSet.CaseSensitive)
				{
					base.CaseSensitive = table.CaseSensitive;
				}
				if (table.Locale.ToString() != table.DataSet.Locale.ToString())
				{
					base.Locale = table.Locale;
				}
				if (table.Namespace != table.DataSet.Namespace)
				{
					base.Namespace = table.Namespace;
				}
				base.Prefix = table.Prefix;
				base.MinimumCapacity = table.MinimumCapacity;
			}

			[DebuggerNonUserCode]
			protected FrmSalesMonthByPrincipalDataTable(SerializationInfo info, StreamingContext context)
				: base(info, context)
			{
				InitVars();
			}

			[DebuggerNonUserCode]
			public void AddFrmSalesMonthByPrincipalRow(FrmSalesMonthByPrincipalRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public FrmSalesMonthByPrincipalRow AddFrmSalesMonthByPrincipalRow(string Principal_SaleBill, string Type, string No_SaleBill, string ShortName_Customer, string Name_Location, string Currency_SaleBill, decimal GoodsAmount_SaleBill, decimal Amount_SaleBill, decimal TaxAmount_SaleBill, string TaxCurrency_SaleBill, DateTime Date_SaleBill)
			{
				FrmSalesMonthByPrincipalRow frmSalesMonthByPrincipalRow = (FrmSalesMonthByPrincipalRow)NewRow();
				frmSalesMonthByPrincipalRow.ItemArray = new object[11]
				{
					Principal_SaleBill,
					Type,
					No_SaleBill,
					ShortName_Customer,
					Name_Location,
					Currency_SaleBill,
					GoodsAmount_SaleBill,
					Amount_SaleBill,
					TaxAmount_SaleBill,
					TaxCurrency_SaleBill,
					Date_SaleBill
				};
				base.Rows.Add(frmSalesMonthByPrincipalRow);
				return frmSalesMonthByPrincipalRow;
			}

			[DebuggerNonUserCode]
			public virtual IEnumerator GetEnumerator()
			{
				return base.Rows.GetEnumerator();
			}

			[DebuggerNonUserCode]
			public override DataTable Clone()
			{
				FrmSalesMonthByPrincipalDataTable frmSalesMonthByPrincipalDataTable = (FrmSalesMonthByPrincipalDataTable)base.Clone();
				frmSalesMonthByPrincipalDataTable.InitVars();
				return frmSalesMonthByPrincipalDataTable;
			}

			[DebuggerNonUserCode]
			protected override DataTable CreateInstance()
			{
				return new FrmSalesMonthByPrincipalDataTable();
			}

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnPrincipal_SaleBill = base.Columns["Principal_SaleBill"];
				columnType = base.Columns["Type"];
				columnNo_SaleBill = base.Columns["No_SaleBill"];
				columnShortName_Customer = base.Columns["ShortName_Customer"];
				columnName_Location = base.Columns["Name_Location"];
				columnCurrency_SaleBill = base.Columns["Currency_SaleBill"];
				columnGoodsAmount_SaleBill = base.Columns["GoodsAmount_SaleBill"];
				columnAmount_SaleBill = base.Columns["Amount_SaleBill"];
				columnTaxAmount_SaleBill = base.Columns["TaxAmount_SaleBill"];
				columnTaxCurrency_SaleBill = base.Columns["TaxCurrency_SaleBill"];
				columnDate_SaleBill = base.Columns["Date_SaleBill"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnPrincipal_SaleBill = new DataColumn("Principal_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnPrincipal_SaleBill);
				columnType = new DataColumn("Type", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnType);
				columnNo_SaleBill = new DataColumn("No_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_SaleBill);
				columnShortName_Customer = new DataColumn("ShortName_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnShortName_Customer);
				columnName_Location = new DataColumn("Name_Location", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Location);
				columnCurrency_SaleBill = new DataColumn("Currency_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnCurrency_SaleBill);
				columnGoodsAmount_SaleBill = new DataColumn("GoodsAmount_SaleBill", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnGoodsAmount_SaleBill);
				columnAmount_SaleBill = new DataColumn("Amount_SaleBill", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnAmount_SaleBill);
				columnTaxAmount_SaleBill = new DataColumn("TaxAmount_SaleBill", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnTaxAmount_SaleBill);
				columnTaxCurrency_SaleBill = new DataColumn("TaxCurrency_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnTaxCurrency_SaleBill);
				columnDate_SaleBill = new DataColumn("Date_SaleBill", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnDate_SaleBill);
			}

			[DebuggerNonUserCode]
			public FrmSalesMonthByPrincipalRow NewFrmSalesMonthByPrincipalRow()
			{
				return (FrmSalesMonthByPrincipalRow)NewRow();
			}

			[DebuggerNonUserCode]
			protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
			{
				return new FrmSalesMonthByPrincipalRow(builder);
			}

			[DebuggerNonUserCode]
			protected override Type GetRowType()
			{
				return typeof(FrmSalesMonthByPrincipalRow);
			}

			[DebuggerNonUserCode]
			protected override void OnRowChanged(DataRowChangeEventArgs e)
			{
				base.OnRowChanged(e);
				if (this.FrmSalesMonthByPrincipalRowChanged != null)
				{
					this.FrmSalesMonthByPrincipalRowChanged(this, new FrmSalesMonthByPrincipalRowChangeEvent((FrmSalesMonthByPrincipalRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			protected override void OnRowChanging(DataRowChangeEventArgs e)
			{
				base.OnRowChanging(e);
				if (this.FrmSalesMonthByPrincipalRowChanging != null)
				{
					this.FrmSalesMonthByPrincipalRowChanging(this, new FrmSalesMonthByPrincipalRowChangeEvent((FrmSalesMonthByPrincipalRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			protected override void OnRowDeleted(DataRowChangeEventArgs e)
			{
				base.OnRowDeleted(e);
				if (this.FrmSalesMonthByPrincipalRowDeleted != null)
				{
					this.FrmSalesMonthByPrincipalRowDeleted(this, new FrmSalesMonthByPrincipalRowChangeEvent((FrmSalesMonthByPrincipalRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			protected override void OnRowDeleting(DataRowChangeEventArgs e)
			{
				base.OnRowDeleting(e);
				if (this.FrmSalesMonthByPrincipalRowDeleting != null)
				{
					this.FrmSalesMonthByPrincipalRowDeleting(this, new FrmSalesMonthByPrincipalRowChangeEvent((FrmSalesMonthByPrincipalRow)e.Row, e.Action));
				}
			}

			[DebuggerNonUserCode]
			public void RemoveFrmSalesMonthByPrincipalRow(FrmSalesMonthByPrincipalRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsUIFrmSalesMonthByPrincipal dsUIFrmSalesMonthByPrincipal = new dsUIFrmSalesMonthByPrincipal();
				xs.Add(dsUIFrmSalesMonthByPrincipal.GetSchemaSerializable());
				XmlSchemaAny xmlSchemaAny = new XmlSchemaAny();
				xmlSchemaAny.Namespace = "http://www.w3.org/2001/XMLSchema";
				xmlSchemaAny.MinOccurs = 0m;
				xmlSchemaAny.MaxOccurs = decimal.MaxValue;
				xmlSchemaAny.ProcessContents = XmlSchemaContentProcessing.Lax;
				xmlSchemaSequence.Items.Add(xmlSchemaAny);
				XmlSchemaAny xmlSchemaAny2 = new XmlSchemaAny();
				xmlSchemaAny2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
				xmlSchemaAny2.MinOccurs = 1m;
				xmlSchemaAny2.ProcessContents = XmlSchemaContentProcessing.Lax;
				xmlSchemaSequence.Items.Add(xmlSchemaAny2);
				XmlSchemaAttribute xmlSchemaAttribute = new XmlSchemaAttribute();
				xmlSchemaAttribute.Name = "namespace";
				xmlSchemaAttribute.FixedValue = dsUIFrmSalesMonthByPrincipal.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "FrmSalesMonthByPrincipalDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				return xmlSchemaComplexType;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class UIRow : DataRow
		{
			private UIDataTable tableUI;

			[DebuggerNonUserCode]
			public DateTime StartDate_SaleBill
			{
				get
				{
					try
					{
						return (DateTime)base[tableUI.StartDate_SaleBillColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'StartDate_SaleBill' in table 'UI' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableUI.StartDate_SaleBillColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public DateTime EndDate_SaleBill
			{
				get
				{
					try
					{
						return (DateTime)base[tableUI.EndDate_SaleBillColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'EndDate_SaleBill' in table 'UI' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableUI.EndDate_SaleBillColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string StartNo_SaleBill
			{
				get
				{
					try
					{
						return (string)base[tableUI.StartNo_SaleBillColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'StartNo_SaleBill' in table 'UI' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableUI.StartNo_SaleBillColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string EndNo_SaleBill
			{
				get
				{
					try
					{
						return (string)base[tableUI.EndNo_SaleBillColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'EndNo_SaleBill' in table 'UI' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableUI.EndNo_SaleBillColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string StartNo_Customer
			{
				get
				{
					try
					{
						return (string)base[tableUI.StartNo_CustomerColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'StartNo_Customer' in table 'UI' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableUI.StartNo_CustomerColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string EndNo_Customer
			{
				get
				{
					try
					{
						return (string)base[tableUI.EndNo_CustomerColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'EndNo_Customer' in table 'UI' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableUI.EndNo_CustomerColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string StartPrincipal_SaleBill
			{
				get
				{
					try
					{
						return (string)base[tableUI.StartPrincipal_SaleBillColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'StartPrincipal_SaleBill' in table 'UI' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableUI.StartPrincipal_SaleBillColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string EndPrincipal_SaleBill
			{
				get
				{
					try
					{
						return (string)base[tableUI.EndPrincipal_SaleBillColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'EndPrincipal_SaleBill' in table 'UI' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableUI.EndPrincipal_SaleBillColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string StartName_Location
			{
				get
				{
					try
					{
						return (string)base[tableUI.StartName_LocationColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'StartName_Location' in table 'UI' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableUI.StartName_LocationColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string EndName_Location
			{
				get
				{
					try
					{
						return (string)base[tableUI.EndName_LocationColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'EndName_Location' in table 'UI' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableUI.EndName_LocationColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string Name_Creator
			{
				get
				{
					try
					{
						return (string)base[tableUI.Name_CreatorColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Name_Creator' in table 'UI' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableUI.Name_CreatorColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public DateTime CreateDate
			{
				get
				{
					try
					{
						return (DateTime)base[tableUI.CreateDateColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'CreateDate' in table 'UI' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableUI.CreateDateColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			internal UIRow(DataRowBuilder rb)
				: base(rb)
			{
				tableUI = (UIDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsStartDate_SaleBillNull()
			{
				return IsNull(tableUI.StartDate_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetStartDate_SaleBillNull()
			{
				base[tableUI.StartDate_SaleBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEndDate_SaleBillNull()
			{
				return IsNull(tableUI.EndDate_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetEndDate_SaleBillNull()
			{
				base[tableUI.EndDate_SaleBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsStartNo_SaleBillNull()
			{
				return IsNull(tableUI.StartNo_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetStartNo_SaleBillNull()
			{
				base[tableUI.StartNo_SaleBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEndNo_SaleBillNull()
			{
				return IsNull(tableUI.EndNo_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetEndNo_SaleBillNull()
			{
				base[tableUI.EndNo_SaleBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsStartNo_CustomerNull()
			{
				return IsNull(tableUI.StartNo_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetStartNo_CustomerNull()
			{
				base[tableUI.StartNo_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEndNo_CustomerNull()
			{
				return IsNull(tableUI.EndNo_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetEndNo_CustomerNull()
			{
				base[tableUI.EndNo_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsStartPrincipal_SaleBillNull()
			{
				return IsNull(tableUI.StartPrincipal_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetStartPrincipal_SaleBillNull()
			{
				base[tableUI.StartPrincipal_SaleBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEndPrincipal_SaleBillNull()
			{
				return IsNull(tableUI.EndPrincipal_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetEndPrincipal_SaleBillNull()
			{
				base[tableUI.EndPrincipal_SaleBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsStartName_LocationNull()
			{
				return IsNull(tableUI.StartName_LocationColumn);
			}

			[DebuggerNonUserCode]
			public void SetStartName_LocationNull()
			{
				base[tableUI.StartName_LocationColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEndName_LocationNull()
			{
				return IsNull(tableUI.EndName_LocationColumn);
			}

			[DebuggerNonUserCode]
			public void SetEndName_LocationNull()
			{
				base[tableUI.EndName_LocationColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsName_CreatorNull()
			{
				return IsNull(tableUI.Name_CreatorColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_CreatorNull()
			{
				base[tableUI.Name_CreatorColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCreateDateNull()
			{
				return IsNull(tableUI.CreateDateColumn);
			}

			[DebuggerNonUserCode]
			public void SetCreateDateNull()
			{
				base[tableUI.CreateDateColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class FrmSalesMonthByPrincipalRow : DataRow
		{
			private FrmSalesMonthByPrincipalDataTable tableFrmSalesMonthByPrincipal;

			[DebuggerNonUserCode]
			public string Principal_SaleBill
			{
				get
				{
					try
					{
						return (string)base[tableFrmSalesMonthByPrincipal.Principal_SaleBillColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Principal_SaleBill' in table 'FrmSalesMonthByPrincipal' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableFrmSalesMonthByPrincipal.Principal_SaleBillColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string Type
			{
				get
				{
					try
					{
						return (string)base[tableFrmSalesMonthByPrincipal.TypeColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Type' in table 'FrmSalesMonthByPrincipal' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableFrmSalesMonthByPrincipal.TypeColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string No_SaleBill
			{
				get
				{
					try
					{
						return (string)base[tableFrmSalesMonthByPrincipal.No_SaleBillColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'No_SaleBill' in table 'FrmSalesMonthByPrincipal' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableFrmSalesMonthByPrincipal.No_SaleBillColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string ShortName_Customer
			{
				get
				{
					try
					{
						return (string)base[tableFrmSalesMonthByPrincipal.ShortName_CustomerColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'ShortName_Customer' in table 'FrmSalesMonthByPrincipal' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableFrmSalesMonthByPrincipal.ShortName_CustomerColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string Name_Location
			{
				get
				{
					try
					{
						return (string)base[tableFrmSalesMonthByPrincipal.Name_LocationColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Name_Location' in table 'FrmSalesMonthByPrincipal' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableFrmSalesMonthByPrincipal.Name_LocationColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string Currency_SaleBill
			{
				get
				{
					try
					{
						return (string)base[tableFrmSalesMonthByPrincipal.Currency_SaleBillColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Currency_SaleBill' in table 'FrmSalesMonthByPrincipal' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableFrmSalesMonthByPrincipal.Currency_SaleBillColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal GoodsAmount_SaleBill
			{
				get
				{
					try
					{
						return (decimal)base[tableFrmSalesMonthByPrincipal.GoodsAmount_SaleBillColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'GoodsAmount_SaleBill' in table 'FrmSalesMonthByPrincipal' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableFrmSalesMonthByPrincipal.GoodsAmount_SaleBillColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal Amount_SaleBill
			{
				get
				{
					try
					{
						return (decimal)base[tableFrmSalesMonthByPrincipal.Amount_SaleBillColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Amount_SaleBill' in table 'FrmSalesMonthByPrincipal' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableFrmSalesMonthByPrincipal.Amount_SaleBillColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public decimal TaxAmount_SaleBill
			{
				get
				{
					try
					{
						return (decimal)base[tableFrmSalesMonthByPrincipal.TaxAmount_SaleBillColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'TaxAmount_SaleBill' in table 'FrmSalesMonthByPrincipal' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableFrmSalesMonthByPrincipal.TaxAmount_SaleBillColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string TaxCurrency_SaleBill
			{
				get
				{
					try
					{
						return (string)base[tableFrmSalesMonthByPrincipal.TaxCurrency_SaleBillColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'TaxCurrency_SaleBill' in table 'FrmSalesMonthByPrincipal' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableFrmSalesMonthByPrincipal.TaxCurrency_SaleBillColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public DateTime Date_SaleBill
			{
				get
				{
					try
					{
						return (DateTime)base[tableFrmSalesMonthByPrincipal.Date_SaleBillColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Date_SaleBill' in table 'FrmSalesMonthByPrincipal' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableFrmSalesMonthByPrincipal.Date_SaleBillColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			internal FrmSalesMonthByPrincipalRow(DataRowBuilder rb)
				: base(rb)
			{
				tableFrmSalesMonthByPrincipal = (FrmSalesMonthByPrincipalDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsPrincipal_SaleBillNull()
			{
				return IsNull(tableFrmSalesMonthByPrincipal.Principal_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetPrincipal_SaleBillNull()
			{
				base[tableFrmSalesMonthByPrincipal.Principal_SaleBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTypeNull()
			{
				return IsNull(tableFrmSalesMonthByPrincipal.TypeColumn);
			}

			[DebuggerNonUserCode]
			public void SetTypeNull()
			{
				base[tableFrmSalesMonthByPrincipal.TypeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsNo_SaleBillNull()
			{
				return IsNull(tableFrmSalesMonthByPrincipal.No_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_SaleBillNull()
			{
				base[tableFrmSalesMonthByPrincipal.No_SaleBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsShortName_CustomerNull()
			{
				return IsNull(tableFrmSalesMonthByPrincipal.ShortName_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetShortName_CustomerNull()
			{
				base[tableFrmSalesMonthByPrincipal.ShortName_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsName_LocationNull()
			{
				return IsNull(tableFrmSalesMonthByPrincipal.Name_LocationColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_LocationNull()
			{
				base[tableFrmSalesMonthByPrincipal.Name_LocationColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCurrency_SaleBillNull()
			{
				return IsNull(tableFrmSalesMonthByPrincipal.Currency_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetCurrency_SaleBillNull()
			{
				base[tableFrmSalesMonthByPrincipal.Currency_SaleBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsGoodsAmount_SaleBillNull()
			{
				return IsNull(tableFrmSalesMonthByPrincipal.GoodsAmount_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetGoodsAmount_SaleBillNull()
			{
				base[tableFrmSalesMonthByPrincipal.GoodsAmount_SaleBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAmount_SaleBillNull()
			{
				return IsNull(tableFrmSalesMonthByPrincipal.Amount_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetAmount_SaleBillNull()
			{
				base[tableFrmSalesMonthByPrincipal.Amount_SaleBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTaxAmount_SaleBillNull()
			{
				return IsNull(tableFrmSalesMonthByPrincipal.TaxAmount_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetTaxAmount_SaleBillNull()
			{
				base[tableFrmSalesMonthByPrincipal.TaxAmount_SaleBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTaxCurrency_SaleBillNull()
			{
				return IsNull(tableFrmSalesMonthByPrincipal.TaxCurrency_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetTaxCurrency_SaleBillNull()
			{
				base[tableFrmSalesMonthByPrincipal.TaxCurrency_SaleBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsDate_SaleBillNull()
			{
				return IsNull(tableFrmSalesMonthByPrincipal.Date_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetDate_SaleBillNull()
			{
				base[tableFrmSalesMonthByPrincipal.Date_SaleBillColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class UIRowChangeEvent : EventArgs
		{
			private UIRow eventRow;

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public UIRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

			[DebuggerNonUserCode]
			public UIRowChangeEvent(UIRow row, DataRowAction action)
			{
				eventRow = row;
				eventAction = action;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class FrmSalesMonthByPrincipalRowChangeEvent : EventArgs
		{
			private FrmSalesMonthByPrincipalRow eventRow;

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public FrmSalesMonthByPrincipalRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

			[DebuggerNonUserCode]
			public FrmSalesMonthByPrincipalRowChangeEvent(FrmSalesMonthByPrincipalRow row, DataRowAction action)
			{
				eventRow = row;
				eventAction = action;
			}
		}

		private UIDataTable tableUI;

		private FrmSalesMonthByPrincipalDataTable tableFrmSalesMonthByPrincipal;

		private SchemaSerializationMode _schemaSerializationMode = SchemaSerializationMode.IncludeSchema;

		[DebuggerNonUserCode]
		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		public UIDataTable UI => tableUI;

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[Browsable(false)]
		[DebuggerNonUserCode]
		public FrmSalesMonthByPrincipalDataTable FrmSalesMonthByPrincipal => tableFrmSalesMonthByPrincipal;

		[Browsable(true)]
		[DebuggerNonUserCode]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
		public override SchemaSerializationMode SchemaSerializationMode
		{
			get
			{
				return _schemaSerializationMode;
			}
			set
			{
				_schemaSerializationMode = value;
			}
		}

		[DebuggerNonUserCode]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public new DataTableCollection Tables => base.Tables;

		[DebuggerNonUserCode]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public new DataRelationCollection Relations => base.Relations;

		[DebuggerNonUserCode]
		public dsUIFrmSalesMonthByPrincipal()
		{
			BeginInit();
			InitClass();
			CollectionChangeEventHandler value = SchemaChanged;
			base.Tables.CollectionChanged += value;
			base.Relations.CollectionChanged += value;
			EndInit();
		}

		[DebuggerNonUserCode]
		protected dsUIFrmSalesMonthByPrincipal(SerializationInfo info, StreamingContext context)
			: base(info, context, ConstructSchema: false)
		{
			if (IsBinarySerialized(info, context))
			{
				InitVars(initTable: false);
				CollectionChangeEventHandler value = SchemaChanged;
				Tables.CollectionChanged += value;
				Relations.CollectionChanged += value;
				return;
			}
			string s = (string)info.GetValue("XmlSchema", typeof(string));
			if (DetermineSchemaSerializationMode(info, context) == SchemaSerializationMode.IncludeSchema)
			{
				DataSet dataSet = new DataSet();
				dataSet.ReadXmlSchema(new XmlTextReader(new StringReader(s)));
				if (dataSet.Tables["UI"] != null)
				{
					base.Tables.Add(new UIDataTable(dataSet.Tables["UI"]));
				}
				if (dataSet.Tables["FrmSalesMonthByPrincipal"] != null)
				{
					base.Tables.Add(new FrmSalesMonthByPrincipalDataTable(dataSet.Tables["FrmSalesMonthByPrincipal"]));
				}
				base.DataSetName = dataSet.DataSetName;
				base.Prefix = dataSet.Prefix;
				base.Namespace = dataSet.Namespace;
				base.Locale = dataSet.Locale;
				base.CaseSensitive = dataSet.CaseSensitive;
				base.EnforceConstraints = dataSet.EnforceConstraints;
				Merge(dataSet, preserveChanges: false, MissingSchemaAction.Add);
				InitVars();
			}
			else
			{
				ReadXmlSchema(new XmlTextReader(new StringReader(s)));
			}
			GetSerializationData(info, context);
			CollectionChangeEventHandler value2 = SchemaChanged;
			base.Tables.CollectionChanged += value2;
			Relations.CollectionChanged += value2;
		}

		[DebuggerNonUserCode]
		protected override void InitializeDerivedDataSet()
		{
			BeginInit();
			InitClass();
			EndInit();
		}

		[DebuggerNonUserCode]
		public override DataSet Clone()
		{
			dsUIFrmSalesMonthByPrincipal dsUIFrmSalesMonthByPrincipal = (dsUIFrmSalesMonthByPrincipal)base.Clone();
			dsUIFrmSalesMonthByPrincipal.InitVars();
			dsUIFrmSalesMonthByPrincipal.SchemaSerializationMode = SchemaSerializationMode;
			return dsUIFrmSalesMonthByPrincipal;
		}

		[DebuggerNonUserCode]
		protected override bool ShouldSerializeTables()
		{
			return false;
		}

		[DebuggerNonUserCode]
		protected override bool ShouldSerializeRelations()
		{
			return false;
		}

		[DebuggerNonUserCode]
		protected override void ReadXmlSerializable(XmlReader reader)
		{
			if (DetermineSchemaSerializationMode(reader) == SchemaSerializationMode.IncludeSchema)
			{
				Reset();
				DataSet dataSet = new DataSet();
				dataSet.ReadXml(reader);
				if (dataSet.Tables["UI"] != null)
				{
					base.Tables.Add(new UIDataTable(dataSet.Tables["UI"]));
				}
				if (dataSet.Tables["FrmSalesMonthByPrincipal"] != null)
				{
					base.Tables.Add(new FrmSalesMonthByPrincipalDataTable(dataSet.Tables["FrmSalesMonthByPrincipal"]));
				}
				base.DataSetName = dataSet.DataSetName;
				base.Prefix = dataSet.Prefix;
				base.Namespace = dataSet.Namespace;
				base.Locale = dataSet.Locale;
				base.CaseSensitive = dataSet.CaseSensitive;
				base.EnforceConstraints = dataSet.EnforceConstraints;
				Merge(dataSet, preserveChanges: false, MissingSchemaAction.Add);
				InitVars();
			}
			else
			{
				ReadXml(reader);
				InitVars();
			}
		}

		[DebuggerNonUserCode]
		protected override XmlSchema GetSchemaSerializable()
		{
			MemoryStream memoryStream = new MemoryStream();
			WriteXmlSchema(new XmlTextWriter(memoryStream, null));
			memoryStream.Position = 0L;
			return XmlSchema.Read(new XmlTextReader(memoryStream), null);
		}

		[DebuggerNonUserCode]
		internal void InitVars()
		{
			InitVars(initTable: true);
		}

		[DebuggerNonUserCode]
		internal void InitVars(bool initTable)
		{
			tableUI = (UIDataTable)base.Tables["UI"];
			if (initTable && tableUI != null)
			{
				tableUI.InitVars();
			}
			tableFrmSalesMonthByPrincipal = (FrmSalesMonthByPrincipalDataTable)base.Tables["FrmSalesMonthByPrincipal"];
			if (initTable && tableFrmSalesMonthByPrincipal != null)
			{
				tableFrmSalesMonthByPrincipal.InitVars();
			}
		}

		[DebuggerNonUserCode]
		private void InitClass()
		{
			base.DataSetName = "dsUIFrmSalesMonthByPrincipal";
			base.Prefix = "";
			base.Namespace = "http://tempuri.org/dsUIFrmSalesMonthByPrincipal.xsd";
			base.EnforceConstraints = true;
			SchemaSerializationMode = SchemaSerializationMode.IncludeSchema;
			tableUI = new UIDataTable();
			base.Tables.Add(tableUI);
			tableFrmSalesMonthByPrincipal = new FrmSalesMonthByPrincipalDataTable();
			base.Tables.Add(tableFrmSalesMonthByPrincipal);
		}

		[DebuggerNonUserCode]
		private bool ShouldSerializeUI()
		{
			return false;
		}

		[DebuggerNonUserCode]
		private bool ShouldSerializeFrmSalesMonthByPrincipal()
		{
			return false;
		}

		[DebuggerNonUserCode]
		private void SchemaChanged(object sender, CollectionChangeEventArgs e)
		{
			if (e.Action == CollectionChangeAction.Remove)
			{
				InitVars();
			}
		}

		[DebuggerNonUserCode]
		public static XmlSchemaComplexType GetTypedDataSetSchema(XmlSchemaSet xs)
		{
			dsUIFrmSalesMonthByPrincipal dsUIFrmSalesMonthByPrincipal = new dsUIFrmSalesMonthByPrincipal();
			XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
			XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
			xs.Add(dsUIFrmSalesMonthByPrincipal.GetSchemaSerializable());
			XmlSchemaAny xmlSchemaAny = new XmlSchemaAny();
			xmlSchemaAny.Namespace = dsUIFrmSalesMonthByPrincipal.Namespace;
			xmlSchemaSequence.Items.Add(xmlSchemaAny);
			xmlSchemaComplexType.Particle = xmlSchemaSequence;
			return xmlSchemaComplexType;
		}
	}
}