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

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

		public delegate void GetRowChangeEventHandler(object sender, GetRowChangeEvent e);

		public delegate void FrmYearSalesStatisticsRowChangeEventHandler(object sender, FrmYearSalesStatisticsRowChangeEvent e);

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

			private DataColumn columnCurrentUser;

			[DebuggerNonUserCode]
			public DataColumn CurrentCompanyColumn => columnCurrentCompany;

			[DebuggerNonUserCode]
			public DataColumn CurrentUserColumn => columnCurrentUser;

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

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

			public event AppendInfoRowChangeEventHandler AppendInfoRowChanging;

			public event AppendInfoRowChangeEventHandler AppendInfoRowChanged;

			public event AppendInfoRowChangeEventHandler AppendInfoRowDeleting;

			public event AppendInfoRowChangeEventHandler AppendInfoRowDeleted;

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

			[DebuggerNonUserCode]
			internal AppendInfoDataTable(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 AppendInfoDataTable(SerializationInfo info, StreamingContext context)
				: base(info, context)
			{
				InitVars();
			}

			[DebuggerNonUserCode]
			public void AddAppendInfoRow(AppendInfoRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public AppendInfoRow AddAppendInfoRow(string CurrentCompany, string CurrentUser)
			{
				AppendInfoRow appendInfoRow = (AppendInfoRow)NewRow();
				appendInfoRow.ItemArray = new object[2]
				{
					CurrentCompany,
					CurrentUser
				};
				base.Rows.Add(appendInfoRow);
				return appendInfoRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnCurrentCompany = base.Columns["CurrentCompany"];
				columnCurrentUser = base.Columns["CurrentUser"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnCurrentCompany = new DataColumn("CurrentCompany", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnCurrentCompany);
				columnCurrentUser = new DataColumn("CurrentUser", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnCurrentUser);
			}

			[DebuggerNonUserCode]
			public AppendInfoRow NewAppendInfoRow()
			{
				return (AppendInfoRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveAppendInfoRow(AppendInfoRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsFrmYearSalesStatistics dsFrmYearSalesStatistics = new dsFrmYearSalesStatistics();
				xs.Add(dsFrmYearSalesStatistics.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 = dsFrmYearSalesStatistics.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "AppendInfoDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				return xmlSchemaComplexType;
			}
		}

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

			[DebuggerNonUserCode]
			public DataColumn DateTimeColumn => columnDateTime;

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

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

			public event GetRowChangeEventHandler GetRowChanging;

			public event GetRowChangeEventHandler GetRowChanged;

			public event GetRowChangeEventHandler GetRowDeleting;

			public event GetRowChangeEventHandler GetRowDeleted;

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

			[DebuggerNonUserCode]
			internal GetDataTable(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 GetDataTable(SerializationInfo info, StreamingContext context)
				: base(info, context)
			{
				InitVars();
			}

			[DebuggerNonUserCode]
			public void AddGetRow(GetRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public GetRow AddGetRow(DateTime DateTime)
			{
				GetRow getRow = (GetRow)NewRow();
				getRow.ItemArray = new object[1]
				{
					DateTime
				};
				base.Rows.Add(getRow);
				return getRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnDateTime = base.Columns["DateTime"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnDateTime = new DataColumn("DateTime", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnDateTime);
			}

			[DebuggerNonUserCode]
			public GetRow NewGetRow()
			{
				return (GetRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveGetRow(GetRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsFrmYearSalesStatistics dsFrmYearSalesStatistics = new dsFrmYearSalesStatistics();
				xs.Add(dsFrmYearSalesStatistics.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 = dsFrmYearSalesStatistics.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "GetDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				return xmlSchemaComplexType;
			}
		}

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

			private DataColumn columnName_Product;

			private DataColumn columnThreeY_SaleAmount;

			private DataColumn columnTwoY_SaleAmount;

			private DataColumn columnOneY_SaleAmount;

			private DataColumn columnThreeM_SaleAmount;

			private DataColumn columnStockQty_ProductStocks;

			private DataColumn columnNotArrive_Amount;

			private DataColumn columnQuantity_OnShip;

			private DataColumn columnNo_PurchaseOrderBill;

			private DataColumn columnRefNo_PurchaseOrderBill;

			private DataColumn columnComment_PurchaseOrderBillProduct;

			private DataColumn columnPNotArrive_Amount;

			private DataColumn columnPQuantity_OnShip;

			[DebuggerNonUserCode]
			public DataColumn No_ProductColumn => columnNo_Product;

			[DebuggerNonUserCode]
			public DataColumn Name_ProductColumn => columnName_Product;

			[DebuggerNonUserCode]
			public DataColumn ThreeY_SaleAmountColumn => columnThreeY_SaleAmount;

			[DebuggerNonUserCode]
			public DataColumn TwoY_SaleAmountColumn => columnTwoY_SaleAmount;

			[DebuggerNonUserCode]
			public DataColumn OneY_SaleAmountColumn => columnOneY_SaleAmount;

			[DebuggerNonUserCode]
			public DataColumn ThreeM_SaleAmountColumn => columnThreeM_SaleAmount;

			[DebuggerNonUserCode]
			public DataColumn StockQty_ProductStocksColumn => columnStockQty_ProductStocks;

			[DebuggerNonUserCode]
			public DataColumn NotArrive_AmountColumn => columnNotArrive_Amount;

			[DebuggerNonUserCode]
			public DataColumn Quantity_OnShipColumn => columnQuantity_OnShip;

			[DebuggerNonUserCode]
			public DataColumn No_PurchaseOrderBillColumn => columnNo_PurchaseOrderBill;

			[DebuggerNonUserCode]
			public DataColumn RefNo_PurchaseOrderBillColumn => columnRefNo_PurchaseOrderBill;

			[DebuggerNonUserCode]
			public DataColumn Comment_PurchaseOrderBillProductColumn => columnComment_PurchaseOrderBillProduct;

			[DebuggerNonUserCode]
			public DataColumn PNotArrive_AmountColumn => columnPNotArrive_Amount;

			[DebuggerNonUserCode]
			public DataColumn PQuantity_OnShipColumn => columnPQuantity_OnShip;

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

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

			public event FrmYearSalesStatisticsRowChangeEventHandler FrmYearSalesStatisticsRowChanging;

			public event FrmYearSalesStatisticsRowChangeEventHandler FrmYearSalesStatisticsRowChanged;

			public event FrmYearSalesStatisticsRowChangeEventHandler FrmYearSalesStatisticsRowDeleting;

			public event FrmYearSalesStatisticsRowChangeEventHandler FrmYearSalesStatisticsRowDeleted;

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

			[DebuggerNonUserCode]
			internal FrmYearSalesStatisticsDataTable(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 FrmYearSalesStatisticsDataTable(SerializationInfo info, StreamingContext context)
				: base(info, context)
			{
				InitVars();
			}

			[DebuggerNonUserCode]
			public void AddFrmYearSalesStatisticsRow(FrmYearSalesStatisticsRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public FrmYearSalesStatisticsRow AddFrmYearSalesStatisticsRow(string No_Product, string Name_Product, decimal ThreeY_SaleAmount, decimal TwoY_SaleAmount, decimal OneY_SaleAmount, decimal ThreeM_SaleAmount, decimal StockQty_ProductStocks, decimal NotArrive_Amount, decimal Quantity_OnShip, string No_PurchaseOrderBill, string RefNo_PurchaseOrderBill, string Comment_PurchaseOrderBillProduct, decimal PNotArrive_Amount, decimal PQuantity_OnShip)
			{
				FrmYearSalesStatisticsRow frmYearSalesStatisticsRow = (FrmYearSalesStatisticsRow)NewRow();
				frmYearSalesStatisticsRow.ItemArray = new object[14]
				{
					No_Product,
					Name_Product,
					ThreeY_SaleAmount,
					TwoY_SaleAmount,
					OneY_SaleAmount,
					ThreeM_SaleAmount,
					StockQty_ProductStocks,
					NotArrive_Amount,
					Quantity_OnShip,
					No_PurchaseOrderBill,
					RefNo_PurchaseOrderBill,
					Comment_PurchaseOrderBillProduct,
					PNotArrive_Amount,
					PQuantity_OnShip
				};
				base.Rows.Add(frmYearSalesStatisticsRow);
				return frmYearSalesStatisticsRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnNo_Product = base.Columns["No_Product"];
				columnName_Product = base.Columns["Name_Product"];
				columnThreeY_SaleAmount = base.Columns["ThreeY_SaleAmount"];
				columnTwoY_SaleAmount = base.Columns["TwoY_SaleAmount"];
				columnOneY_SaleAmount = base.Columns["OneY_SaleAmount"];
				columnThreeM_SaleAmount = base.Columns["ThreeM_SaleAmount"];
				columnStockQty_ProductStocks = base.Columns["StockQty_ProductStocks"];
				columnNotArrive_Amount = base.Columns["NotArrive_Amount"];
				columnQuantity_OnShip = base.Columns["Quantity_OnShip"];
				columnNo_PurchaseOrderBill = base.Columns["No_PurchaseOrderBill"];
				columnRefNo_PurchaseOrderBill = base.Columns["RefNo_PurchaseOrderBill"];
				columnComment_PurchaseOrderBillProduct = base.Columns["Comment_PurchaseOrderBillProduct"];
				columnPNotArrive_Amount = base.Columns["PNotArrive_Amount"];
				columnPQuantity_OnShip = base.Columns["PQuantity_OnShip"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnNo_Product = new DataColumn("No_Product", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_Product);
				columnName_Product = new DataColumn("Name_Product", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Product);
				columnThreeY_SaleAmount = new DataColumn("ThreeY_SaleAmount", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnThreeY_SaleAmount);
				columnTwoY_SaleAmount = new DataColumn("TwoY_SaleAmount", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnTwoY_SaleAmount);
				columnOneY_SaleAmount = new DataColumn("OneY_SaleAmount", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnOneY_SaleAmount);
				columnThreeM_SaleAmount = new DataColumn("ThreeM_SaleAmount", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnThreeM_SaleAmount);
				columnStockQty_ProductStocks = new DataColumn("StockQty_ProductStocks", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnStockQty_ProductStocks);
				columnNotArrive_Amount = new DataColumn("NotArrive_Amount", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnNotArrive_Amount);
				columnQuantity_OnShip = new DataColumn("Quantity_OnShip", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnQuantity_OnShip);
				columnNo_PurchaseOrderBill = new DataColumn("No_PurchaseOrderBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_PurchaseOrderBill);
				columnRefNo_PurchaseOrderBill = new DataColumn("RefNo_PurchaseOrderBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnRefNo_PurchaseOrderBill);
				columnComment_PurchaseOrderBillProduct = new DataColumn("Comment_PurchaseOrderBillProduct", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnComment_PurchaseOrderBillProduct);
				columnPNotArrive_Amount = new DataColumn("PNotArrive_Amount", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnPNotArrive_Amount);
				columnPQuantity_OnShip = new DataColumn("PQuantity_OnShip", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnPQuantity_OnShip);
			}

			[DebuggerNonUserCode]
			public FrmYearSalesStatisticsRow NewFrmYearSalesStatisticsRow()
			{
				return (FrmYearSalesStatisticsRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveFrmYearSalesStatisticsRow(FrmYearSalesStatisticsRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsFrmYearSalesStatistics dsFrmYearSalesStatistics = new dsFrmYearSalesStatistics();
				xs.Add(dsFrmYearSalesStatistics.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 = dsFrmYearSalesStatistics.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "FrmYearSalesStatisticsDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				return xmlSchemaComplexType;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class AppendInfoRow : DataRow
		{
			private AppendInfoDataTable tableAppendInfo;

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

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

			[DebuggerNonUserCode]
			internal AppendInfoRow(DataRowBuilder rb)
				: base(rb)
			{
				tableAppendInfo = (AppendInfoDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsCurrentCompanyNull()
			{
				return IsNull(tableAppendInfo.CurrentCompanyColumn);
			}

			[DebuggerNonUserCode]
			public void SetCurrentCompanyNull()
			{
				base[tableAppendInfo.CurrentCompanyColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCurrentUserNull()
			{
				return IsNull(tableAppendInfo.CurrentUserColumn);
			}

			[DebuggerNonUserCode]
			public void SetCurrentUserNull()
			{
				base[tableAppendInfo.CurrentUserColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class GetRow : DataRow
		{
			private GetDataTable tableGet;

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

			[DebuggerNonUserCode]
			internal GetRow(DataRowBuilder rb)
				: base(rb)
			{
				tableGet = (GetDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsDateTimeNull()
			{
				return IsNull(tableGet.DateTimeColumn);
			}

			[DebuggerNonUserCode]
			public void SetDateTimeNull()
			{
				base[tableGet.DateTimeColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class FrmYearSalesStatisticsRow : DataRow
		{
			private FrmYearSalesStatisticsDataTable tableFrmYearSalesStatistics;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			internal FrmYearSalesStatisticsRow(DataRowBuilder rb)
				: base(rb)
			{
				tableFrmYearSalesStatistics = (FrmYearSalesStatisticsDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsNo_ProductNull()
			{
				return IsNull(tableFrmYearSalesStatistics.No_ProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_ProductNull()
			{
				base[tableFrmYearSalesStatistics.No_ProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsName_ProductNull()
			{
				return IsNull(tableFrmYearSalesStatistics.Name_ProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_ProductNull()
			{
				base[tableFrmYearSalesStatistics.Name_ProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsThreeY_SaleAmountNull()
			{
				return IsNull(tableFrmYearSalesStatistics.ThreeY_SaleAmountColumn);
			}

			[DebuggerNonUserCode]
			public void SetThreeY_SaleAmountNull()
			{
				base[tableFrmYearSalesStatistics.ThreeY_SaleAmountColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTwoY_SaleAmountNull()
			{
				return IsNull(tableFrmYearSalesStatistics.TwoY_SaleAmountColumn);
			}

			[DebuggerNonUserCode]
			public void SetTwoY_SaleAmountNull()
			{
				base[tableFrmYearSalesStatistics.TwoY_SaleAmountColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsOneY_SaleAmountNull()
			{
				return IsNull(tableFrmYearSalesStatistics.OneY_SaleAmountColumn);
			}

			[DebuggerNonUserCode]
			public void SetOneY_SaleAmountNull()
			{
				base[tableFrmYearSalesStatistics.OneY_SaleAmountColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsThreeM_SaleAmountNull()
			{
				return IsNull(tableFrmYearSalesStatistics.ThreeM_SaleAmountColumn);
			}

			[DebuggerNonUserCode]
			public void SetThreeM_SaleAmountNull()
			{
				base[tableFrmYearSalesStatistics.ThreeM_SaleAmountColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsStockQty_ProductStocksNull()
			{
				return IsNull(tableFrmYearSalesStatistics.StockQty_ProductStocksColumn);
			}

			[DebuggerNonUserCode]
			public void SetStockQty_ProductStocksNull()
			{
				base[tableFrmYearSalesStatistics.StockQty_ProductStocksColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsNotArrive_AmountNull()
			{
				return IsNull(tableFrmYearSalesStatistics.NotArrive_AmountColumn);
			}

			[DebuggerNonUserCode]
			public void SetNotArrive_AmountNull()
			{
				base[tableFrmYearSalesStatistics.NotArrive_AmountColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsQuantity_OnShipNull()
			{
				return IsNull(tableFrmYearSalesStatistics.Quantity_OnShipColumn);
			}

			[DebuggerNonUserCode]
			public void SetQuantity_OnShipNull()
			{
				base[tableFrmYearSalesStatistics.Quantity_OnShipColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsNo_PurchaseOrderBillNull()
			{
				return IsNull(tableFrmYearSalesStatistics.No_PurchaseOrderBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_PurchaseOrderBillNull()
			{
				base[tableFrmYearSalesStatistics.No_PurchaseOrderBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsRefNo_PurchaseOrderBillNull()
			{
				return IsNull(tableFrmYearSalesStatistics.RefNo_PurchaseOrderBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetRefNo_PurchaseOrderBillNull()
			{
				base[tableFrmYearSalesStatistics.RefNo_PurchaseOrderBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsComment_PurchaseOrderBillProductNull()
			{
				return IsNull(tableFrmYearSalesStatistics.Comment_PurchaseOrderBillProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetComment_PurchaseOrderBillProductNull()
			{
				base[tableFrmYearSalesStatistics.Comment_PurchaseOrderBillProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsPNotArrive_AmountNull()
			{
				return IsNull(tableFrmYearSalesStatistics.PNotArrive_AmountColumn);
			}

			[DebuggerNonUserCode]
			public void SetPNotArrive_AmountNull()
			{
				base[tableFrmYearSalesStatistics.PNotArrive_AmountColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsPQuantity_OnShipNull()
			{
				return IsNull(tableFrmYearSalesStatistics.PQuantity_OnShipColumn);
			}

			[DebuggerNonUserCode]
			public void SetPQuantity_OnShipNull()
			{
				base[tableFrmYearSalesStatistics.PQuantity_OnShipColumn] = Convert.DBNull;
			}
		}

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public AppendInfoRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public GetRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public FrmYearSalesStatisticsRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

		private AppendInfoDataTable tableAppendInfo;

		private GetDataTable tableGet;

		private FrmYearSalesStatisticsDataTable tableFrmYearSalesStatistics;

		private SchemaSerializationMode _schemaSerializationMode = SchemaSerializationMode.IncludeSchema;

		[DebuggerNonUserCode]
		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		public AppendInfoDataTable AppendInfo => tableAppendInfo;

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[DebuggerNonUserCode]
		[Browsable(false)]
		public GetDataTable Get => tableGet;

		[DebuggerNonUserCode]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[Browsable(false)]
		public FrmYearSalesStatisticsDataTable FrmYearSalesStatistics => tableFrmYearSalesStatistics;

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

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

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

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

		[DebuggerNonUserCode]
		protected dsFrmYearSalesStatistics(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["AppendInfo"] != null)
				{
					base.Tables.Add(new AppendInfoDataTable(dataSet.Tables["AppendInfo"]));
				}
				if (dataSet.Tables["Get"] != null)
				{
					base.Tables.Add(new GetDataTable(dataSet.Tables["Get"]));
				}
				if (dataSet.Tables["FrmYearSalesStatistics"] != null)
				{
					base.Tables.Add(new FrmYearSalesStatisticsDataTable(dataSet.Tables["FrmYearSalesStatistics"]));
				}
				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()
		{
			dsFrmYearSalesStatistics dsFrmYearSalesStatistics = (dsFrmYearSalesStatistics)base.Clone();
			dsFrmYearSalesStatistics.InitVars();
			dsFrmYearSalesStatistics.SchemaSerializationMode = SchemaSerializationMode;
			return dsFrmYearSalesStatistics;
		}

		[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["AppendInfo"] != null)
				{
					base.Tables.Add(new AppendInfoDataTable(dataSet.Tables["AppendInfo"]));
				}
				if (dataSet.Tables["Get"] != null)
				{
					base.Tables.Add(new GetDataTable(dataSet.Tables["Get"]));
				}
				if (dataSet.Tables["FrmYearSalesStatistics"] != null)
				{
					base.Tables.Add(new FrmYearSalesStatisticsDataTable(dataSet.Tables["FrmYearSalesStatistics"]));
				}
				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)
		{
			tableAppendInfo = (AppendInfoDataTable)base.Tables["AppendInfo"];
			if (initTable && tableAppendInfo != null)
			{
				tableAppendInfo.InitVars();
			}
			tableGet = (GetDataTable)base.Tables["Get"];
			if (initTable && tableGet != null)
			{
				tableGet.InitVars();
			}
			tableFrmYearSalesStatistics = (FrmYearSalesStatisticsDataTable)base.Tables["FrmYearSalesStatistics"];
			if (initTable && tableFrmYearSalesStatistics != null)
			{
				tableFrmYearSalesStatistics.InitVars();
			}
		}

		[DebuggerNonUserCode]
		private void InitClass()
		{
			base.DataSetName = "dsFrmYearSalesStatistics";
			base.Prefix = "";
			base.Namespace = "http://tempuri.org/dsFrmYearSalesStatistics.xsd";
			base.Locale = new CultureInfo("en-US");
			base.EnforceConstraints = true;
			SchemaSerializationMode = SchemaSerializationMode.IncludeSchema;
			tableAppendInfo = new AppendInfoDataTable();
			base.Tables.Add(tableAppendInfo);
			tableGet = new GetDataTable();
			base.Tables.Add(tableGet);
			tableFrmYearSalesStatistics = new FrmYearSalesStatisticsDataTable();
			base.Tables.Add(tableFrmYearSalesStatistics);
		}

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

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

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

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

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