sanlu_new/sanlu_c#/SunRoxmServer/SunRoxm.BizPeri.ReportDataSet/SunRoxm.BizPeri.ReportDataSet.ReportDataSet/dsFrmSaleContract.cs

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")]
	[HelpKeyword("vs.data.DataSet")]
	[DesignerCategory("code")]
	[ToolboxItem(true)]
	[XmlSchemaProvider("GetTypedDataSetSchema")]
	[XmlRoot("dsFrmSaleContract")]
	public class dsFrmSaleContract : DataSet
	{
		public delegate void SaleBillRowChangeEventHandler(object sender, SaleBillRowChangeEvent e);

		public delegate void CessOutRowChangeEventHandler(object sender, CessOutRowChangeEvent e);

		public delegate void CompanyRowChangeEventHandler(object sender, CompanyRowChangeEvent e);

		public delegate void CustomerInfoRowChangeEventHandler(object sender, CustomerInfoRowChangeEvent e);

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

			private DataColumn columnNo_Telephone;

			private DataColumn columnRevenueRegisterNo_Customer;

			private DataColumn columnBank_Customer;

			private DataColumn columnAccount_Customer;

			private DataColumn columnSendAddr_Customer;

			private DataColumn columnAddress_Invoice;

			private DataColumn columnNo_SaleBill;

			private DataColumn columnTaxCurrency_SaleBill;

			private DataColumn columnQuantity_SaleBillProduct;

			private DataColumn columnUnitPrice_SaleBillProduct;

			private DataColumn columnTaxCurrency;

			private DataColumn columnNo_Product;

			private DataColumn columnName_Product;

			private DataColumn columnDate_SaleBill;

			private DataColumn columnMoneyCurrency;

			private DataColumn columnTitle_Invoice;

			private DataColumn columnNo_Customer;

			private DataColumn columnNo_Fax;

			[DebuggerNonUserCode]
			public DataColumn Name_CustomerColumn => columnName_Customer;

			[DebuggerNonUserCode]
			public DataColumn No_TelephoneColumn => columnNo_Telephone;

			[DebuggerNonUserCode]
			public DataColumn RevenueRegisterNo_CustomerColumn => columnRevenueRegisterNo_Customer;

			[DebuggerNonUserCode]
			public DataColumn Bank_CustomerColumn => columnBank_Customer;

			[DebuggerNonUserCode]
			public DataColumn Account_CustomerColumn => columnAccount_Customer;

			[DebuggerNonUserCode]
			public DataColumn SendAddr_CustomerColumn => columnSendAddr_Customer;

			[DebuggerNonUserCode]
			public DataColumn Address_InvoiceColumn => columnAddress_Invoice;

			[DebuggerNonUserCode]
			public DataColumn No_SaleBillColumn => columnNo_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn TaxCurrency_SaleBillColumn => columnTaxCurrency_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn Quantity_SaleBillProductColumn => columnQuantity_SaleBillProduct;

			[DebuggerNonUserCode]
			public DataColumn UnitPrice_SaleBillProductColumn => columnUnitPrice_SaleBillProduct;

			[DebuggerNonUserCode]
			public DataColumn TaxCurrencyColumn => columnTaxCurrency;

			[DebuggerNonUserCode]
			public DataColumn No_ProductColumn => columnNo_Product;

			[DebuggerNonUserCode]
			public DataColumn Name_ProductColumn => columnName_Product;

			[DebuggerNonUserCode]
			public DataColumn Date_SaleBillColumn => columnDate_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn MoneyCurrencyColumn => columnMoneyCurrency;

			[DebuggerNonUserCode]
			public DataColumn Title_InvoiceColumn => columnTitle_Invoice;

			[DebuggerNonUserCode]
			public DataColumn No_CustomerColumn => columnNo_Customer;

			[DebuggerNonUserCode]
			public DataColumn No_FaxColumn => columnNo_Fax;

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

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

			public event SaleBillRowChangeEventHandler SaleBillRowChanging;

			public event SaleBillRowChangeEventHandler SaleBillRowChanged;

			public event SaleBillRowChangeEventHandler SaleBillRowDeleting;

			public event SaleBillRowChangeEventHandler SaleBillRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddSaleBillRow(SaleBillRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public SaleBillRow AddSaleBillRow(string Name_Customer, string No_Telephone, string RevenueRegisterNo_Customer, string Bank_Customer, string Account_Customer, string SendAddr_Customer, string Address_Invoice, string No_SaleBill, string TaxCurrency_SaleBill, decimal Quantity_SaleBillProduct, decimal UnitPrice_SaleBillProduct, decimal TaxCurrency, string No_Product, string Name_Product, DateTime Date_SaleBill, decimal MoneyCurrency, string Title_Invoice, string No_Customer, string No_Fax)
			{
				SaleBillRow saleBillRow = (SaleBillRow)NewRow();
				saleBillRow.ItemArray = new object[19]
				{
					Name_Customer,
					No_Telephone,
					RevenueRegisterNo_Customer,
					Bank_Customer,
					Account_Customer,
					SendAddr_Customer,
					Address_Invoice,
					No_SaleBill,
					TaxCurrency_SaleBill,
					Quantity_SaleBillProduct,
					UnitPrice_SaleBillProduct,
					TaxCurrency,
					No_Product,
					Name_Product,
					Date_SaleBill,
					MoneyCurrency,
					Title_Invoice,
					No_Customer,
					No_Fax
				};
				base.Rows.Add(saleBillRow);
				return saleBillRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnName_Customer = base.Columns["Name_Customer"];
				columnNo_Telephone = base.Columns["No_Telephone"];
				columnRevenueRegisterNo_Customer = base.Columns["RevenueRegisterNo_Customer"];
				columnBank_Customer = base.Columns["Bank_Customer"];
				columnAccount_Customer = base.Columns["Account_Customer"];
				columnSendAddr_Customer = base.Columns["SendAddr_Customer"];
				columnAddress_Invoice = base.Columns["Address_Invoice"];
				columnNo_SaleBill = base.Columns["No_SaleBill"];
				columnTaxCurrency_SaleBill = base.Columns["TaxCurrency_SaleBill"];
				columnQuantity_SaleBillProduct = base.Columns["Quantity_SaleBillProduct"];
				columnUnitPrice_SaleBillProduct = base.Columns["UnitPrice_SaleBillProduct"];
				columnTaxCurrency = base.Columns["TaxCurrency"];
				columnNo_Product = base.Columns["No_Product"];
				columnName_Product = base.Columns["Name_Product"];
				columnDate_SaleBill = base.Columns["Date_SaleBill"];
				columnMoneyCurrency = base.Columns["MoneyCurrency"];
				columnTitle_Invoice = base.Columns["Title_Invoice"];
				columnNo_Customer = base.Columns["No_Customer"];
				columnNo_Fax = base.Columns["No_Fax"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnName_Customer = new DataColumn("Name_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Customer);
				columnNo_Telephone = new DataColumn("No_Telephone", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_Telephone);
				columnRevenueRegisterNo_Customer = new DataColumn("RevenueRegisterNo_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnRevenueRegisterNo_Customer);
				columnBank_Customer = new DataColumn("Bank_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnBank_Customer);
				columnAccount_Customer = new DataColumn("Account_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnAccount_Customer);
				columnSendAddr_Customer = new DataColumn("SendAddr_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnSendAddr_Customer);
				columnAddress_Invoice = new DataColumn("Address_Invoice", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnAddress_Invoice);
				columnNo_SaleBill = new DataColumn("No_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_SaleBill);
				columnTaxCurrency_SaleBill = new DataColumn("TaxCurrency_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnTaxCurrency_SaleBill);
				columnQuantity_SaleBillProduct = new DataColumn("Quantity_SaleBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnQuantity_SaleBillProduct);
				columnUnitPrice_SaleBillProduct = new DataColumn("UnitPrice_SaleBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnUnitPrice_SaleBillProduct);
				columnTaxCurrency = new DataColumn("TaxCurrency", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnTaxCurrency);
				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);
				columnDate_SaleBill = new DataColumn("Date_SaleBill", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnDate_SaleBill);
				columnMoneyCurrency = new DataColumn("MoneyCurrency", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnMoneyCurrency);
				columnTitle_Invoice = new DataColumn("Title_Invoice", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnTitle_Invoice);
				columnNo_Customer = new DataColumn("No_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_Customer);
				columnNo_Fax = new DataColumn("No_Fax", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_Fax);
			}

			[DebuggerNonUserCode]
			public SaleBillRow NewSaleBillRow()
			{
				return (SaleBillRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveSaleBillRow(SaleBillRow row)
			{
				base.Rows.Remove(row);
			}

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

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

			[DebuggerNonUserCode]
			public DataColumn CessOut_SystemSettingColumn => columnCessOut_SystemSetting;

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

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

			public event CessOutRowChangeEventHandler CessOutRowChanging;

			public event CessOutRowChangeEventHandler CessOutRowChanged;

			public event CessOutRowChangeEventHandler CessOutRowDeleting;

			public event CessOutRowChangeEventHandler CessOutRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddCessOutRow(CessOutRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public CessOutRow AddCessOutRow(double CessOut_SystemSetting)
			{
				CessOutRow cessOutRow = (CessOutRow)NewRow();
				cessOutRow.ItemArray = new object[1]
				{
					CessOut_SystemSetting
				};
				base.Rows.Add(cessOutRow);
				return cessOutRow;
			}

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

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

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

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

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

			[DebuggerNonUserCode]
			public CessOutRow NewCessOutRow()
			{
				return (CessOutRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveCessOutRow(CessOutRow row)
			{
				base.Rows.Remove(row);
			}

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

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

			private DataColumn columnSendAddress_Company;

			private DataColumn columnTel_Company;

			private DataColumn columnRevenueRegisterNo_Company;

			private DataColumn columnBank_Company;

			private DataColumn columnAccount_Company;

			private DataColumn columnFax_Company;

			[DebuggerNonUserCode]
			public DataColumn Name_CompanyColumn => columnName_Company;

			[DebuggerNonUserCode]
			public DataColumn SendAddress_CompanyColumn => columnSendAddress_Company;

			[DebuggerNonUserCode]
			public DataColumn Tel_CompanyColumn => columnTel_Company;

			[DebuggerNonUserCode]
			public DataColumn RevenueRegisterNo_CompanyColumn => columnRevenueRegisterNo_Company;

			[DebuggerNonUserCode]
			public DataColumn Bank_CompanyColumn => columnBank_Company;

			[DebuggerNonUserCode]
			public DataColumn Account_CompanyColumn => columnAccount_Company;

			[DebuggerNonUserCode]
			public DataColumn Fax_CompanyColumn => columnFax_Company;

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

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

			public event CompanyRowChangeEventHandler CompanyRowChanging;

			public event CompanyRowChangeEventHandler CompanyRowChanged;

			public event CompanyRowChangeEventHandler CompanyRowDeleting;

			public event CompanyRowChangeEventHandler CompanyRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddCompanyRow(CompanyRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public CompanyRow AddCompanyRow(string Name_Company, string SendAddress_Company, string Tel_Company, string RevenueRegisterNo_Company, string Bank_Company, string Account_Company, string Fax_Company)
			{
				CompanyRow companyRow = (CompanyRow)NewRow();
				companyRow.ItemArray = new object[7]
				{
					Name_Company,
					SendAddress_Company,
					Tel_Company,
					RevenueRegisterNo_Company,
					Bank_Company,
					Account_Company,
					Fax_Company
				};
				base.Rows.Add(companyRow);
				return companyRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnName_Company = base.Columns["Name_Company"];
				columnSendAddress_Company = base.Columns["SendAddress_Company"];
				columnTel_Company = base.Columns["Tel_Company"];
				columnRevenueRegisterNo_Company = base.Columns["RevenueRegisterNo_Company"];
				columnBank_Company = base.Columns["Bank_Company"];
				columnAccount_Company = base.Columns["Account_Company"];
				columnFax_Company = base.Columns["Fax_Company"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnName_Company = new DataColumn("Name_Company", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Company);
				columnSendAddress_Company = new DataColumn("SendAddress_Company", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnSendAddress_Company);
				columnTel_Company = new DataColumn("Tel_Company", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnTel_Company);
				columnRevenueRegisterNo_Company = new DataColumn("RevenueRegisterNo_Company", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnRevenueRegisterNo_Company);
				columnBank_Company = new DataColumn("Bank_Company", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnBank_Company);
				columnAccount_Company = new DataColumn("Account_Company", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnAccount_Company);
				columnFax_Company = new DataColumn("Fax_Company", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnFax_Company);
			}

			[DebuggerNonUserCode]
			public CompanyRow NewCompanyRow()
			{
				return (CompanyRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveCompanyRow(CompanyRow row)
			{
				base.Rows.Remove(row);
			}

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

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

			private DataColumn columnPayTime;

			[DebuggerNonUserCode]
			public DataColumn CommentColumn => columnComment;

			[DebuggerNonUserCode]
			public DataColumn PayTimeColumn => columnPayTime;

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

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

			public event CustomerInfoRowChangeEventHandler CustomerInfoRowChanging;

			public event CustomerInfoRowChangeEventHandler CustomerInfoRowChanged;

			public event CustomerInfoRowChangeEventHandler CustomerInfoRowDeleting;

			public event CustomerInfoRowChangeEventHandler CustomerInfoRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddCustomerInfoRow(CustomerInfoRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public CustomerInfoRow AddCustomerInfoRow(string Comment, DateTime PayTime)
			{
				CustomerInfoRow customerInfoRow = (CustomerInfoRow)NewRow();
				customerInfoRow.ItemArray = new object[2]
				{
					Comment,
					PayTime
				};
				base.Rows.Add(customerInfoRow);
				return customerInfoRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnComment = base.Columns["Comment"];
				columnPayTime = base.Columns["PayTime"];
			}

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

			[DebuggerNonUserCode]
			public CustomerInfoRow NewCustomerInfoRow()
			{
				return (CustomerInfoRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveCustomerInfoRow(CustomerInfoRow row)
			{
				base.Rows.Remove(row);
			}

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

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class SaleBillRow : DataRow
		{
			private SaleBillDataTable tableSaleBill;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			internal SaleBillRow(DataRowBuilder rb)
				: base(rb)
			{
				tableSaleBill = (SaleBillDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsName_CustomerNull()
			{
				return IsNull(tableSaleBill.Name_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_CustomerNull()
			{
				base[tableSaleBill.Name_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsNo_TelephoneNull()
			{
				return IsNull(tableSaleBill.No_TelephoneColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_TelephoneNull()
			{
				base[tableSaleBill.No_TelephoneColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsRevenueRegisterNo_CustomerNull()
			{
				return IsNull(tableSaleBill.RevenueRegisterNo_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetRevenueRegisterNo_CustomerNull()
			{
				base[tableSaleBill.RevenueRegisterNo_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsBank_CustomerNull()
			{
				return IsNull(tableSaleBill.Bank_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetBank_CustomerNull()
			{
				base[tableSaleBill.Bank_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAccount_CustomerNull()
			{
				return IsNull(tableSaleBill.Account_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetAccount_CustomerNull()
			{
				base[tableSaleBill.Account_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSendAddr_CustomerNull()
			{
				return IsNull(tableSaleBill.SendAddr_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetSendAddr_CustomerNull()
			{
				base[tableSaleBill.SendAddr_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAddress_InvoiceNull()
			{
				return IsNull(tableSaleBill.Address_InvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetAddress_InvoiceNull()
			{
				base[tableSaleBill.Address_InvoiceColumn] = Convert.DBNull;
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsUnitPrice_SaleBillProductNull()
			{
				return IsNull(tableSaleBill.UnitPrice_SaleBillProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetUnitPrice_SaleBillProductNull()
			{
				base[tableSaleBill.UnitPrice_SaleBillProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTaxCurrencyNull()
			{
				return IsNull(tableSaleBill.TaxCurrencyColumn);
			}

			[DebuggerNonUserCode]
			public void SetTaxCurrencyNull()
			{
				base[tableSaleBill.TaxCurrencyColumn] = Convert.DBNull;
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsMoneyCurrencyNull()
			{
				return IsNull(tableSaleBill.MoneyCurrencyColumn);
			}

			[DebuggerNonUserCode]
			public void SetMoneyCurrencyNull()
			{
				base[tableSaleBill.MoneyCurrencyColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTitle_InvoiceNull()
			{
				return IsNull(tableSaleBill.Title_InvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetTitle_InvoiceNull()
			{
				base[tableSaleBill.Title_InvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsNo_CustomerNull()
			{
				return IsNull(tableSaleBill.No_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_CustomerNull()
			{
				base[tableSaleBill.No_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsNo_FaxNull()
			{
				return IsNull(tableSaleBill.No_FaxColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_FaxNull()
			{
				base[tableSaleBill.No_FaxColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class CessOutRow : DataRow
		{
			private CessOutDataTable tableCessOut;

			[DebuggerNonUserCode]
			public double CessOut_SystemSetting
			{
				get
				{
					try
					{
						return (double)base[tableCessOut.CessOut_SystemSettingColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'CessOut_SystemSetting' in table 'CessOut' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableCessOut.CessOut_SystemSettingColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			internal CessOutRow(DataRowBuilder rb)
				: base(rb)
			{
				tableCessOut = (CessOutDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsCessOut_SystemSettingNull()
			{
				return IsNull(tableCessOut.CessOut_SystemSettingColumn);
			}

			[DebuggerNonUserCode]
			public void SetCessOut_SystemSettingNull()
			{
				base[tableCessOut.CessOut_SystemSettingColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class CompanyRow : DataRow
		{
			private CompanyDataTable tableCompany;

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			internal CompanyRow(DataRowBuilder rb)
				: base(rb)
			{
				tableCompany = (CompanyDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsName_CompanyNull()
			{
				return IsNull(tableCompany.Name_CompanyColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_CompanyNull()
			{
				base[tableCompany.Name_CompanyColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSendAddress_CompanyNull()
			{
				return IsNull(tableCompany.SendAddress_CompanyColumn);
			}

			[DebuggerNonUserCode]
			public void SetSendAddress_CompanyNull()
			{
				base[tableCompany.SendAddress_CompanyColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTel_CompanyNull()
			{
				return IsNull(tableCompany.Tel_CompanyColumn);
			}

			[DebuggerNonUserCode]
			public void SetTel_CompanyNull()
			{
				base[tableCompany.Tel_CompanyColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsRevenueRegisterNo_CompanyNull()
			{
				return IsNull(tableCompany.RevenueRegisterNo_CompanyColumn);
			}

			[DebuggerNonUserCode]
			public void SetRevenueRegisterNo_CompanyNull()
			{
				base[tableCompany.RevenueRegisterNo_CompanyColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsBank_CompanyNull()
			{
				return IsNull(tableCompany.Bank_CompanyColumn);
			}

			[DebuggerNonUserCode]
			public void SetBank_CompanyNull()
			{
				base[tableCompany.Bank_CompanyColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAccount_CompanyNull()
			{
				return IsNull(tableCompany.Account_CompanyColumn);
			}

			[DebuggerNonUserCode]
			public void SetAccount_CompanyNull()
			{
				base[tableCompany.Account_CompanyColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsFax_CompanyNull()
			{
				return IsNull(tableCompany.Fax_CompanyColumn);
			}

			[DebuggerNonUserCode]
			public void SetFax_CompanyNull()
			{
				base[tableCompany.Fax_CompanyColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class CustomerInfoRow : DataRow
		{
			private CustomerInfoDataTable tableCustomerInfo;

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

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

			[DebuggerNonUserCode]
			internal CustomerInfoRow(DataRowBuilder rb)
				: base(rb)
			{
				tableCustomerInfo = (CustomerInfoDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsCommentNull()
			{
				return IsNull(tableCustomerInfo.CommentColumn);
			}

			[DebuggerNonUserCode]
			public void SetCommentNull()
			{
				base[tableCustomerInfo.CommentColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsPayTimeNull()
			{
				return IsNull(tableCustomerInfo.PayTimeColumn);
			}

			[DebuggerNonUserCode]
			public void SetPayTimeNull()
			{
				base[tableCustomerInfo.PayTimeColumn] = Convert.DBNull;
			}
		}

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public SaleBillRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public CessOutRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public CompanyRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public CustomerInfoRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

		private SaleBillDataTable tableSaleBill;

		private CessOutDataTable tableCessOut;

		private CompanyDataTable tableCompany;

		private CustomerInfoDataTable tableCustomerInfo;

		private SchemaSerializationMode _schemaSerializationMode = SchemaSerializationMode.IncludeSchema;

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[DebuggerNonUserCode]
		[Browsable(false)]
		public SaleBillDataTable SaleBill => tableSaleBill;

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[Browsable(false)]
		[DebuggerNonUserCode]
		public CessOutDataTable CessOut => tableCessOut;

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[DebuggerNonUserCode]
		[Browsable(false)]
		public CompanyDataTable Company => tableCompany;

		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[DebuggerNonUserCode]
		public CustomerInfoDataTable CustomerInfo => tableCustomerInfo;

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

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

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

		[DebuggerNonUserCode]
		protected dsFrmSaleContract(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["SaleBill"] != null)
				{
					base.Tables.Add(new SaleBillDataTable(dataSet.Tables["SaleBill"]));
				}
				if (dataSet.Tables["CessOut"] != null)
				{
					base.Tables.Add(new CessOutDataTable(dataSet.Tables["CessOut"]));
				}
				if (dataSet.Tables["Company"] != null)
				{
					base.Tables.Add(new CompanyDataTable(dataSet.Tables["Company"]));
				}
				if (dataSet.Tables["CustomerInfo"] != null)
				{
					base.Tables.Add(new CustomerInfoDataTable(dataSet.Tables["CustomerInfo"]));
				}
				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()
		{
			dsFrmSaleContract dsFrmSaleContract = (dsFrmSaleContract)base.Clone();
			dsFrmSaleContract.InitVars();
			dsFrmSaleContract.SchemaSerializationMode = SchemaSerializationMode;
			return dsFrmSaleContract;
		}

		[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["SaleBill"] != null)
				{
					base.Tables.Add(new SaleBillDataTable(dataSet.Tables["SaleBill"]));
				}
				if (dataSet.Tables["CessOut"] != null)
				{
					base.Tables.Add(new CessOutDataTable(dataSet.Tables["CessOut"]));
				}
				if (dataSet.Tables["Company"] != null)
				{
					base.Tables.Add(new CompanyDataTable(dataSet.Tables["Company"]));
				}
				if (dataSet.Tables["CustomerInfo"] != null)
				{
					base.Tables.Add(new CustomerInfoDataTable(dataSet.Tables["CustomerInfo"]));
				}
				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)
		{
			tableSaleBill = (SaleBillDataTable)base.Tables["SaleBill"];
			if (initTable && tableSaleBill != null)
			{
				tableSaleBill.InitVars();
			}
			tableCessOut = (CessOutDataTable)base.Tables["CessOut"];
			if (initTable && tableCessOut != null)
			{
				tableCessOut.InitVars();
			}
			tableCompany = (CompanyDataTable)base.Tables["Company"];
			if (initTable && tableCompany != null)
			{
				tableCompany.InitVars();
			}
			tableCustomerInfo = (CustomerInfoDataTable)base.Tables["CustomerInfo"];
			if (initTable && tableCustomerInfo != null)
			{
				tableCustomerInfo.InitVars();
			}
		}

		[DebuggerNonUserCode]
		private void InitClass()
		{
			base.DataSetName = "dsFrmSaleContract";
			base.Prefix = "";
			base.Namespace = "http://tempuri.org/dsFrmSaleContract.xsd";
			base.EnforceConstraints = true;
			SchemaSerializationMode = SchemaSerializationMode.IncludeSchema;
			tableSaleBill = new SaleBillDataTable();
			base.Tables.Add(tableSaleBill);
			tableCessOut = new CessOutDataTable();
			base.Tables.Add(tableCessOut);
			tableCompany = new CompanyDataTable();
			base.Tables.Add(tableCompany);
			tableCustomerInfo = new CustomerInfoDataTable();
			base.Tables.Add(tableCustomerInfo);
		}

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

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

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

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

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

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