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("dsUIFrmOverallSearchStatistics")]
	[HelpKeyword("vs.data.DataSet")]
	[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
	[DesignerCategory("code")]
	[ToolboxItem(true)]
	[XmlSchemaProvider("GetTypedDataSetSchema")]
	public class dsUIFrmOverallSearchStatistics : DataSet
	{
		public delegate void UIRowChangeEventHandler(object sender, UIRowChangeEvent e);

		public delegate void OverallSearchStatisticsRowChangeEventHandler(object sender, OverallSearchStatisticsRowChangeEvent e);

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

			private DataColumn columnEndNo_Product;

			private DataColumn columnName_Creator;

			private DataColumn columnCreateDate;

			[DebuggerNonUserCode]
			public DataColumn StartNo_ProductColumn => columnStartNo_Product;

			[DebuggerNonUserCode]
			public DataColumn EndNo_ProductColumn => columnEndNo_Product;

			[DebuggerNonUserCode]
			public DataColumn Name_CreatorColumn => columnName_Creator;

			[DebuggerNonUserCode]
			public DataColumn CreateDateColumn => columnCreateDate;

			[Browsable(false)]
			[DebuggerNonUserCode]
			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(string StartNo_Product, string EndNo_Product, string Name_Creator, DateTime CreateDate)
			{
				UIRow uIRow = (UIRow)NewRow();
				uIRow.ItemArray = new object[4]
				{
					StartNo_Product,
					EndNo_Product,
					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()
			{
				columnStartNo_Product = base.Columns["StartNo_Product"];
				columnEndNo_Product = base.Columns["EndNo_Product"];
				columnName_Creator = base.Columns["Name_Creator"];
				columnCreateDate = base.Columns["CreateDate"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnStartNo_Product = new DataColumn("StartNo_Product", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnStartNo_Product);
				columnEndNo_Product = new DataColumn("EndNo_Product", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnEndNo_Product);
				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);
				columnStartNo_Product.Caption = "StartNo_Customer";
				columnEndNo_Product.Caption = "EndNo_Customer";
			}

			[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();
				dsUIFrmOverallSearchStatistics dsUIFrmOverallSearchStatistics = new dsUIFrmOverallSearchStatistics();
				xs.Add(dsUIFrmOverallSearchStatistics.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 = dsUIFrmOverallSearchStatistics.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 OverallSearchStatisticsDataTable : DataTable, IEnumerable
		{
			private DataColumn columnNo_Product;

			private DataColumn columnName_Product;

			private DataColumn columnOpeningStockQty_ProductStocks;

			private DataColumn columnPDay;

			private DataColumn columnQuantity_PurchaseInDepotBillProduct;

			private DataColumn columnMon;

			private DataColumn columnQuantity_SaleOutDepotBillProduct;

			private DataColumn columnInQuantity_ModifyDepotBillProduct;

			private DataColumn columnOutQuantity_ModifyDepotBillProduct;

			private DataColumn columnStockQty_ProductStocks;

			[DebuggerNonUserCode]
			public DataColumn No_ProductColumn => columnNo_Product;

			[DebuggerNonUserCode]
			public DataColumn Name_ProductColumn => columnName_Product;

			[DebuggerNonUserCode]
			public DataColumn OpeningStockQty_ProductStocksColumn => columnOpeningStockQty_ProductStocks;

			[DebuggerNonUserCode]
			public DataColumn PDayColumn => columnPDay;

			[DebuggerNonUserCode]
			public DataColumn Quantity_PurchaseInDepotBillProductColumn => columnQuantity_PurchaseInDepotBillProduct;

			[DebuggerNonUserCode]
			public DataColumn MonColumn => columnMon;

			[DebuggerNonUserCode]
			public DataColumn Quantity_SaleOutDepotBillProductColumn => columnQuantity_SaleOutDepotBillProduct;

			[DebuggerNonUserCode]
			public DataColumn InQuantity_ModifyDepotBillProductColumn => columnInQuantity_ModifyDepotBillProduct;

			[DebuggerNonUserCode]
			public DataColumn OutQuantity_ModifyDepotBillProductColumn => columnOutQuantity_ModifyDepotBillProduct;

			[DebuggerNonUserCode]
			public DataColumn StockQty_ProductStocksColumn => columnStockQty_ProductStocks;

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

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

			public event OverallSearchStatisticsRowChangeEventHandler OverallSearchStatisticsRowChanging;

			public event OverallSearchStatisticsRowChangeEventHandler OverallSearchStatisticsRowChanged;

			public event OverallSearchStatisticsRowChangeEventHandler OverallSearchStatisticsRowDeleting;

			public event OverallSearchStatisticsRowChangeEventHandler OverallSearchStatisticsRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddOverallSearchStatisticsRow(OverallSearchStatisticsRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public OverallSearchStatisticsRow AddOverallSearchStatisticsRow(string No_Product, string Name_Product, decimal OpeningStockQty_ProductStocks, string PDay, decimal Quantity_PurchaseInDepotBillProduct, string Mon, decimal Quantity_SaleOutDepotBillProduct, decimal InQuantity_ModifyDepotBillProduct, decimal OutQuantity_ModifyDepotBillProduct, decimal StockQty_ProductStocks)
			{
				OverallSearchStatisticsRow overallSearchStatisticsRow = (OverallSearchStatisticsRow)NewRow();
				overallSearchStatisticsRow.ItemArray = new object[10]
				{
					No_Product,
					Name_Product,
					OpeningStockQty_ProductStocks,
					PDay,
					Quantity_PurchaseInDepotBillProduct,
					Mon,
					Quantity_SaleOutDepotBillProduct,
					InQuantity_ModifyDepotBillProduct,
					OutQuantity_ModifyDepotBillProduct,
					StockQty_ProductStocks
				};
				base.Rows.Add(overallSearchStatisticsRow);
				return overallSearchStatisticsRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnNo_Product = base.Columns["No_Product"];
				columnName_Product = base.Columns["Name_Product"];
				columnOpeningStockQty_ProductStocks = base.Columns["OpeningStockQty_ProductStocks"];
				columnPDay = base.Columns["PDay"];
				columnQuantity_PurchaseInDepotBillProduct = base.Columns["Quantity_PurchaseInDepotBillProduct"];
				columnMon = base.Columns["Mon"];
				columnQuantity_SaleOutDepotBillProduct = base.Columns["Quantity_SaleOutDepotBillProduct"];
				columnInQuantity_ModifyDepotBillProduct = base.Columns["InQuantity_ModifyDepotBillProduct"];
				columnOutQuantity_ModifyDepotBillProduct = base.Columns["OutQuantity_ModifyDepotBillProduct"];
				columnStockQty_ProductStocks = base.Columns["StockQty_ProductStocks"];
			}

			[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);
				columnOpeningStockQty_ProductStocks = new DataColumn("OpeningStockQty_ProductStocks", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnOpeningStockQty_ProductStocks);
				columnPDay = new DataColumn("PDay", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnPDay);
				columnQuantity_PurchaseInDepotBillProduct = new DataColumn("Quantity_PurchaseInDepotBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnQuantity_PurchaseInDepotBillProduct);
				columnMon = new DataColumn("Mon", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnMon);
				columnQuantity_SaleOutDepotBillProduct = new DataColumn("Quantity_SaleOutDepotBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnQuantity_SaleOutDepotBillProduct);
				columnInQuantity_ModifyDepotBillProduct = new DataColumn("InQuantity_ModifyDepotBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnInQuantity_ModifyDepotBillProduct);
				columnOutQuantity_ModifyDepotBillProduct = new DataColumn("OutQuantity_ModifyDepotBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnOutQuantity_ModifyDepotBillProduct);
				columnStockQty_ProductStocks = new DataColumn("StockQty_ProductStocks", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnStockQty_ProductStocks);
			}

			[DebuggerNonUserCode]
			public OverallSearchStatisticsRow NewOverallSearchStatisticsRow()
			{
				return (OverallSearchStatisticsRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveOverallSearchStatisticsRow(OverallSearchStatisticsRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsUIFrmOverallSearchStatistics dsUIFrmOverallSearchStatistics = new dsUIFrmOverallSearchStatistics();
				xs.Add(dsUIFrmOverallSearchStatistics.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 = dsUIFrmOverallSearchStatistics.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "OverallSearchStatisticsDataTable";
				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 string StartNo_Product
			{
				get
				{
					try
					{
						return (string)base[tableUI.StartNo_ProductColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'StartNo_Product' in table 'UI' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableUI.StartNo_ProductColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public string EndNo_Product
			{
				get
				{
					try
					{
						return (string)base[tableUI.EndNo_ProductColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'EndNo_Product' in table 'UI' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableUI.EndNo_ProductColumn] = 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 IsStartNo_ProductNull()
			{
				return IsNull(tableUI.StartNo_ProductColumn);
			}

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

			[DebuggerNonUserCode]
			public bool IsEndNo_ProductNull()
			{
				return IsNull(tableUI.EndNo_ProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetEndNo_ProductNull()
			{
				base[tableUI.EndNo_ProductColumn] = 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 OverallSearchStatisticsRow : DataRow
		{
			private OverallSearchStatisticsDataTable tableOverallSearchStatistics;

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

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

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

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			internal OverallSearchStatisticsRow(DataRowBuilder rb)
				: base(rb)
			{
				tableOverallSearchStatistics = (OverallSearchStatisticsDataTable)base.Table;
			}

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsOpeningStockQty_ProductStocksNull()
			{
				return IsNull(tableOverallSearchStatistics.OpeningStockQty_ProductStocksColumn);
			}

			[DebuggerNonUserCode]
			public void SetOpeningStockQty_ProductStocksNull()
			{
				base[tableOverallSearchStatistics.OpeningStockQty_ProductStocksColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsPDayNull()
			{
				return IsNull(tableOverallSearchStatistics.PDayColumn);
			}

			[DebuggerNonUserCode]
			public void SetPDayNull()
			{
				base[tableOverallSearchStatistics.PDayColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsQuantity_PurchaseInDepotBillProductNull()
			{
				return IsNull(tableOverallSearchStatistics.Quantity_PurchaseInDepotBillProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetQuantity_PurchaseInDepotBillProductNull()
			{
				base[tableOverallSearchStatistics.Quantity_PurchaseInDepotBillProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsMonNull()
			{
				return IsNull(tableOverallSearchStatistics.MonColumn);
			}

			[DebuggerNonUserCode]
			public void SetMonNull()
			{
				base[tableOverallSearchStatistics.MonColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsQuantity_SaleOutDepotBillProductNull()
			{
				return IsNull(tableOverallSearchStatistics.Quantity_SaleOutDepotBillProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetQuantity_SaleOutDepotBillProductNull()
			{
				base[tableOverallSearchStatistics.Quantity_SaleOutDepotBillProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsInQuantity_ModifyDepotBillProductNull()
			{
				return IsNull(tableOverallSearchStatistics.InQuantity_ModifyDepotBillProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetInQuantity_ModifyDepotBillProductNull()
			{
				base[tableOverallSearchStatistics.InQuantity_ModifyDepotBillProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsOutQuantity_ModifyDepotBillProductNull()
			{
				return IsNull(tableOverallSearchStatistics.OutQuantity_ModifyDepotBillProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetOutQuantity_ModifyDepotBillProductNull()
			{
				base[tableOverallSearchStatistics.OutQuantity_ModifyDepotBillProductColumn] = Convert.DBNull;
			}

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

			[DebuggerNonUserCode]
			public void SetStockQty_ProductStocksNull()
			{
				base[tableOverallSearchStatistics.StockQty_ProductStocksColumn] = 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 OverallSearchStatisticsRowChangeEvent : EventArgs
		{
			private OverallSearchStatisticsRow eventRow;

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public OverallSearchStatisticsRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

		private UIDataTable tableUI;

		private OverallSearchStatisticsDataTable tableOverallSearchStatistics;

		private SchemaSerializationMode _schemaSerializationMode = SchemaSerializationMode.IncludeSchema;

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

		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[DebuggerNonUserCode]
		public OverallSearchStatisticsDataTable OverallSearchStatistics => tableOverallSearchStatistics;

		[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;

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

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

		[DebuggerNonUserCode]
		protected dsUIFrmOverallSearchStatistics(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["OverallSearchStatistics"] != null)
				{
					base.Tables.Add(new OverallSearchStatisticsDataTable(dataSet.Tables["OverallSearchStatistics"]));
				}
				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()
		{
			dsUIFrmOverallSearchStatistics dsUIFrmOverallSearchStatistics = (dsUIFrmOverallSearchStatistics)base.Clone();
			dsUIFrmOverallSearchStatistics.InitVars();
			dsUIFrmOverallSearchStatistics.SchemaSerializationMode = SchemaSerializationMode;
			return dsUIFrmOverallSearchStatistics;
		}

		[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["OverallSearchStatistics"] != null)
				{
					base.Tables.Add(new OverallSearchStatisticsDataTable(dataSet.Tables["OverallSearchStatistics"]));
				}
				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();
			}
			tableOverallSearchStatistics = (OverallSearchStatisticsDataTable)base.Tables["OverallSearchStatistics"];
			if (initTable && tableOverallSearchStatistics != null)
			{
				tableOverallSearchStatistics.InitVars();
			}
		}

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

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

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

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

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