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

		public delegate void AppendInfoRowChangeEventHandler(object sender, AppendInfoRowChangeEvent e);

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

			private DataColumn columnName_Product;

			private DataColumn columnCost_Product;

			private DataColumn columnOpeningAvailableQty_ProductStocks;

			private DataColumn columnAvailableQty_ProductStocks;

			private DataColumn columnQuantity_SaleBillProduct;

			private DataColumn columnQuantity_SaleOutDepotBillProduct;

			private DataColumn columnOutQuantity_ModifyDepotBillProduct;

			private DataColumn columnInQuantity_ModifyDepotBillProduct;

			private DataColumn columnQuantity_PurchaseOrderBillProduct;

			private DataColumn columnQuantity_PurchaseInDepotBillProduct;

			private DataColumn columnOutQuantity_StocktakingBillProduct;

			private DataColumn columnInQuantity_StocktakingBillProduct;

			private DataColumn columnTotalPrice;

			private DataColumn columnQuantity_SaleRtnBillProduct;

			private DataColumn columnType_Product;

			private DataColumn columnQuantity_RealSale;

			private DataColumn columnOpeningStockQty_ProductStocks;

			private DataColumn columnStockQty_ProductStocks;

			[DebuggerNonUserCode]
			public DataColumn No_ProductColumn => columnNo_Product;

			[DebuggerNonUserCode]
			public DataColumn Name_ProductColumn => columnName_Product;

			[DebuggerNonUserCode]
			public DataColumn Cost_ProductColumn => columnCost_Product;

			[DebuggerNonUserCode]
			public DataColumn OpeningAvailableQty_ProductStocksColumn => columnOpeningAvailableQty_ProductStocks;

			[DebuggerNonUserCode]
			public DataColumn AvailableQty_ProductStocksColumn => columnAvailableQty_ProductStocks;

			[DebuggerNonUserCode]
			public DataColumn Quantity_SaleBillProductColumn => columnQuantity_SaleBillProduct;

			[DebuggerNonUserCode]
			public DataColumn Quantity_SaleOutDepotBillProductColumn => columnQuantity_SaleOutDepotBillProduct;

			[DebuggerNonUserCode]
			public DataColumn OutQuantity_ModifyDepotBillProductColumn => columnOutQuantity_ModifyDepotBillProduct;

			[DebuggerNonUserCode]
			public DataColumn InQuantity_ModifyDepotBillProductColumn => columnInQuantity_ModifyDepotBillProduct;

			[DebuggerNonUserCode]
			public DataColumn Quantity_PurchaseOrderBillProductColumn => columnQuantity_PurchaseOrderBillProduct;

			[DebuggerNonUserCode]
			public DataColumn Quantity_PurchaseInDepotBillProductColumn => columnQuantity_PurchaseInDepotBillProduct;

			[DebuggerNonUserCode]
			public DataColumn OutQuantity_StocktakingBillProductColumn => columnOutQuantity_StocktakingBillProduct;

			[DebuggerNonUserCode]
			public DataColumn InQuantity_StocktakingBillProductColumn => columnInQuantity_StocktakingBillProduct;

			[DebuggerNonUserCode]
			public DataColumn TotalPriceColumn => columnTotalPrice;

			[DebuggerNonUserCode]
			public DataColumn Quantity_SaleRtnBillProductColumn => columnQuantity_SaleRtnBillProduct;

			[DebuggerNonUserCode]
			public DataColumn Type_ProductColumn => columnType_Product;

			[DebuggerNonUserCode]
			public DataColumn Quantity_RealSaleColumn => columnQuantity_RealSale;

			[DebuggerNonUserCode]
			public DataColumn OpeningStockQty_ProductStocksColumn => columnOpeningStockQty_ProductStocks;

			[DebuggerNonUserCode]
			public DataColumn StockQty_ProductStocksColumn => columnStockQty_ProductStocks;

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

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

			public event TotalRowChangeEventHandler TotalRowChanging;

			public event TotalRowChangeEventHandler TotalRowChanged;

			public event TotalRowChangeEventHandler TotalRowDeleting;

			public event TotalRowChangeEventHandler TotalRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddTotalRow(TotalRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public TotalRow AddTotalRow(string No_Product, string Name_Product, decimal Cost_Product, decimal OpeningAvailableQty_ProductStocks, decimal AvailableQty_ProductStocks, decimal Quantity_SaleBillProduct, decimal Quantity_SaleOutDepotBillProduct, decimal OutQuantity_ModifyDepotBillProduct, decimal InQuantity_ModifyDepotBillProduct, decimal Quantity_PurchaseOrderBillProduct, decimal Quantity_PurchaseInDepotBillProduct, decimal OutQuantity_StocktakingBillProduct, decimal InQuantity_StocktakingBillProduct, decimal TotalPrice, decimal Quantity_SaleRtnBillProduct, string Type_Product, decimal Quantity_RealSale, decimal OpeningStockQty_ProductStocks, decimal StockQty_ProductStocks)
			{
				TotalRow totalRow = (TotalRow)NewRow();
				totalRow.ItemArray = new object[19]
				{
					No_Product,
					Name_Product,
					Cost_Product,
					OpeningAvailableQty_ProductStocks,
					AvailableQty_ProductStocks,
					Quantity_SaleBillProduct,
					Quantity_SaleOutDepotBillProduct,
					OutQuantity_ModifyDepotBillProduct,
					InQuantity_ModifyDepotBillProduct,
					Quantity_PurchaseOrderBillProduct,
					Quantity_PurchaseInDepotBillProduct,
					OutQuantity_StocktakingBillProduct,
					InQuantity_StocktakingBillProduct,
					TotalPrice,
					Quantity_SaleRtnBillProduct,
					Type_Product,
					Quantity_RealSale,
					OpeningStockQty_ProductStocks,
					StockQty_ProductStocks
				};
				base.Rows.Add(totalRow);
				return totalRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnNo_Product = base.Columns["No_Product"];
				columnName_Product = base.Columns["Name_Product"];
				columnCost_Product = base.Columns["Cost_Product"];
				columnOpeningAvailableQty_ProductStocks = base.Columns["OpeningAvailableQty_ProductStocks"];
				columnAvailableQty_ProductStocks = base.Columns["AvailableQty_ProductStocks"];
				columnQuantity_SaleBillProduct = base.Columns["Quantity_SaleBillProduct"];
				columnQuantity_SaleOutDepotBillProduct = base.Columns["Quantity_SaleOutDepotBillProduct"];
				columnOutQuantity_ModifyDepotBillProduct = base.Columns["OutQuantity_ModifyDepotBillProduct"];
				columnInQuantity_ModifyDepotBillProduct = base.Columns["InQuantity_ModifyDepotBillProduct"];
				columnQuantity_PurchaseOrderBillProduct = base.Columns["Quantity_PurchaseOrderBillProduct"];
				columnQuantity_PurchaseInDepotBillProduct = base.Columns["Quantity_PurchaseInDepotBillProduct"];
				columnOutQuantity_StocktakingBillProduct = base.Columns["OutQuantity_StocktakingBillProduct"];
				columnInQuantity_StocktakingBillProduct = base.Columns["InQuantity_StocktakingBillProduct"];
				columnTotalPrice = base.Columns["TotalPrice"];
				columnQuantity_SaleRtnBillProduct = base.Columns["Quantity_SaleRtnBillProduct"];
				columnType_Product = base.Columns["Type_Product"];
				columnQuantity_RealSale = base.Columns["Quantity_RealSale"];
				columnOpeningStockQty_ProductStocks = base.Columns["OpeningStockQty_ProductStocks"];
				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);
				columnCost_Product = new DataColumn("Cost_Product", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnCost_Product);
				columnOpeningAvailableQty_ProductStocks = new DataColumn("OpeningAvailableQty_ProductStocks", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnOpeningAvailableQty_ProductStocks);
				columnAvailableQty_ProductStocks = new DataColumn("AvailableQty_ProductStocks", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnAvailableQty_ProductStocks);
				columnQuantity_SaleBillProduct = new DataColumn("Quantity_SaleBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnQuantity_SaleBillProduct);
				columnQuantity_SaleOutDepotBillProduct = new DataColumn("Quantity_SaleOutDepotBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnQuantity_SaleOutDepotBillProduct);
				columnOutQuantity_ModifyDepotBillProduct = new DataColumn("OutQuantity_ModifyDepotBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnOutQuantity_ModifyDepotBillProduct);
				columnInQuantity_ModifyDepotBillProduct = new DataColumn("InQuantity_ModifyDepotBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnInQuantity_ModifyDepotBillProduct);
				columnQuantity_PurchaseOrderBillProduct = new DataColumn("Quantity_PurchaseOrderBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnQuantity_PurchaseOrderBillProduct);
				columnQuantity_PurchaseInDepotBillProduct = new DataColumn("Quantity_PurchaseInDepotBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnQuantity_PurchaseInDepotBillProduct);
				columnOutQuantity_StocktakingBillProduct = new DataColumn("OutQuantity_StocktakingBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnOutQuantity_StocktakingBillProduct);
				columnInQuantity_StocktakingBillProduct = new DataColumn("InQuantity_StocktakingBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnInQuantity_StocktakingBillProduct);
				columnTotalPrice = new DataColumn("TotalPrice", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnTotalPrice);
				columnQuantity_SaleRtnBillProduct = new DataColumn("Quantity_SaleRtnBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnQuantity_SaleRtnBillProduct);
				columnType_Product = new DataColumn("Type_Product", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnType_Product);
				columnQuantity_RealSale = new DataColumn("Quantity_RealSale", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnQuantity_RealSale);
				columnOpeningStockQty_ProductStocks = new DataColumn("OpeningStockQty_ProductStocks", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnOpeningStockQty_ProductStocks);
				columnStockQty_ProductStocks = new DataColumn("StockQty_ProductStocks", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnStockQty_ProductStocks);
			}

			[DebuggerNonUserCode]
			public TotalRow NewTotalRow()
			{
				return (TotalRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveTotalRow(TotalRow row)
			{
				base.Rows.Remove(row);
			}

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

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

			[DebuggerNonUserCode]
			[Browsable(false)]
			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();
				dsFrmOverallSearchTable dsFrmOverallSearchTable = new dsFrmOverallSearchTable();
				xs.Add(dsFrmOverallSearchTable.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 = dsFrmOverallSearchTable.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "AppendInfoDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				return xmlSchemaComplexType;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class TotalRow : DataRow
		{
			private TotalDataTable tableTotal;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			internal TotalRow(DataRowBuilder rb)
				: base(rb)
			{
				tableTotal = (TotalDataTable)base.Table;
			}

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsCost_ProductNull()
			{
				return IsNull(tableTotal.Cost_ProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetCost_ProductNull()
			{
				base[tableTotal.Cost_ProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsOpeningAvailableQty_ProductStocksNull()
			{
				return IsNull(tableTotal.OpeningAvailableQty_ProductStocksColumn);
			}

			[DebuggerNonUserCode]
			public void SetOpeningAvailableQty_ProductStocksNull()
			{
				base[tableTotal.OpeningAvailableQty_ProductStocksColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAvailableQty_ProductStocksNull()
			{
				return IsNull(tableTotal.AvailableQty_ProductStocksColumn);
			}

			[DebuggerNonUserCode]
			public void SetAvailableQty_ProductStocksNull()
			{
				base[tableTotal.AvailableQty_ProductStocksColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsQuantity_SaleBillProductNull()
			{
				return IsNull(tableTotal.Quantity_SaleBillProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetQuantity_SaleBillProductNull()
			{
				base[tableTotal.Quantity_SaleBillProductColumn] = Convert.DBNull;
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsQuantity_PurchaseOrderBillProductNull()
			{
				return IsNull(tableTotal.Quantity_PurchaseOrderBillProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetQuantity_PurchaseOrderBillProductNull()
			{
				base[tableTotal.Quantity_PurchaseOrderBillProductColumn] = Convert.DBNull;
			}

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

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

			[DebuggerNonUserCode]
			public bool IsOutQuantity_StocktakingBillProductNull()
			{
				return IsNull(tableTotal.OutQuantity_StocktakingBillProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetOutQuantity_StocktakingBillProductNull()
			{
				base[tableTotal.OutQuantity_StocktakingBillProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsInQuantity_StocktakingBillProductNull()
			{
				return IsNull(tableTotal.InQuantity_StocktakingBillProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetInQuantity_StocktakingBillProductNull()
			{
				base[tableTotal.InQuantity_StocktakingBillProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTotalPriceNull()
			{
				return IsNull(tableTotal.TotalPriceColumn);
			}

			[DebuggerNonUserCode]
			public void SetTotalPriceNull()
			{
				base[tableTotal.TotalPriceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsQuantity_SaleRtnBillProductNull()
			{
				return IsNull(tableTotal.Quantity_SaleRtnBillProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetQuantity_SaleRtnBillProductNull()
			{
				base[tableTotal.Quantity_SaleRtnBillProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsType_ProductNull()
			{
				return IsNull(tableTotal.Type_ProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetType_ProductNull()
			{
				base[tableTotal.Type_ProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsQuantity_RealSaleNull()
			{
				return IsNull(tableTotal.Quantity_RealSaleColumn);
			}

			[DebuggerNonUserCode]
			public void SetQuantity_RealSaleNull()
			{
				base[tableTotal.Quantity_RealSaleColumn] = Convert.DBNull;
			}

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

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

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

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

		[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 TotalRowChangeEvent : EventArgs
		{
			private TotalRow eventRow;

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public TotalRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

		private TotalDataTable tableTotal;

		private AppendInfoDataTable tableAppendInfo;

		private SchemaSerializationMode _schemaSerializationMode = SchemaSerializationMode.IncludeSchema;

		[DebuggerNonUserCode]
		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		public TotalDataTable Total => tableTotal;

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

		[DebuggerNonUserCode]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
		[Browsable(true)]
		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 dsFrmOverallSearchTable()
		{
			BeginInit();
			InitClass();
			CollectionChangeEventHandler value = SchemaChanged;
			base.Tables.CollectionChanged += value;
			base.Relations.CollectionChanged += value;
			EndInit();
		}

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

		[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["Total"] != null)
				{
					base.Tables.Add(new TotalDataTable(dataSet.Tables["Total"]));
				}
				if (dataSet.Tables["AppendInfo"] != null)
				{
					base.Tables.Add(new AppendInfoDataTable(dataSet.Tables["AppendInfo"]));
				}
				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)
		{
			tableTotal = (TotalDataTable)base.Tables["Total"];
			if (initTable && tableTotal != null)
			{
				tableTotal.InitVars();
			}
			tableAppendInfo = (AppendInfoDataTable)base.Tables["AppendInfo"];
			if (initTable && tableAppendInfo != null)
			{
				tableAppendInfo.InitVars();
			}
		}

		[DebuggerNonUserCode]
		private void InitClass()
		{
			base.DataSetName = "dsFrmOverallSearchTable";
			base.Prefix = "";
			base.Namespace = "http://tempuri.org/dsFrmOverallSearchTable.xsd";
			base.EnforceConstraints = true;
			SchemaSerializationMode = SchemaSerializationMode.IncludeSchema;
			tableTotal = new TotalDataTable();
			base.Tables.Add(tableTotal);
			tableAppendInfo = new AppendInfoDataTable();
			base.Tables.Add(tableAppendInfo);
		}

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

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

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

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