sanlu_new/sanlu_c#/SunRoxmServer/SunRoxm.BizPeri.ReportDataSet/SunRoxm.BizPeri.ReportDataSet.ReportDataSet/dsFrmCustomer.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")]
	[XmlRoot("dsFrmCustomer")]
	[HelpKeyword("vs.data.DataSet")]
	[ToolboxItem(true)]
	[XmlSchemaProvider("GetTypedDataSetSchema")]
	[DesignerCategory("code")]
	public class dsFrmCustomer : DataSet
	{
		public delegate void TelephoneRowChangeEventHandler(object sender, TelephoneRowChangeEvent e);

		public delegate void CustomerRowChangeEventHandler(object sender, CustomerRowChangeEvent e);

		public delegate void EmployeeRowChangeEventHandler(object sender, EmployeeRowChangeEvent e);

		public delegate void InvoiceRowChangeEventHandler(object sender, InvoiceRowChangeEvent e);

		public delegate void PrincipalRowChangeEventHandler(object sender, PrincipalRowChangeEvent e);

		public delegate void LinkmanRowChangeEventHandler(object sender, LinkmanRowChangeEvent e);

		public delegate void FaxRowChangeEventHandler(object sender, FaxRowChangeEvent e);

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

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

			private DataColumn columnNo_Telephone;

			private DataColumn columnFocus_Telephone;

			[DebuggerNonUserCode]
			public DataColumn Name_TelephoneColumn => columnName_Telephone;

			[DebuggerNonUserCode]
			public DataColumn No_TelephoneColumn => columnNo_Telephone;

			[DebuggerNonUserCode]
			public DataColumn Focus_TelephoneColumn => columnFocus_Telephone;

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

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

			public event TelephoneRowChangeEventHandler TelephoneRowChanging;

			public event TelephoneRowChangeEventHandler TelephoneRowChanged;

			public event TelephoneRowChangeEventHandler TelephoneRowDeleting;

			public event TelephoneRowChangeEventHandler TelephoneRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddTelephoneRow(TelephoneRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public TelephoneRow AddTelephoneRow(string Name_Telephone, string No_Telephone, bool Focus_Telephone)
			{
				TelephoneRow telephoneRow = (TelephoneRow)NewRow();
				telephoneRow.ItemArray = new object[3]
				{
					Name_Telephone,
					No_Telephone,
					Focus_Telephone
				};
				base.Rows.Add(telephoneRow);
				return telephoneRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnName_Telephone = base.Columns["Name_Telephone"];
				columnNo_Telephone = base.Columns["No_Telephone"];
				columnFocus_Telephone = base.Columns["Focus_Telephone"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnName_Telephone = new DataColumn("Name_Telephone", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Telephone);
				columnNo_Telephone = new DataColumn("No_Telephone", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_Telephone);
				columnFocus_Telephone = new DataColumn("Focus_Telephone", typeof(bool), null, MappingType.Element);
				base.Columns.Add(columnFocus_Telephone);
			}

			[DebuggerNonUserCode]
			public TelephoneRow NewTelephoneRow()
			{
				return (TelephoneRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveTelephoneRow(TelephoneRow row)
			{
				base.Rows.Remove(row);
			}

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

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

			private DataColumn columnShortName_Customer;

			private DataColumn columnName_Customer;

			private DataColumn columnRegistedAddress_Customer;

			private DataColumn columnCountry_Customer;

			private DataColumn columnPostalCode_Customer;

			private DataColumn columnType_Customer;

			private DataColumn columnIsGeneric_Customer;

			private DataColumn columnPayLimitCurrency;

			private DataColumn columnPayLimit_Customer;

			private DataColumn columnGetMethod_Customer;

			private DataColumn columnCreateDate_Customer;

			private DataColumn columnSendAddr_Customer;

			private DataColumn columnComment_Customer;

			private DataColumn columnIndustry_Customer;

			private DataColumn columnZone_Customer;

			private DataColumn columnSource_Customer;

			private DataColumn columnLevel_Customer;

			private DataColumn columnBank_Customer;

			private DataColumn columnAccount_Customer;

			private DataColumn columnRevenueRegisterNo_Customer;

			private DataColumn columnLastDiscount_Customer;

			private DataColumn columnSuspendDate_Customer;

			private DataColumn columnToGetBalance_Customer;

			private DataColumn columnPrePayBalance_Customer;

			private DataColumn columnLastTax_Customer;

			private DataColumn columnLastModDate_Customer;

			private DataColumn columnCreatorName_Customer;

			private DataColumn columnLastModUser;

			private DataColumn columnCountryName;

			[DebuggerNonUserCode]
			public DataColumn No_CustomerColumn => columnNo_Customer;

			[DebuggerNonUserCode]
			public DataColumn ShortName_CustomerColumn => columnShortName_Customer;

			[DebuggerNonUserCode]
			public DataColumn Name_CustomerColumn => columnName_Customer;

			[DebuggerNonUserCode]
			public DataColumn RegistedAddress_CustomerColumn => columnRegistedAddress_Customer;

			[DebuggerNonUserCode]
			public DataColumn Country_CustomerColumn => columnCountry_Customer;

			[DebuggerNonUserCode]
			public DataColumn PostalCode_CustomerColumn => columnPostalCode_Customer;

			[DebuggerNonUserCode]
			public DataColumn Type_CustomerColumn => columnType_Customer;

			[DebuggerNonUserCode]
			public DataColumn IsGeneric_CustomerColumn => columnIsGeneric_Customer;

			[DebuggerNonUserCode]
			public DataColumn PayLimitCurrencyColumn => columnPayLimitCurrency;

			[DebuggerNonUserCode]
			public DataColumn PayLimit_CustomerColumn => columnPayLimit_Customer;

			[DebuggerNonUserCode]
			public DataColumn GetMethod_CustomerColumn => columnGetMethod_Customer;

			[DebuggerNonUserCode]
			public DataColumn CreateDate_CustomerColumn => columnCreateDate_Customer;

			[DebuggerNonUserCode]
			public DataColumn SendAddr_CustomerColumn => columnSendAddr_Customer;

			[DebuggerNonUserCode]
			public DataColumn Comment_CustomerColumn => columnComment_Customer;

			[DebuggerNonUserCode]
			public DataColumn Industry_CustomerColumn => columnIndustry_Customer;

			[DebuggerNonUserCode]
			public DataColumn Zone_CustomerColumn => columnZone_Customer;

			[DebuggerNonUserCode]
			public DataColumn Source_CustomerColumn => columnSource_Customer;

			[DebuggerNonUserCode]
			public DataColumn Level_CustomerColumn => columnLevel_Customer;

			[DebuggerNonUserCode]
			public DataColumn Bank_CustomerColumn => columnBank_Customer;

			[DebuggerNonUserCode]
			public DataColumn Account_CustomerColumn => columnAccount_Customer;

			[DebuggerNonUserCode]
			public DataColumn RevenueRegisterNo_CustomerColumn => columnRevenueRegisterNo_Customer;

			[DebuggerNonUserCode]
			public DataColumn LastDiscount_CustomerColumn => columnLastDiscount_Customer;

			[DebuggerNonUserCode]
			public DataColumn SuspendDate_CustomerColumn => columnSuspendDate_Customer;

			[DebuggerNonUserCode]
			public DataColumn ToGetBalance_CustomerColumn => columnToGetBalance_Customer;

			[DebuggerNonUserCode]
			public DataColumn PrePayBalance_CustomerColumn => columnPrePayBalance_Customer;

			[DebuggerNonUserCode]
			public DataColumn LastTax_CustomerColumn => columnLastTax_Customer;

			[DebuggerNonUserCode]
			public DataColumn LastModDate_CustomerColumn => columnLastModDate_Customer;

			[DebuggerNonUserCode]
			public DataColumn CreatorName_CustomerColumn => columnCreatorName_Customer;

			[DebuggerNonUserCode]
			public DataColumn LastModUserColumn => columnLastModUser;

			[DebuggerNonUserCode]
			public DataColumn CountryNameColumn => columnCountryName;

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

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

			public event CustomerRowChangeEventHandler CustomerRowChanging;

			public event CustomerRowChangeEventHandler CustomerRowChanged;

			public event CustomerRowChangeEventHandler CustomerRowDeleting;

			public event CustomerRowChangeEventHandler CustomerRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddCustomerRow(CustomerRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public CustomerRow AddCustomerRow(string No_Customer, string ShortName_Customer, string Name_Customer, string RegistedAddress_Customer, int Country_Customer, string PostalCode_Customer, string Type_Customer, bool IsGeneric_Customer, string PayLimitCurrency, decimal PayLimit_Customer, string GetMethod_Customer, DateTime CreateDate_Customer, string SendAddr_Customer, string Comment_Customer, string Industry_Customer, string Zone_Customer, string Source_Customer, string Level_Customer, string Bank_Customer, string Account_Customer, string RevenueRegisterNo_Customer, decimal LastDiscount_Customer, DateTime SuspendDate_Customer, decimal ToGetBalance_Customer, decimal PrePayBalance_Customer, string LastTax_Customer, DateTime LastModDate_Customer, string CreatorName_Customer, string LastModUser, string CountryName)
			{
				CustomerRow customerRow = (CustomerRow)NewRow();
				customerRow.ItemArray = new object[30]
				{
					No_Customer,
					ShortName_Customer,
					Name_Customer,
					RegistedAddress_Customer,
					Country_Customer,
					PostalCode_Customer,
					Type_Customer,
					IsGeneric_Customer,
					PayLimitCurrency,
					PayLimit_Customer,
					GetMethod_Customer,
					CreateDate_Customer,
					SendAddr_Customer,
					Comment_Customer,
					Industry_Customer,
					Zone_Customer,
					Source_Customer,
					Level_Customer,
					Bank_Customer,
					Account_Customer,
					RevenueRegisterNo_Customer,
					LastDiscount_Customer,
					SuspendDate_Customer,
					ToGetBalance_Customer,
					PrePayBalance_Customer,
					LastTax_Customer,
					LastModDate_Customer,
					CreatorName_Customer,
					LastModUser,
					CountryName
				};
				base.Rows.Add(customerRow);
				return customerRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnNo_Customer = base.Columns["No_Customer"];
				columnShortName_Customer = base.Columns["ShortName_Customer"];
				columnName_Customer = base.Columns["Name_Customer"];
				columnRegistedAddress_Customer = base.Columns["RegistedAddress_Customer"];
				columnCountry_Customer = base.Columns["Country_Customer"];
				columnPostalCode_Customer = base.Columns["PostalCode_Customer"];
				columnType_Customer = base.Columns["Type_Customer"];
				columnIsGeneric_Customer = base.Columns["IsGeneric_Customer"];
				columnPayLimitCurrency = base.Columns["PayLimitCurrency"];
				columnPayLimit_Customer = base.Columns["PayLimit_Customer"];
				columnGetMethod_Customer = base.Columns["GetMethod_Customer"];
				columnCreateDate_Customer = base.Columns["CreateDate_Customer"];
				columnSendAddr_Customer = base.Columns["SendAddr_Customer"];
				columnComment_Customer = base.Columns["Comment_Customer"];
				columnIndustry_Customer = base.Columns["Industry_Customer"];
				columnZone_Customer = base.Columns["Zone_Customer"];
				columnSource_Customer = base.Columns["Source_Customer"];
				columnLevel_Customer = base.Columns["Level_Customer"];
				columnBank_Customer = base.Columns["Bank_Customer"];
				columnAccount_Customer = base.Columns["Account_Customer"];
				columnRevenueRegisterNo_Customer = base.Columns["RevenueRegisterNo_Customer"];
				columnLastDiscount_Customer = base.Columns["LastDiscount_Customer"];
				columnSuspendDate_Customer = base.Columns["SuspendDate_Customer"];
				columnToGetBalance_Customer = base.Columns["ToGetBalance_Customer"];
				columnPrePayBalance_Customer = base.Columns["PrePayBalance_Customer"];
				columnLastTax_Customer = base.Columns["LastTax_Customer"];
				columnLastModDate_Customer = base.Columns["LastModDate_Customer"];
				columnCreatorName_Customer = base.Columns["CreatorName_Customer"];
				columnLastModUser = base.Columns["LastModUser"];
				columnCountryName = base.Columns["CountryName"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnNo_Customer = new DataColumn("No_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_Customer);
				columnShortName_Customer = new DataColumn("ShortName_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnShortName_Customer);
				columnName_Customer = new DataColumn("Name_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Customer);
				columnRegistedAddress_Customer = new DataColumn("RegistedAddress_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnRegistedAddress_Customer);
				columnCountry_Customer = new DataColumn("Country_Customer", typeof(int), null, MappingType.Element);
				base.Columns.Add(columnCountry_Customer);
				columnPostalCode_Customer = new DataColumn("PostalCode_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnPostalCode_Customer);
				columnType_Customer = new DataColumn("Type_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnType_Customer);
				columnIsGeneric_Customer = new DataColumn("IsGeneric_Customer", typeof(bool), null, MappingType.Element);
				base.Columns.Add(columnIsGeneric_Customer);
				columnPayLimitCurrency = new DataColumn("PayLimitCurrency", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnPayLimitCurrency);
				columnPayLimit_Customer = new DataColumn("PayLimit_Customer", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnPayLimit_Customer);
				columnGetMethod_Customer = new DataColumn("GetMethod_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnGetMethod_Customer);
				columnCreateDate_Customer = new DataColumn("CreateDate_Customer", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnCreateDate_Customer);
				columnSendAddr_Customer = new DataColumn("SendAddr_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnSendAddr_Customer);
				columnComment_Customer = new DataColumn("Comment_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnComment_Customer);
				columnIndustry_Customer = new DataColumn("Industry_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnIndustry_Customer);
				columnZone_Customer = new DataColumn("Zone_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnZone_Customer);
				columnSource_Customer = new DataColumn("Source_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnSource_Customer);
				columnLevel_Customer = new DataColumn("Level_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnLevel_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);
				columnRevenueRegisterNo_Customer = new DataColumn("RevenueRegisterNo_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnRevenueRegisterNo_Customer);
				columnLastDiscount_Customer = new DataColumn("LastDiscount_Customer", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnLastDiscount_Customer);
				columnSuspendDate_Customer = new DataColumn("SuspendDate_Customer", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnSuspendDate_Customer);
				columnToGetBalance_Customer = new DataColumn("ToGetBalance_Customer", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnToGetBalance_Customer);
				columnPrePayBalance_Customer = new DataColumn("PrePayBalance_Customer", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnPrePayBalance_Customer);
				columnLastTax_Customer = new DataColumn("LastTax_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnLastTax_Customer);
				columnLastModDate_Customer = new DataColumn("LastModDate_Customer", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnLastModDate_Customer);
				columnCreatorName_Customer = new DataColumn("CreatorName_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnCreatorName_Customer);
				columnLastModUser = new DataColumn("LastModUser", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnLastModUser);
				columnCountryName = new DataColumn("CountryName", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnCountryName);
			}

			[DebuggerNonUserCode]
			public CustomerRow NewCustomerRow()
			{
				return (CustomerRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveCustomerRow(CustomerRow row)
			{
				base.Rows.Remove(row);
			}

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

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

			private DataColumn columnName_Employee;

			private DataColumn columnEmployeeNo_Employee;

			private DataColumn columnNameEng_Employee;

			private DataColumn columnGender_Employee;

			private DataColumn columnCountry_Employee;

			private DataColumn columnHomeplace_Employee;

			private DataColumn columnNation_Employee;

			private DataColumn columnIDNo_Employee;

			private DataColumn columnPassport_Employee;

			private DataColumn columnIsMarried_Employee;

			private DataColumn columnCreateDate_Employee;

			private DataColumn columnDuty_Employee;

			private DataColumn columnProbation_Employee;

			private DataColumn columnOnJobDate_Employee;

			private DataColumn columnOnDuty_Employee;

			private DataColumn columnObJobStatus_Employee;

			private DataColumn columnOffDuty_Employee;

			private DataColumn columnSuspendDate_Employee;

			private DataColumn columnTel_Employee;

			private DataColumn columnEMail_Employee;

			private DataColumn columnAddress_Employee;

			private DataColumn columnComment_Employee;

			private DataColumn columnLastModDate_Employee;

			[DebuggerNonUserCode]
			public DataColumn No_EmployeeColumn => columnNo_Employee;

			[DebuggerNonUserCode]
			public DataColumn Name_EmployeeColumn => columnName_Employee;

			[DebuggerNonUserCode]
			public DataColumn EmployeeNo_EmployeeColumn => columnEmployeeNo_Employee;

			[DebuggerNonUserCode]
			public DataColumn NameEng_EmployeeColumn => columnNameEng_Employee;

			[DebuggerNonUserCode]
			public DataColumn Gender_EmployeeColumn => columnGender_Employee;

			[DebuggerNonUserCode]
			public DataColumn Country_EmployeeColumn => columnCountry_Employee;

			[DebuggerNonUserCode]
			public DataColumn Homeplace_EmployeeColumn => columnHomeplace_Employee;

			[DebuggerNonUserCode]
			public DataColumn Nation_EmployeeColumn => columnNation_Employee;

			[DebuggerNonUserCode]
			public DataColumn IDNo_EmployeeColumn => columnIDNo_Employee;

			[DebuggerNonUserCode]
			public DataColumn Passport_EmployeeColumn => columnPassport_Employee;

			[DebuggerNonUserCode]
			public DataColumn IsMarried_EmployeeColumn => columnIsMarried_Employee;

			[DebuggerNonUserCode]
			public DataColumn CreateDate_EmployeeColumn => columnCreateDate_Employee;

			[DebuggerNonUserCode]
			public DataColumn Duty_EmployeeColumn => columnDuty_Employee;

			[DebuggerNonUserCode]
			public DataColumn Probation_EmployeeColumn => columnProbation_Employee;

			[DebuggerNonUserCode]
			public DataColumn OnJobDate_EmployeeColumn => columnOnJobDate_Employee;

			[DebuggerNonUserCode]
			public DataColumn OnDuty_EmployeeColumn => columnOnDuty_Employee;

			[DebuggerNonUserCode]
			public DataColumn ObJobStatus_EmployeeColumn => columnObJobStatus_Employee;

			[DebuggerNonUserCode]
			public DataColumn OffDuty_EmployeeColumn => columnOffDuty_Employee;

			[DebuggerNonUserCode]
			public DataColumn SuspendDate_EmployeeColumn => columnSuspendDate_Employee;

			[DebuggerNonUserCode]
			public DataColumn Tel_EmployeeColumn => columnTel_Employee;

			[DebuggerNonUserCode]
			public DataColumn EMail_EmployeeColumn => columnEMail_Employee;

			[DebuggerNonUserCode]
			public DataColumn Address_EmployeeColumn => columnAddress_Employee;

			[DebuggerNonUserCode]
			public DataColumn Comment_EmployeeColumn => columnComment_Employee;

			[DebuggerNonUserCode]
			public DataColumn LastModDate_EmployeeColumn => columnLastModDate_Employee;

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

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

			public event EmployeeRowChangeEventHandler EmployeeRowChanging;

			public event EmployeeRowChangeEventHandler EmployeeRowChanged;

			public event EmployeeRowChangeEventHandler EmployeeRowDeleting;

			public event EmployeeRowChangeEventHandler EmployeeRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddEmployeeRow(EmployeeRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public EmployeeRow AddEmployeeRow(string No_Employee, string Name_Employee, string EmployeeNo_Employee, string NameEng_Employee, bool Gender_Employee, int Country_Employee, string Homeplace_Employee, string Nation_Employee, string IDNo_Employee, string Passport_Employee, bool IsMarried_Employee, DateTime CreateDate_Employee, string Duty_Employee, decimal Probation_Employee, DateTime OnJobDate_Employee, DateTime OnDuty_Employee, int ObJobStatus_Employee, DateTime OffDuty_Employee, DateTime SuspendDate_Employee, string Tel_Employee, string EMail_Employee, string Address_Employee, string Comment_Employee, DateTime LastModDate_Employee)
			{
				EmployeeRow employeeRow = (EmployeeRow)NewRow();
				employeeRow.ItemArray = new object[24]
				{
					No_Employee,
					Name_Employee,
					EmployeeNo_Employee,
					NameEng_Employee,
					Gender_Employee,
					Country_Employee,
					Homeplace_Employee,
					Nation_Employee,
					IDNo_Employee,
					Passport_Employee,
					IsMarried_Employee,
					CreateDate_Employee,
					Duty_Employee,
					Probation_Employee,
					OnJobDate_Employee,
					OnDuty_Employee,
					ObJobStatus_Employee,
					OffDuty_Employee,
					SuspendDate_Employee,
					Tel_Employee,
					EMail_Employee,
					Address_Employee,
					Comment_Employee,
					LastModDate_Employee
				};
				base.Rows.Add(employeeRow);
				return employeeRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnNo_Employee = base.Columns["No_Employee"];
				columnName_Employee = base.Columns["Name_Employee"];
				columnEmployeeNo_Employee = base.Columns["EmployeeNo_Employee"];
				columnNameEng_Employee = base.Columns["NameEng_Employee"];
				columnGender_Employee = base.Columns["Gender_Employee"];
				columnCountry_Employee = base.Columns["Country_Employee"];
				columnHomeplace_Employee = base.Columns["Homeplace_Employee"];
				columnNation_Employee = base.Columns["Nation_Employee"];
				columnIDNo_Employee = base.Columns["IDNo_Employee"];
				columnPassport_Employee = base.Columns["Passport_Employee"];
				columnIsMarried_Employee = base.Columns["IsMarried_Employee"];
				columnCreateDate_Employee = base.Columns["CreateDate_Employee"];
				columnDuty_Employee = base.Columns["Duty_Employee"];
				columnProbation_Employee = base.Columns["Probation_Employee"];
				columnOnJobDate_Employee = base.Columns["OnJobDate_Employee"];
				columnOnDuty_Employee = base.Columns["OnDuty_Employee"];
				columnObJobStatus_Employee = base.Columns["ObJobStatus_Employee"];
				columnOffDuty_Employee = base.Columns["OffDuty_Employee"];
				columnSuspendDate_Employee = base.Columns["SuspendDate_Employee"];
				columnTel_Employee = base.Columns["Tel_Employee"];
				columnEMail_Employee = base.Columns["EMail_Employee"];
				columnAddress_Employee = base.Columns["Address_Employee"];
				columnComment_Employee = base.Columns["Comment_Employee"];
				columnLastModDate_Employee = base.Columns["LastModDate_Employee"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnNo_Employee = new DataColumn("No_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_Employee);
				columnName_Employee = new DataColumn("Name_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Employee);
				columnEmployeeNo_Employee = new DataColumn("EmployeeNo_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnEmployeeNo_Employee);
				columnNameEng_Employee = new DataColumn("NameEng_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNameEng_Employee);
				columnGender_Employee = new DataColumn("Gender_Employee", typeof(bool), null, MappingType.Element);
				base.Columns.Add(columnGender_Employee);
				columnCountry_Employee = new DataColumn("Country_Employee", typeof(int), null, MappingType.Element);
				base.Columns.Add(columnCountry_Employee);
				columnHomeplace_Employee = new DataColumn("Homeplace_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnHomeplace_Employee);
				columnNation_Employee = new DataColumn("Nation_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNation_Employee);
				columnIDNo_Employee = new DataColumn("IDNo_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnIDNo_Employee);
				columnPassport_Employee = new DataColumn("Passport_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnPassport_Employee);
				columnIsMarried_Employee = new DataColumn("IsMarried_Employee", typeof(bool), null, MappingType.Element);
				base.Columns.Add(columnIsMarried_Employee);
				columnCreateDate_Employee = new DataColumn("CreateDate_Employee", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnCreateDate_Employee);
				columnDuty_Employee = new DataColumn("Duty_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnDuty_Employee);
				columnProbation_Employee = new DataColumn("Probation_Employee", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnProbation_Employee);
				columnOnJobDate_Employee = new DataColumn("OnJobDate_Employee", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnOnJobDate_Employee);
				columnOnDuty_Employee = new DataColumn("OnDuty_Employee", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnOnDuty_Employee);
				columnObJobStatus_Employee = new DataColumn("ObJobStatus_Employee", typeof(int), null, MappingType.Element);
				base.Columns.Add(columnObJobStatus_Employee);
				columnOffDuty_Employee = new DataColumn("OffDuty_Employee", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnOffDuty_Employee);
				columnSuspendDate_Employee = new DataColumn("SuspendDate_Employee", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnSuspendDate_Employee);
				columnTel_Employee = new DataColumn("Tel_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnTel_Employee);
				columnEMail_Employee = new DataColumn("EMail_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnEMail_Employee);
				columnAddress_Employee = new DataColumn("Address_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnAddress_Employee);
				columnComment_Employee = new DataColumn("Comment_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnComment_Employee);
				columnLastModDate_Employee = new DataColumn("LastModDate_Employee", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnLastModDate_Employee);
			}

			[DebuggerNonUserCode]
			public EmployeeRow NewEmployeeRow()
			{
				return (EmployeeRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveEmployeeRow(EmployeeRow row)
			{
				base.Rows.Remove(row);
			}

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

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

			private DataColumn columnAddress_Invoice;

			private DataColumn columnTel_Invoice;

			private DataColumn columnLinkman_Invoice;

			private DataColumn columnCommon_Invoice;

			private DataColumn columnComment_Invoice;

			[DebuggerNonUserCode]
			public DataColumn Title_InvoiceColumn => columnTitle_Invoice;

			[DebuggerNonUserCode]
			public DataColumn Address_InvoiceColumn => columnAddress_Invoice;

			[DebuggerNonUserCode]
			public DataColumn Tel_InvoiceColumn => columnTel_Invoice;

			[DebuggerNonUserCode]
			public DataColumn Linkman_InvoiceColumn => columnLinkman_Invoice;

			[DebuggerNonUserCode]
			public DataColumn Common_InvoiceColumn => columnCommon_Invoice;

			[DebuggerNonUserCode]
			public DataColumn Comment_InvoiceColumn => columnComment_Invoice;

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

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

			public event InvoiceRowChangeEventHandler InvoiceRowChanging;

			public event InvoiceRowChangeEventHandler InvoiceRowChanged;

			public event InvoiceRowChangeEventHandler InvoiceRowDeleting;

			public event InvoiceRowChangeEventHandler InvoiceRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddInvoiceRow(InvoiceRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public InvoiceRow AddInvoiceRow(string Title_Invoice, string Address_Invoice, string Tel_Invoice, string Linkman_Invoice, bool Common_Invoice, string Comment_Invoice)
			{
				InvoiceRow invoiceRow = (InvoiceRow)NewRow();
				invoiceRow.ItemArray = new object[6]
				{
					Title_Invoice,
					Address_Invoice,
					Tel_Invoice,
					Linkman_Invoice,
					Common_Invoice,
					Comment_Invoice
				};
				base.Rows.Add(invoiceRow);
				return invoiceRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnTitle_Invoice = base.Columns["Title_Invoice"];
				columnAddress_Invoice = base.Columns["Address_Invoice"];
				columnTel_Invoice = base.Columns["Tel_Invoice"];
				columnLinkman_Invoice = base.Columns["Linkman_Invoice"];
				columnCommon_Invoice = base.Columns["Common_Invoice"];
				columnComment_Invoice = base.Columns["Comment_Invoice"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnTitle_Invoice = new DataColumn("Title_Invoice", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnTitle_Invoice);
				columnAddress_Invoice = new DataColumn("Address_Invoice", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnAddress_Invoice);
				columnTel_Invoice = new DataColumn("Tel_Invoice", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnTel_Invoice);
				columnLinkman_Invoice = new DataColumn("Linkman_Invoice", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnLinkman_Invoice);
				columnCommon_Invoice = new DataColumn("Common_Invoice", typeof(bool), null, MappingType.Element);
				base.Columns.Add(columnCommon_Invoice);
				columnComment_Invoice = new DataColumn("Comment_Invoice", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnComment_Invoice);
			}

			[DebuggerNonUserCode]
			public InvoiceRow NewInvoiceRow()
			{
				return (InvoiceRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveInvoiceRow(InvoiceRow row)
			{
				base.Rows.Remove(row);
			}

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

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

			private DataColumn columnComment_Principal;

			private DataColumn columnName_Employee;

			private DataColumn columnNo_Employee;

			[DebuggerNonUserCode]
			public DataColumn IsMain_PrincipalColumn => columnIsMain_Principal;

			[DebuggerNonUserCode]
			public DataColumn Comment_PrincipalColumn => columnComment_Principal;

			[DebuggerNonUserCode]
			public DataColumn Name_EmployeeColumn => columnName_Employee;

			[DebuggerNonUserCode]
			public DataColumn No_EmployeeColumn => columnNo_Employee;

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

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

			public event PrincipalRowChangeEventHandler PrincipalRowChanging;

			public event PrincipalRowChangeEventHandler PrincipalRowChanged;

			public event PrincipalRowChangeEventHandler PrincipalRowDeleting;

			public event PrincipalRowChangeEventHandler PrincipalRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddPrincipalRow(PrincipalRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public PrincipalRow AddPrincipalRow(bool IsMain_Principal, string Comment_Principal, string Name_Employee, string No_Employee)
			{
				PrincipalRow principalRow = (PrincipalRow)NewRow();
				principalRow.ItemArray = new object[4]
				{
					IsMain_Principal,
					Comment_Principal,
					Name_Employee,
					No_Employee
				};
				base.Rows.Add(principalRow);
				return principalRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnIsMain_Principal = base.Columns["IsMain_Principal"];
				columnComment_Principal = base.Columns["Comment_Principal"];
				columnName_Employee = base.Columns["Name_Employee"];
				columnNo_Employee = base.Columns["No_Employee"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnIsMain_Principal = new DataColumn("IsMain_Principal", typeof(bool), null, MappingType.Element);
				base.Columns.Add(columnIsMain_Principal);
				columnComment_Principal = new DataColumn("Comment_Principal", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnComment_Principal);
				columnName_Employee = new DataColumn("Name_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Employee);
				columnNo_Employee = new DataColumn("No_Employee", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_Employee);
			}

			[DebuggerNonUserCode]
			public PrincipalRow NewPrincipalRow()
			{
				return (PrincipalRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemovePrincipalRow(PrincipalRow row)
			{
				base.Rows.Remove(row);
			}

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

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

			private DataColumn columnDepartment_Linkman;

			private DataColumn columnDuty_Linkman;

			private DataColumn columnTel_Linkman;

			private DataColumn columnFax_Linkman;

			private DataColumn columnMobile_Linkman;

			private DataColumn columnEmail_Linkman;

			private DataColumn columnIsMain_Linkman;

			private DataColumn columnComment_Linkman;

			[DebuggerNonUserCode]
			public DataColumn Name_LinkmanColumn => columnName_Linkman;

			[DebuggerNonUserCode]
			public DataColumn Department_LinkmanColumn => columnDepartment_Linkman;

			[DebuggerNonUserCode]
			public DataColumn Duty_LinkmanColumn => columnDuty_Linkman;

			[DebuggerNonUserCode]
			public DataColumn Tel_LinkmanColumn => columnTel_Linkman;

			[DebuggerNonUserCode]
			public DataColumn Fax_LinkmanColumn => columnFax_Linkman;

			[DebuggerNonUserCode]
			public DataColumn Mobile_LinkmanColumn => columnMobile_Linkman;

			[DebuggerNonUserCode]
			public DataColumn Email_LinkmanColumn => columnEmail_Linkman;

			[DebuggerNonUserCode]
			public DataColumn IsMain_LinkmanColumn => columnIsMain_Linkman;

			[DebuggerNonUserCode]
			public DataColumn Comment_LinkmanColumn => columnComment_Linkman;

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

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

			public event LinkmanRowChangeEventHandler LinkmanRowChanging;

			public event LinkmanRowChangeEventHandler LinkmanRowChanged;

			public event LinkmanRowChangeEventHandler LinkmanRowDeleting;

			public event LinkmanRowChangeEventHandler LinkmanRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddLinkmanRow(LinkmanRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public LinkmanRow AddLinkmanRow(string Name_Linkman, string Department_Linkman, string Duty_Linkman, string Tel_Linkman, string Fax_Linkman, string Mobile_Linkman, string Email_Linkman, bool IsMain_Linkman, string Comment_Linkman)
			{
				LinkmanRow linkmanRow = (LinkmanRow)NewRow();
				linkmanRow.ItemArray = new object[9]
				{
					Name_Linkman,
					Department_Linkman,
					Duty_Linkman,
					Tel_Linkman,
					Fax_Linkman,
					Mobile_Linkman,
					Email_Linkman,
					IsMain_Linkman,
					Comment_Linkman
				};
				base.Rows.Add(linkmanRow);
				return linkmanRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnName_Linkman = base.Columns["Name_Linkman"];
				columnDepartment_Linkman = base.Columns["Department_Linkman"];
				columnDuty_Linkman = base.Columns["Duty_Linkman"];
				columnTel_Linkman = base.Columns["Tel_Linkman"];
				columnFax_Linkman = base.Columns["Fax_Linkman"];
				columnMobile_Linkman = base.Columns["Mobile_Linkman"];
				columnEmail_Linkman = base.Columns["Email_Linkman"];
				columnIsMain_Linkman = base.Columns["IsMain_Linkman"];
				columnComment_Linkman = base.Columns["Comment_Linkman"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnName_Linkman = new DataColumn("Name_Linkman", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Linkman);
				columnDepartment_Linkman = new DataColumn("Department_Linkman", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnDepartment_Linkman);
				columnDuty_Linkman = new DataColumn("Duty_Linkman", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnDuty_Linkman);
				columnTel_Linkman = new DataColumn("Tel_Linkman", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnTel_Linkman);
				columnFax_Linkman = new DataColumn("Fax_Linkman", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnFax_Linkman);
				columnMobile_Linkman = new DataColumn("Mobile_Linkman", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnMobile_Linkman);
				columnEmail_Linkman = new DataColumn("Email_Linkman", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnEmail_Linkman);
				columnIsMain_Linkman = new DataColumn("IsMain_Linkman", typeof(bool), null, MappingType.Element);
				base.Columns.Add(columnIsMain_Linkman);
				columnComment_Linkman = new DataColumn("Comment_Linkman", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnComment_Linkman);
			}

			[DebuggerNonUserCode]
			public LinkmanRow NewLinkmanRow()
			{
				return (LinkmanRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveLinkmanRow(LinkmanRow row)
			{
				base.Rows.Remove(row);
			}

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

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

			private DataColumn columnNo_Fax;

			private DataColumn columnFocus_Fax;

			[DebuggerNonUserCode]
			public DataColumn Name_FaxColumn => columnName_Fax;

			[DebuggerNonUserCode]
			public DataColumn No_FaxColumn => columnNo_Fax;

			[DebuggerNonUserCode]
			public DataColumn Focus_FaxColumn => columnFocus_Fax;

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

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

			public event FaxRowChangeEventHandler FaxRowChanging;

			public event FaxRowChangeEventHandler FaxRowChanged;

			public event FaxRowChangeEventHandler FaxRowDeleting;

			public event FaxRowChangeEventHandler FaxRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddFaxRow(FaxRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public FaxRow AddFaxRow(string Name_Fax, string No_Fax, bool Focus_Fax)
			{
				FaxRow faxRow = (FaxRow)NewRow();
				faxRow.ItemArray = new object[3]
				{
					Name_Fax,
					No_Fax,
					Focus_Fax
				};
				base.Rows.Add(faxRow);
				return faxRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnName_Fax = base.Columns["Name_Fax"];
				columnNo_Fax = base.Columns["No_Fax"];
				columnFocus_Fax = base.Columns["Focus_Fax"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnName_Fax = new DataColumn("Name_Fax", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Fax);
				columnNo_Fax = new DataColumn("No_Fax", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_Fax);
				columnFocus_Fax = new DataColumn("Focus_Fax", typeof(bool), null, MappingType.Element);
				base.Columns.Add(columnFocus_Fax);
			}

			[DebuggerNonUserCode]
			public FaxRow NewFaxRow()
			{
				return (FaxRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveFaxRow(FaxRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsFrmCustomer dsFrmCustomer = new dsFrmCustomer();
				xs.Add(dsFrmCustomer.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 = dsFrmCustomer.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "FaxDataTable";
				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();
				dsFrmCustomer dsFrmCustomer = new dsFrmCustomer();
				xs.Add(dsFrmCustomer.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 = dsFrmCustomer.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 TelephoneRow : DataRow
		{
			private TelephoneDataTable tableTelephone;

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

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

			[DebuggerNonUserCode]
			public bool Focus_Telephone
			{
				get
				{
					try
					{
						return (bool)base[tableTelephone.Focus_TelephoneColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Focus_Telephone' in table 'Telephone' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableTelephone.Focus_TelephoneColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			internal TelephoneRow(DataRowBuilder rb)
				: base(rb)
			{
				tableTelephone = (TelephoneDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsName_TelephoneNull()
			{
				return IsNull(tableTelephone.Name_TelephoneColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_TelephoneNull()
			{
				base[tableTelephone.Name_TelephoneColumn] = Convert.DBNull;
			}

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

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

			[DebuggerNonUserCode]
			public bool IsFocus_TelephoneNull()
			{
				return IsNull(tableTelephone.Focus_TelephoneColumn);
			}

			[DebuggerNonUserCode]
			public void SetFocus_TelephoneNull()
			{
				base[tableTelephone.Focus_TelephoneColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class CustomerRow : DataRow
		{
			private CustomerDataTable tableCustomer;

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

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

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

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

			[DebuggerNonUserCode]
			public int Country_Customer
			{
				get
				{
					try
					{
						return (int)base[tableCustomer.Country_CustomerColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Country_Customer' in table 'Customer' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableCustomer.Country_CustomerColumn] = value;
				}
			}

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

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

			[DebuggerNonUserCode]
			public bool IsGeneric_Customer
			{
				get
				{
					try
					{
						return (bool)base[tableCustomer.IsGeneric_CustomerColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'IsGeneric_Customer' in table 'Customer' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableCustomer.IsGeneric_CustomerColumn] = value;
				}
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			internal CustomerRow(DataRowBuilder rb)
				: base(rb)
			{
				tableCustomer = (CustomerDataTable)base.Table;
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsRegistedAddress_CustomerNull()
			{
				return IsNull(tableCustomer.RegistedAddress_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetRegistedAddress_CustomerNull()
			{
				base[tableCustomer.RegistedAddress_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCountry_CustomerNull()
			{
				return IsNull(tableCustomer.Country_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetCountry_CustomerNull()
			{
				base[tableCustomer.Country_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsPostalCode_CustomerNull()
			{
				return IsNull(tableCustomer.PostalCode_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetPostalCode_CustomerNull()
			{
				base[tableCustomer.PostalCode_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsType_CustomerNull()
			{
				return IsNull(tableCustomer.Type_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetType_CustomerNull()
			{
				base[tableCustomer.Type_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsIsGeneric_CustomerNull()
			{
				return IsNull(tableCustomer.IsGeneric_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetIsGeneric_CustomerNull()
			{
				base[tableCustomer.IsGeneric_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsPayLimitCurrencyNull()
			{
				return IsNull(tableCustomer.PayLimitCurrencyColumn);
			}

			[DebuggerNonUserCode]
			public void SetPayLimitCurrencyNull()
			{
				base[tableCustomer.PayLimitCurrencyColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsPayLimit_CustomerNull()
			{
				return IsNull(tableCustomer.PayLimit_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetPayLimit_CustomerNull()
			{
				base[tableCustomer.PayLimit_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsGetMethod_CustomerNull()
			{
				return IsNull(tableCustomer.GetMethod_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetGetMethod_CustomerNull()
			{
				base[tableCustomer.GetMethod_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCreateDate_CustomerNull()
			{
				return IsNull(tableCustomer.CreateDate_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetCreateDate_CustomerNull()
			{
				base[tableCustomer.CreateDate_CustomerColumn] = Convert.DBNull;
			}

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

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

			[DebuggerNonUserCode]
			public bool IsComment_CustomerNull()
			{
				return IsNull(tableCustomer.Comment_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetComment_CustomerNull()
			{
				base[tableCustomer.Comment_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsIndustry_CustomerNull()
			{
				return IsNull(tableCustomer.Industry_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetIndustry_CustomerNull()
			{
				base[tableCustomer.Industry_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsZone_CustomerNull()
			{
				return IsNull(tableCustomer.Zone_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetZone_CustomerNull()
			{
				base[tableCustomer.Zone_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSource_CustomerNull()
			{
				return IsNull(tableCustomer.Source_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetSource_CustomerNull()
			{
				base[tableCustomer.Source_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsLevel_CustomerNull()
			{
				return IsNull(tableCustomer.Level_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetLevel_CustomerNull()
			{
				base[tableCustomer.Level_CustomerColumn] = Convert.DBNull;
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsLastDiscount_CustomerNull()
			{
				return IsNull(tableCustomer.LastDiscount_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetLastDiscount_CustomerNull()
			{
				base[tableCustomer.LastDiscount_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSuspendDate_CustomerNull()
			{
				return IsNull(tableCustomer.SuspendDate_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetSuspendDate_CustomerNull()
			{
				base[tableCustomer.SuspendDate_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsToGetBalance_CustomerNull()
			{
				return IsNull(tableCustomer.ToGetBalance_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetToGetBalance_CustomerNull()
			{
				base[tableCustomer.ToGetBalance_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsPrePayBalance_CustomerNull()
			{
				return IsNull(tableCustomer.PrePayBalance_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetPrePayBalance_CustomerNull()
			{
				base[tableCustomer.PrePayBalance_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsLastTax_CustomerNull()
			{
				return IsNull(tableCustomer.LastTax_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetLastTax_CustomerNull()
			{
				base[tableCustomer.LastTax_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsLastModDate_CustomerNull()
			{
				return IsNull(tableCustomer.LastModDate_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetLastModDate_CustomerNull()
			{
				base[tableCustomer.LastModDate_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCreatorName_CustomerNull()
			{
				return IsNull(tableCustomer.CreatorName_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetCreatorName_CustomerNull()
			{
				base[tableCustomer.CreatorName_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsLastModUserNull()
			{
				return IsNull(tableCustomer.LastModUserColumn);
			}

			[DebuggerNonUserCode]
			public void SetLastModUserNull()
			{
				base[tableCustomer.LastModUserColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCountryNameNull()
			{
				return IsNull(tableCustomer.CountryNameColumn);
			}

			[DebuggerNonUserCode]
			public void SetCountryNameNull()
			{
				base[tableCustomer.CountryNameColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class EmployeeRow : DataRow
		{
			private EmployeeDataTable tableEmployee;

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

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

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

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

			[DebuggerNonUserCode]
			public bool Gender_Employee
			{
				get
				{
					try
					{
						return (bool)base[tableEmployee.Gender_EmployeeColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Gender_Employee' in table 'Employee' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableEmployee.Gender_EmployeeColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			public int Country_Employee
			{
				get
				{
					try
					{
						return (int)base[tableEmployee.Country_EmployeeColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Country_Employee' in table 'Employee' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableEmployee.Country_EmployeeColumn] = value;
				}
			}

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsMarried_Employee
			{
				get
				{
					try
					{
						return (bool)base[tableEmployee.IsMarried_EmployeeColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'IsMarried_Employee' in table 'Employee' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableEmployee.IsMarried_EmployeeColumn] = value;
				}
			}

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

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

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

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

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

			[DebuggerNonUserCode]
			public int ObJobStatus_Employee
			{
				get
				{
					try
					{
						return (int)base[tableEmployee.ObJobStatus_EmployeeColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'ObJobStatus_Employee' in table 'Employee' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableEmployee.ObJobStatus_EmployeeColumn] = value;
				}
			}

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			internal EmployeeRow(DataRowBuilder rb)
				: base(rb)
			{
				tableEmployee = (EmployeeDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsNo_EmployeeNull()
			{
				return IsNull(tableEmployee.No_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_EmployeeNull()
			{
				base[tableEmployee.No_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsName_EmployeeNull()
			{
				return IsNull(tableEmployee.Name_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_EmployeeNull()
			{
				base[tableEmployee.Name_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEmployeeNo_EmployeeNull()
			{
				return IsNull(tableEmployee.EmployeeNo_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetEmployeeNo_EmployeeNull()
			{
				base[tableEmployee.EmployeeNo_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsNameEng_EmployeeNull()
			{
				return IsNull(tableEmployee.NameEng_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetNameEng_EmployeeNull()
			{
				base[tableEmployee.NameEng_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsGender_EmployeeNull()
			{
				return IsNull(tableEmployee.Gender_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetGender_EmployeeNull()
			{
				base[tableEmployee.Gender_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCountry_EmployeeNull()
			{
				return IsNull(tableEmployee.Country_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetCountry_EmployeeNull()
			{
				base[tableEmployee.Country_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsHomeplace_EmployeeNull()
			{
				return IsNull(tableEmployee.Homeplace_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetHomeplace_EmployeeNull()
			{
				base[tableEmployee.Homeplace_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsNation_EmployeeNull()
			{
				return IsNull(tableEmployee.Nation_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetNation_EmployeeNull()
			{
				base[tableEmployee.Nation_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsIDNo_EmployeeNull()
			{
				return IsNull(tableEmployee.IDNo_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetIDNo_EmployeeNull()
			{
				base[tableEmployee.IDNo_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsPassport_EmployeeNull()
			{
				return IsNull(tableEmployee.Passport_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetPassport_EmployeeNull()
			{
				base[tableEmployee.Passport_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsIsMarried_EmployeeNull()
			{
				return IsNull(tableEmployee.IsMarried_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetIsMarried_EmployeeNull()
			{
				base[tableEmployee.IsMarried_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCreateDate_EmployeeNull()
			{
				return IsNull(tableEmployee.CreateDate_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetCreateDate_EmployeeNull()
			{
				base[tableEmployee.CreateDate_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsDuty_EmployeeNull()
			{
				return IsNull(tableEmployee.Duty_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetDuty_EmployeeNull()
			{
				base[tableEmployee.Duty_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsProbation_EmployeeNull()
			{
				return IsNull(tableEmployee.Probation_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetProbation_EmployeeNull()
			{
				base[tableEmployee.Probation_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsOnJobDate_EmployeeNull()
			{
				return IsNull(tableEmployee.OnJobDate_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetOnJobDate_EmployeeNull()
			{
				base[tableEmployee.OnJobDate_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsOnDuty_EmployeeNull()
			{
				return IsNull(tableEmployee.OnDuty_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetOnDuty_EmployeeNull()
			{
				base[tableEmployee.OnDuty_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsObJobStatus_EmployeeNull()
			{
				return IsNull(tableEmployee.ObJobStatus_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetObJobStatus_EmployeeNull()
			{
				base[tableEmployee.ObJobStatus_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsOffDuty_EmployeeNull()
			{
				return IsNull(tableEmployee.OffDuty_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetOffDuty_EmployeeNull()
			{
				base[tableEmployee.OffDuty_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSuspendDate_EmployeeNull()
			{
				return IsNull(tableEmployee.SuspendDate_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetSuspendDate_EmployeeNull()
			{
				base[tableEmployee.SuspendDate_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTel_EmployeeNull()
			{
				return IsNull(tableEmployee.Tel_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetTel_EmployeeNull()
			{
				base[tableEmployee.Tel_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEMail_EmployeeNull()
			{
				return IsNull(tableEmployee.EMail_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetEMail_EmployeeNull()
			{
				base[tableEmployee.EMail_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAddress_EmployeeNull()
			{
				return IsNull(tableEmployee.Address_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetAddress_EmployeeNull()
			{
				base[tableEmployee.Address_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsComment_EmployeeNull()
			{
				return IsNull(tableEmployee.Comment_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetComment_EmployeeNull()
			{
				base[tableEmployee.Comment_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsLastModDate_EmployeeNull()
			{
				return IsNull(tableEmployee.LastModDate_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetLastModDate_EmployeeNull()
			{
				base[tableEmployee.LastModDate_EmployeeColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class InvoiceRow : DataRow
		{
			private InvoiceDataTable tableInvoice;

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

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

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

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

			[DebuggerNonUserCode]
			public bool Common_Invoice
			{
				get
				{
					try
					{
						return (bool)base[tableInvoice.Common_InvoiceColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Common_Invoice' in table 'Invoice' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableInvoice.Common_InvoiceColumn] = value;
				}
			}

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

			[DebuggerNonUserCode]
			internal InvoiceRow(DataRowBuilder rb)
				: base(rb)
			{
				tableInvoice = (InvoiceDataTable)base.Table;
			}

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsTel_InvoiceNull()
			{
				return IsNull(tableInvoice.Tel_InvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetTel_InvoiceNull()
			{
				base[tableInvoice.Tel_InvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsLinkman_InvoiceNull()
			{
				return IsNull(tableInvoice.Linkman_InvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetLinkman_InvoiceNull()
			{
				base[tableInvoice.Linkman_InvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCommon_InvoiceNull()
			{
				return IsNull(tableInvoice.Common_InvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetCommon_InvoiceNull()
			{
				base[tableInvoice.Common_InvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsComment_InvoiceNull()
			{
				return IsNull(tableInvoice.Comment_InvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetComment_InvoiceNull()
			{
				base[tableInvoice.Comment_InvoiceColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class PrincipalRow : DataRow
		{
			private PrincipalDataTable tablePrincipal;

			[DebuggerNonUserCode]
			public bool IsMain_Principal
			{
				get
				{
					try
					{
						return (bool)base[tablePrincipal.IsMain_PrincipalColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'IsMain_Principal' in table 'Principal' is DBNull.", innerException);
					}
				}
				set
				{
					base[tablePrincipal.IsMain_PrincipalColumn] = value;
				}
			}

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

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

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

			[DebuggerNonUserCode]
			internal PrincipalRow(DataRowBuilder rb)
				: base(rb)
			{
				tablePrincipal = (PrincipalDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsIsMain_PrincipalNull()
			{
				return IsNull(tablePrincipal.IsMain_PrincipalColumn);
			}

			[DebuggerNonUserCode]
			public void SetIsMain_PrincipalNull()
			{
				base[tablePrincipal.IsMain_PrincipalColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsComment_PrincipalNull()
			{
				return IsNull(tablePrincipal.Comment_PrincipalColumn);
			}

			[DebuggerNonUserCode]
			public void SetComment_PrincipalNull()
			{
				base[tablePrincipal.Comment_PrincipalColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsName_EmployeeNull()
			{
				return IsNull(tablePrincipal.Name_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_EmployeeNull()
			{
				base[tablePrincipal.Name_EmployeeColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsNo_EmployeeNull()
			{
				return IsNull(tablePrincipal.No_EmployeeColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_EmployeeNull()
			{
				base[tablePrincipal.No_EmployeeColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class LinkmanRow : DataRow
		{
			private LinkmanDataTable tableLinkman;

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsMain_Linkman
			{
				get
				{
					try
					{
						return (bool)base[tableLinkman.IsMain_LinkmanColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'IsMain_Linkman' in table 'Linkman' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableLinkman.IsMain_LinkmanColumn] = value;
				}
			}

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

			[DebuggerNonUserCode]
			internal LinkmanRow(DataRowBuilder rb)
				: base(rb)
			{
				tableLinkman = (LinkmanDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsName_LinkmanNull()
			{
				return IsNull(tableLinkman.Name_LinkmanColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_LinkmanNull()
			{
				base[tableLinkman.Name_LinkmanColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsDepartment_LinkmanNull()
			{
				return IsNull(tableLinkman.Department_LinkmanColumn);
			}

			[DebuggerNonUserCode]
			public void SetDepartment_LinkmanNull()
			{
				base[tableLinkman.Department_LinkmanColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsDuty_LinkmanNull()
			{
				return IsNull(tableLinkman.Duty_LinkmanColumn);
			}

			[DebuggerNonUserCode]
			public void SetDuty_LinkmanNull()
			{
				base[tableLinkman.Duty_LinkmanColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTel_LinkmanNull()
			{
				return IsNull(tableLinkman.Tel_LinkmanColumn);
			}

			[DebuggerNonUserCode]
			public void SetTel_LinkmanNull()
			{
				base[tableLinkman.Tel_LinkmanColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsFax_LinkmanNull()
			{
				return IsNull(tableLinkman.Fax_LinkmanColumn);
			}

			[DebuggerNonUserCode]
			public void SetFax_LinkmanNull()
			{
				base[tableLinkman.Fax_LinkmanColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsMobile_LinkmanNull()
			{
				return IsNull(tableLinkman.Mobile_LinkmanColumn);
			}

			[DebuggerNonUserCode]
			public void SetMobile_LinkmanNull()
			{
				base[tableLinkman.Mobile_LinkmanColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEmail_LinkmanNull()
			{
				return IsNull(tableLinkman.Email_LinkmanColumn);
			}

			[DebuggerNonUserCode]
			public void SetEmail_LinkmanNull()
			{
				base[tableLinkman.Email_LinkmanColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsIsMain_LinkmanNull()
			{
				return IsNull(tableLinkman.IsMain_LinkmanColumn);
			}

			[DebuggerNonUserCode]
			public void SetIsMain_LinkmanNull()
			{
				base[tableLinkman.IsMain_LinkmanColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsComment_LinkmanNull()
			{
				return IsNull(tableLinkman.Comment_LinkmanColumn);
			}

			[DebuggerNonUserCode]
			public void SetComment_LinkmanNull()
			{
				base[tableLinkman.Comment_LinkmanColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class FaxRow : DataRow
		{
			private FaxDataTable tableFax;

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

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

			[DebuggerNonUserCode]
			public bool Focus_Fax
			{
				get
				{
					try
					{
						return (bool)base[tableFax.Focus_FaxColumn];
					}
					catch (InvalidCastException innerException)
					{
						throw new StrongTypingException("The value for column 'Focus_Fax' in table 'Fax' is DBNull.", innerException);
					}
				}
				set
				{
					base[tableFax.Focus_FaxColumn] = value;
				}
			}

			[DebuggerNonUserCode]
			internal FaxRow(DataRowBuilder rb)
				: base(rb)
			{
				tableFax = (FaxDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsName_FaxNull()
			{
				return IsNull(tableFax.Name_FaxColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_FaxNull()
			{
				base[tableFax.Name_FaxColumn] = Convert.DBNull;
			}

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

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

			[DebuggerNonUserCode]
			public bool IsFocus_FaxNull()
			{
				return IsNull(tableFax.Focus_FaxColumn);
			}

			[DebuggerNonUserCode]
			public void SetFocus_FaxNull()
			{
				base[tableFax.Focus_FaxColumn] = 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 TelephoneRowChangeEvent : EventArgs
		{
			private TelephoneRow eventRow;

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public TelephoneRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public CustomerRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public EmployeeRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public InvoiceRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public PrincipalRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public LinkmanRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public FaxRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

			[DebuggerNonUserCode]
			public FaxRowChangeEvent(FaxRow 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 TelephoneDataTable tableTelephone;

		private CustomerDataTable tableCustomer;

		private EmployeeDataTable tableEmployee;

		private InvoiceDataTable tableInvoice;

		private PrincipalDataTable tablePrincipal;

		private LinkmanDataTable tableLinkman;

		private FaxDataTable tableFax;

		private AppendInfoDataTable tableAppendInfo;

		private SchemaSerializationMode _schemaSerializationMode = SchemaSerializationMode.IncludeSchema;

		[Browsable(false)]
		[DebuggerNonUserCode]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		public TelephoneDataTable Telephone => tableTelephone;

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[DebuggerNonUserCode]
		[Browsable(false)]
		public CustomerDataTable Customer => tableCustomer;

		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[DebuggerNonUserCode]
		public EmployeeDataTable Employee => tableEmployee;

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[Browsable(false)]
		[DebuggerNonUserCode]
		public InvoiceDataTable Invoice => tableInvoice;

		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[DebuggerNonUserCode]
		public PrincipalDataTable Principal => tablePrincipal;

		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[DebuggerNonUserCode]
		public LinkmanDataTable Linkman => tableLinkman;

		[DebuggerNonUserCode]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[Browsable(false)]
		public FaxDataTable Fax => tableFax;

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

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

		[DebuggerNonUserCode]
		protected dsFrmCustomer(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["Telephone"] != null)
				{
					base.Tables.Add(new TelephoneDataTable(dataSet.Tables["Telephone"]));
				}
				if (dataSet.Tables["Customer"] != null)
				{
					base.Tables.Add(new CustomerDataTable(dataSet.Tables["Customer"]));
				}
				if (dataSet.Tables["Employee"] != null)
				{
					base.Tables.Add(new EmployeeDataTable(dataSet.Tables["Employee"]));
				}
				if (dataSet.Tables["Invoice"] != null)
				{
					base.Tables.Add(new InvoiceDataTable(dataSet.Tables["Invoice"]));
				}
				if (dataSet.Tables["Principal"] != null)
				{
					base.Tables.Add(new PrincipalDataTable(dataSet.Tables["Principal"]));
				}
				if (dataSet.Tables["Linkman"] != null)
				{
					base.Tables.Add(new LinkmanDataTable(dataSet.Tables["Linkman"]));
				}
				if (dataSet.Tables["Fax"] != null)
				{
					base.Tables.Add(new FaxDataTable(dataSet.Tables["Fax"]));
				}
				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()
		{
			dsFrmCustomer dsFrmCustomer = (dsFrmCustomer)base.Clone();
			dsFrmCustomer.InitVars();
			dsFrmCustomer.SchemaSerializationMode = SchemaSerializationMode;
			return dsFrmCustomer;
		}

		[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["Telephone"] != null)
				{
					base.Tables.Add(new TelephoneDataTable(dataSet.Tables["Telephone"]));
				}
				if (dataSet.Tables["Customer"] != null)
				{
					base.Tables.Add(new CustomerDataTable(dataSet.Tables["Customer"]));
				}
				if (dataSet.Tables["Employee"] != null)
				{
					base.Tables.Add(new EmployeeDataTable(dataSet.Tables["Employee"]));
				}
				if (dataSet.Tables["Invoice"] != null)
				{
					base.Tables.Add(new InvoiceDataTable(dataSet.Tables["Invoice"]));
				}
				if (dataSet.Tables["Principal"] != null)
				{
					base.Tables.Add(new PrincipalDataTable(dataSet.Tables["Principal"]));
				}
				if (dataSet.Tables["Linkman"] != null)
				{
					base.Tables.Add(new LinkmanDataTable(dataSet.Tables["Linkman"]));
				}
				if (dataSet.Tables["Fax"] != null)
				{
					base.Tables.Add(new FaxDataTable(dataSet.Tables["Fax"]));
				}
				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)
		{
			tableTelephone = (TelephoneDataTable)base.Tables["Telephone"];
			if (initTable && tableTelephone != null)
			{
				tableTelephone.InitVars();
			}
			tableCustomer = (CustomerDataTable)base.Tables["Customer"];
			if (initTable && tableCustomer != null)
			{
				tableCustomer.InitVars();
			}
			tableEmployee = (EmployeeDataTable)base.Tables["Employee"];
			if (initTable && tableEmployee != null)
			{
				tableEmployee.InitVars();
			}
			tableInvoice = (InvoiceDataTable)base.Tables["Invoice"];
			if (initTable && tableInvoice != null)
			{
				tableInvoice.InitVars();
			}
			tablePrincipal = (PrincipalDataTable)base.Tables["Principal"];
			if (initTable && tablePrincipal != null)
			{
				tablePrincipal.InitVars();
			}
			tableLinkman = (LinkmanDataTable)base.Tables["Linkman"];
			if (initTable && tableLinkman != null)
			{
				tableLinkman.InitVars();
			}
			tableFax = (FaxDataTable)base.Tables["Fax"];
			if (initTable && tableFax != null)
			{
				tableFax.InitVars();
			}
			tableAppendInfo = (AppendInfoDataTable)base.Tables["AppendInfo"];
			if (initTable && tableAppendInfo != null)
			{
				tableAppendInfo.InitVars();
			}
		}

		[DebuggerNonUserCode]
		private void InitClass()
		{
			base.DataSetName = "dsFrmCustomer";
			base.Prefix = "";
			base.Namespace = "http://tempuri.org/dsFrmCustomer.xsd";
			base.EnforceConstraints = true;
			SchemaSerializationMode = SchemaSerializationMode.IncludeSchema;
			tableTelephone = new TelephoneDataTable();
			base.Tables.Add(tableTelephone);
			tableCustomer = new CustomerDataTable();
			base.Tables.Add(tableCustomer);
			tableEmployee = new EmployeeDataTable();
			base.Tables.Add(tableEmployee);
			tableInvoice = new InvoiceDataTable();
			base.Tables.Add(tableInvoice);
			tablePrincipal = new PrincipalDataTable();
			base.Tables.Add(tablePrincipal);
			tableLinkman = new LinkmanDataTable();
			base.Tables.Add(tableLinkman);
			tableFax = new FaxDataTable();
			base.Tables.Add(tableFax);
			tableAppendInfo = new AppendInfoDataTable();
			base.Tables.Add(tableAppendInfo);
		}

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

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

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

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

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

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

		[DebuggerNonUserCode]
		private bool ShouldSerializeFax()
		{
			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)
		{
			dsFrmCustomer dsFrmCustomer = new dsFrmCustomer();
			XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
			XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
			xs.Add(dsFrmCustomer.GetSchemaSerializable());
			XmlSchemaAny xmlSchemaAny = new XmlSchemaAny();
			xmlSchemaAny.Namespace = dsFrmCustomer.Namespace;
			xmlSchemaSequence.Items.Add(xmlSchemaAny);
			xmlSchemaComplexType.Particle = xmlSchemaSequence;
			return xmlSchemaComplexType;
		}
	}
}