sanlu_new/sanlu_c#/SunRoxmServer/SunRoxm.BizPeri.ReportDataSet/SunRoxm.BizPeri.ReportDataSet.ReportDataSet/dsFrmSaleInvoicce.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.Globalization;
using System.IO;
using System.Runtime.Serialization;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;

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

		public delegate void SaleInvoiceProductRowChangeEventHandler(object sender, SaleInvoiceProductRowChangeEvent e);

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

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

			private DataColumn columnDate_SaleInvoice;

			private DataColumn columnType_SaleInvoice;

			private DataColumn columnInvoiceDate_SaleInvoice;

			private DataColumn columnNo_Invoice;

			private DataColumn columnInvoiceAddress_SaleInvoice;

			private DataColumn columnInvoiceTitle_SaleInvoice;

			private DataColumn columnBank_SaleInvoice;

			private DataColumn columnAccount_SaleInvoice;

			private DataColumn columnCurrency_SaleInvoice;

			private DataColumn columnPayDate_SaleInvoice;

			private DataColumn columnCreateDate_SaleInvoice;

			private DataColumn columnLastModDate_SaleInvoice;

			private DataColumn columnAssessDate_SaleInvoice;

			private DataColumn columnDisable_SaleInvoice;

			private DataColumn columnAmount_SaleInvoice;

			private DataColumn columnIncludeTax_SaleInvoice;

			private DataColumn columnGoodsAmount_SaleInvoice;

			private DataColumn columnTaxAmount_SaleInvoice;

			private DataColumn columnStrikedAmount_SaleInvoice;

			private DataColumn columnDiscountAmount_SaleInvoice;

			private DataColumn columnCreator;

			private DataColumn columnAssessor;

			private DataColumn columnLastModUser;

			private DataColumn columnNo_Customer;

			private DataColumn columnShortName_Customer;

			private DataColumn columnRevenueRegisterNo_Customer;

			private DataColumn columnBank_Customer;

			private DataColumn columnAccount_Customer;

			private DataColumn columnGetMethod_Customer;

			private DataColumn columnTypeName;

			private DataColumn columnStartDate;

			private DataColumn columnEndDate;

			private DataColumn columnckRtn;

			[DebuggerNonUserCode]
			public DataColumn No_SaleInvoiceColumn => columnNo_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn Date_SaleInvoiceColumn => columnDate_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn Type_SaleInvoiceColumn => columnType_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn InvoiceDate_SaleInvoiceColumn => columnInvoiceDate_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn No_InvoiceColumn => columnNo_Invoice;

			[DebuggerNonUserCode]
			public DataColumn InvoiceAddress_SaleInvoiceColumn => columnInvoiceAddress_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn InvoiceTitle_SaleInvoiceColumn => columnInvoiceTitle_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn Bank_SaleInvoiceColumn => columnBank_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn Account_SaleInvoiceColumn => columnAccount_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn Currency_SaleInvoiceColumn => columnCurrency_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn PayDate_SaleInvoiceColumn => columnPayDate_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn CreateDate_SaleInvoiceColumn => columnCreateDate_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn LastModDate_SaleInvoiceColumn => columnLastModDate_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn AssessDate_SaleInvoiceColumn => columnAssessDate_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn Disable_SaleInvoiceColumn => columnDisable_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn Amount_SaleInvoiceColumn => columnAmount_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn IncludeTax_SaleInvoiceColumn => columnIncludeTax_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn GoodsAmount_SaleInvoiceColumn => columnGoodsAmount_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn TaxAmount_SaleInvoiceColumn => columnTaxAmount_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn StrikedAmount_SaleInvoiceColumn => columnStrikedAmount_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn DiscountAmount_SaleInvoiceColumn => columnDiscountAmount_SaleInvoice;

			[DebuggerNonUserCode]
			public DataColumn CreatorColumn => columnCreator;

			[DebuggerNonUserCode]
			public DataColumn AssessorColumn => columnAssessor;

			[DebuggerNonUserCode]
			public DataColumn LastModUserColumn => columnLastModUser;

			[DebuggerNonUserCode]
			public DataColumn No_CustomerColumn => columnNo_Customer;

			[DebuggerNonUserCode]
			public DataColumn ShortName_CustomerColumn => columnShortName_Customer;

			[DebuggerNonUserCode]
			public DataColumn RevenueRegisterNo_CustomerColumn => columnRevenueRegisterNo_Customer;

			[DebuggerNonUserCode]
			public DataColumn Bank_CustomerColumn => columnBank_Customer;

			[DebuggerNonUserCode]
			public DataColumn Account_CustomerColumn => columnAccount_Customer;

			[DebuggerNonUserCode]
			public DataColumn GetMethod_CustomerColumn => columnGetMethod_Customer;

			[DebuggerNonUserCode]
			public DataColumn TypeNameColumn => columnTypeName;

			[DebuggerNonUserCode]
			public DataColumn StartDateColumn => columnStartDate;

			[DebuggerNonUserCode]
			public DataColumn EndDateColumn => columnEndDate;

			[DebuggerNonUserCode]
			public DataColumn ckRtnColumn => columnckRtn;

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

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

			public event SaleInvoiceRowChangeEventHandler SaleInvoiceRowChanging;

			public event SaleInvoiceRowChangeEventHandler SaleInvoiceRowChanged;

			public event SaleInvoiceRowChangeEventHandler SaleInvoiceRowDeleting;

			public event SaleInvoiceRowChangeEventHandler SaleInvoiceRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddSaleInvoiceRow(SaleInvoiceRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public SaleInvoiceRow AddSaleInvoiceRow(string No_SaleInvoice, DateTime Date_SaleInvoice, int Type_SaleInvoice, DateTime InvoiceDate_SaleInvoice, string No_Invoice, string InvoiceAddress_SaleInvoice, string InvoiceTitle_SaleInvoice, string Bank_SaleInvoice, string Account_SaleInvoice, string Currency_SaleInvoice, DateTime PayDate_SaleInvoice, DateTime CreateDate_SaleInvoice, DateTime LastModDate_SaleInvoice, DateTime AssessDate_SaleInvoice, bool Disable_SaleInvoice, decimal Amount_SaleInvoice, bool IncludeTax_SaleInvoice, decimal GoodsAmount_SaleInvoice, decimal TaxAmount_SaleInvoice, decimal StrikedAmount_SaleInvoice, decimal DiscountAmount_SaleInvoice, string Creator, string Assessor, string LastModUser, string No_Customer, string ShortName_Customer, string RevenueRegisterNo_Customer, string Bank_Customer, string Account_Customer, string GetMethod_Customer, string TypeName, DateTime StartDate, DateTime EndDate, bool ckRtn)
			{
				SaleInvoiceRow saleInvoiceRow = (SaleInvoiceRow)NewRow();
				object[] array2 = saleInvoiceRow.ItemArray = new object[34]
				{
					No_SaleInvoice,
					Date_SaleInvoice,
					Type_SaleInvoice,
					InvoiceDate_SaleInvoice,
					No_Invoice,
					InvoiceAddress_SaleInvoice,
					InvoiceTitle_SaleInvoice,
					Bank_SaleInvoice,
					Account_SaleInvoice,
					Currency_SaleInvoice,
					PayDate_SaleInvoice,
					CreateDate_SaleInvoice,
					LastModDate_SaleInvoice,
					AssessDate_SaleInvoice,
					Disable_SaleInvoice,
					Amount_SaleInvoice,
					IncludeTax_SaleInvoice,
					GoodsAmount_SaleInvoice,
					TaxAmount_SaleInvoice,
					StrikedAmount_SaleInvoice,
					DiscountAmount_SaleInvoice,
					Creator,
					Assessor,
					LastModUser,
					No_Customer,
					ShortName_Customer,
					RevenueRegisterNo_Customer,
					Bank_Customer,
					Account_Customer,
					GetMethod_Customer,
					TypeName,
					StartDate,
					EndDate,
					ckRtn
				};
				base.Rows.Add(saleInvoiceRow);
				return saleInvoiceRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnNo_SaleInvoice = base.Columns["No_SaleInvoice"];
				columnDate_SaleInvoice = base.Columns["Date_SaleInvoice"];
				columnType_SaleInvoice = base.Columns["Type_SaleInvoice"];
				columnInvoiceDate_SaleInvoice = base.Columns["InvoiceDate_SaleInvoice"];
				columnNo_Invoice = base.Columns["No_Invoice"];
				columnInvoiceAddress_SaleInvoice = base.Columns["InvoiceAddress_SaleInvoice"];
				columnInvoiceTitle_SaleInvoice = base.Columns["InvoiceTitle_SaleInvoice"];
				columnBank_SaleInvoice = base.Columns["Bank_SaleInvoice"];
				columnAccount_SaleInvoice = base.Columns["Account_SaleInvoice"];
				columnCurrency_SaleInvoice = base.Columns["Currency_SaleInvoice"];
				columnPayDate_SaleInvoice = base.Columns["PayDate_SaleInvoice"];
				columnCreateDate_SaleInvoice = base.Columns["CreateDate_SaleInvoice"];
				columnLastModDate_SaleInvoice = base.Columns["LastModDate_SaleInvoice"];
				columnAssessDate_SaleInvoice = base.Columns["AssessDate_SaleInvoice"];
				columnDisable_SaleInvoice = base.Columns["Disable_SaleInvoice"];
				columnAmount_SaleInvoice = base.Columns["Amount_SaleInvoice"];
				columnIncludeTax_SaleInvoice = base.Columns["IncludeTax_SaleInvoice"];
				columnGoodsAmount_SaleInvoice = base.Columns["GoodsAmount_SaleInvoice"];
				columnTaxAmount_SaleInvoice = base.Columns["TaxAmount_SaleInvoice"];
				columnStrikedAmount_SaleInvoice = base.Columns["StrikedAmount_SaleInvoice"];
				columnDiscountAmount_SaleInvoice = base.Columns["DiscountAmount_SaleInvoice"];
				columnCreator = base.Columns["Creator"];
				columnAssessor = base.Columns["Assessor"];
				columnLastModUser = base.Columns["LastModUser"];
				columnNo_Customer = base.Columns["No_Customer"];
				columnShortName_Customer = base.Columns["ShortName_Customer"];
				columnRevenueRegisterNo_Customer = base.Columns["RevenueRegisterNo_Customer"];
				columnBank_Customer = base.Columns["Bank_Customer"];
				columnAccount_Customer = base.Columns["Account_Customer"];
				columnGetMethod_Customer = base.Columns["GetMethod_Customer"];
				columnTypeName = base.Columns["TypeName"];
				columnStartDate = base.Columns["StartDate"];
				columnEndDate = base.Columns["EndDate"];
				columnckRtn = base.Columns["ckRtn"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnNo_SaleInvoice = new DataColumn("No_SaleInvoice", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_SaleInvoice);
				columnDate_SaleInvoice = new DataColumn("Date_SaleInvoice", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnDate_SaleInvoice);
				columnType_SaleInvoice = new DataColumn("Type_SaleInvoice", typeof(int), null, MappingType.Element);
				base.Columns.Add(columnType_SaleInvoice);
				columnInvoiceDate_SaleInvoice = new DataColumn("InvoiceDate_SaleInvoice", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnInvoiceDate_SaleInvoice);
				columnNo_Invoice = new DataColumn("No_Invoice", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_Invoice);
				columnInvoiceAddress_SaleInvoice = new DataColumn("InvoiceAddress_SaleInvoice", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnInvoiceAddress_SaleInvoice);
				columnInvoiceTitle_SaleInvoice = new DataColumn("InvoiceTitle_SaleInvoice", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnInvoiceTitle_SaleInvoice);
				columnBank_SaleInvoice = new DataColumn("Bank_SaleInvoice", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnBank_SaleInvoice);
				columnAccount_SaleInvoice = new DataColumn("Account_SaleInvoice", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnAccount_SaleInvoice);
				columnCurrency_SaleInvoice = new DataColumn("Currency_SaleInvoice", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnCurrency_SaleInvoice);
				columnPayDate_SaleInvoice = new DataColumn("PayDate_SaleInvoice", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnPayDate_SaleInvoice);
				columnCreateDate_SaleInvoice = new DataColumn("CreateDate_SaleInvoice", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnCreateDate_SaleInvoice);
				columnLastModDate_SaleInvoice = new DataColumn("LastModDate_SaleInvoice", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnLastModDate_SaleInvoice);
				columnAssessDate_SaleInvoice = new DataColumn("AssessDate_SaleInvoice", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnAssessDate_SaleInvoice);
				columnDisable_SaleInvoice = new DataColumn("Disable_SaleInvoice", typeof(bool), null, MappingType.Element);
				base.Columns.Add(columnDisable_SaleInvoice);
				columnAmount_SaleInvoice = new DataColumn("Amount_SaleInvoice", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnAmount_SaleInvoice);
				columnIncludeTax_SaleInvoice = new DataColumn("IncludeTax_SaleInvoice", typeof(bool), null, MappingType.Element);
				base.Columns.Add(columnIncludeTax_SaleInvoice);
				columnGoodsAmount_SaleInvoice = new DataColumn("GoodsAmount_SaleInvoice", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnGoodsAmount_SaleInvoice);
				columnTaxAmount_SaleInvoice = new DataColumn("TaxAmount_SaleInvoice", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnTaxAmount_SaleInvoice);
				columnStrikedAmount_SaleInvoice = new DataColumn("StrikedAmount_SaleInvoice", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnStrikedAmount_SaleInvoice);
				columnDiscountAmount_SaleInvoice = new DataColumn("DiscountAmount_SaleInvoice", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnDiscountAmount_SaleInvoice);
				columnCreator = new DataColumn("Creator", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnCreator);
				columnAssessor = new DataColumn("Assessor", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnAssessor);
				columnLastModUser = new DataColumn("LastModUser", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnLastModUser);
				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);
				columnRevenueRegisterNo_Customer = new DataColumn("RevenueRegisterNo_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnRevenueRegisterNo_Customer);
				columnBank_Customer = new DataColumn("Bank_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnBank_Customer);
				columnAccount_Customer = new DataColumn("Account_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnAccount_Customer);
				columnGetMethod_Customer = new DataColumn("GetMethod_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnGetMethod_Customer);
				columnTypeName = new DataColumn("TypeName", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnTypeName);
				columnStartDate = new DataColumn("StartDate", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnStartDate);
				columnEndDate = new DataColumn("EndDate", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnEndDate);
				columnckRtn = new DataColumn("ckRtn", typeof(bool), null, MappingType.Element);
				base.Columns.Add(columnckRtn);
			}

			[DebuggerNonUserCode]
			public SaleInvoiceRow NewSaleInvoiceRow()
			{
				return (SaleInvoiceRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveSaleInvoiceRow(SaleInvoiceRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsFrmSaleInvoicce dsFrmSaleInvoicce = new dsFrmSaleInvoicce();
				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 = dsFrmSaleInvoicce.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "SaleInvoiceDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				XmlSchema schemaSerializable = dsFrmSaleInvoicce.GetSchemaSerializable();
				if (xs.Contains(schemaSerializable.TargetNamespace))
				{
					MemoryStream memoryStream = new MemoryStream();
					MemoryStream memoryStream2 = new MemoryStream();
					try
					{
						XmlSchema xmlSchema = null;
						schemaSerializable.Write(memoryStream);
						IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
						while (enumerator.MoveNext())
						{
							xmlSchema = (XmlSchema)enumerator.Current;
							memoryStream2.SetLength(0L);
							xmlSchema.Write(memoryStream2);
							if (memoryStream.Length == memoryStream2.Length)
							{
								memoryStream.Position = 0L;
								memoryStream2.Position = 0L;
								while (memoryStream.Position != memoryStream.Length && memoryStream.ReadByte() == memoryStream2.ReadByte())
								{
								}
								if (memoryStream.Position == memoryStream.Length)
								{
									return xmlSchemaComplexType;
								}
							}
						}
					}
					finally
					{
						memoryStream?.Close();
						memoryStream2?.Close();
					}
				}
				xs.Add(schemaSerializable);
				return xmlSchemaComplexType;
			}
		}

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

			private DataColumn columnNo_FromBill;

			private DataColumn columnNo_FromBillProduct;

			private DataColumn columnQuantity_SaleInvoiceProduct;

			private DataColumn columnUnitPrice_SaleInvoiceProduct;

			private DataColumn columnTaxRate_SaleInvoiceProduct;

			private DataColumn columnComment_SaleInvoiceProduct;

			private DataColumn columnAmount_SaleInvoiceProduct;

			private DataColumn columnTaxAmount_SaleInvoiceProduct;

			private DataColumn columnGoodsAmount_SaleInvoiceProduct;

			private DataColumn columnTaxCurrency_SaleInvoiceProduct;

			private DataColumn columnName_BillType;

			private DataColumn columnNo_Product;

			private DataColumn columnName_Product;

			private DataColumn columnInvoiceName_Product;

			private DataColumn columnUnit_Product;

			private DataColumn columnNegative;

			private DataColumn columnNo_Customer;

			private DataColumn columnShortName_Customer;

			private DataColumn columnMoney;

			[DebuggerNonUserCode]
			public DataColumn Type_FromBillColumn => columnType_FromBill;

			[DebuggerNonUserCode]
			public DataColumn No_FromBillColumn => columnNo_FromBill;

			[DebuggerNonUserCode]
			public DataColumn No_FromBillProductColumn => columnNo_FromBillProduct;

			[DebuggerNonUserCode]
			public DataColumn Quantity_SaleInvoiceProductColumn => columnQuantity_SaleInvoiceProduct;

			[DebuggerNonUserCode]
			public DataColumn UnitPrice_SaleInvoiceProductColumn => columnUnitPrice_SaleInvoiceProduct;

			[DebuggerNonUserCode]
			public DataColumn TaxRate_SaleInvoiceProductColumn => columnTaxRate_SaleInvoiceProduct;

			[DebuggerNonUserCode]
			public DataColumn Comment_SaleInvoiceProductColumn => columnComment_SaleInvoiceProduct;

			[DebuggerNonUserCode]
			public DataColumn Amount_SaleInvoiceProductColumn => columnAmount_SaleInvoiceProduct;

			[DebuggerNonUserCode]
			public DataColumn TaxAmount_SaleInvoiceProductColumn => columnTaxAmount_SaleInvoiceProduct;

			[DebuggerNonUserCode]
			public DataColumn GoodsAmount_SaleInvoiceProductColumn => columnGoodsAmount_SaleInvoiceProduct;

			[DebuggerNonUserCode]
			public DataColumn TaxCurrency_SaleInvoiceProductColumn => columnTaxCurrency_SaleInvoiceProduct;

			[DebuggerNonUserCode]
			public DataColumn Name_BillTypeColumn => columnName_BillType;

			[DebuggerNonUserCode]
			public DataColumn No_ProductColumn => columnNo_Product;

			[DebuggerNonUserCode]
			public DataColumn Name_ProductColumn => columnName_Product;

			[DebuggerNonUserCode]
			public DataColumn InvoiceName_ProductColumn => columnInvoiceName_Product;

			[DebuggerNonUserCode]
			public DataColumn Unit_ProductColumn => columnUnit_Product;

			[DebuggerNonUserCode]
			public DataColumn NegativeColumn => columnNegative;

			[DebuggerNonUserCode]
			public DataColumn No_CustomerColumn => columnNo_Customer;

			[DebuggerNonUserCode]
			public DataColumn ShortName_CustomerColumn => columnShortName_Customer;

			[DebuggerNonUserCode]
			public DataColumn MoneyColumn => columnMoney;

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

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

			public event SaleInvoiceProductRowChangeEventHandler SaleInvoiceProductRowChanging;

			public event SaleInvoiceProductRowChangeEventHandler SaleInvoiceProductRowChanged;

			public event SaleInvoiceProductRowChangeEventHandler SaleInvoiceProductRowDeleting;

			public event SaleInvoiceProductRowChangeEventHandler SaleInvoiceProductRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddSaleInvoiceProductRow(SaleInvoiceProductRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public SaleInvoiceProductRow AddSaleInvoiceProductRow(int Type_FromBill, string No_FromBill, string No_FromBillProduct, decimal Quantity_SaleInvoiceProduct, decimal UnitPrice_SaleInvoiceProduct, decimal TaxRate_SaleInvoiceProduct, string Comment_SaleInvoiceProduct, decimal Amount_SaleInvoiceProduct, decimal TaxAmount_SaleInvoiceProduct, decimal GoodsAmount_SaleInvoiceProduct, string TaxCurrency_SaleInvoiceProduct, string Name_BillType, string No_Product, string Name_Product, string InvoiceName_Product, string Unit_Product, bool Negative, string No_Customer, string ShortName_Customer, decimal Money)
			{
				SaleInvoiceProductRow saleInvoiceProductRow = (SaleInvoiceProductRow)NewRow();
				object[] array2 = saleInvoiceProductRow.ItemArray = new object[20]
				{
					Type_FromBill,
					No_FromBill,
					No_FromBillProduct,
					Quantity_SaleInvoiceProduct,
					UnitPrice_SaleInvoiceProduct,
					TaxRate_SaleInvoiceProduct,
					Comment_SaleInvoiceProduct,
					Amount_SaleInvoiceProduct,
					TaxAmount_SaleInvoiceProduct,
					GoodsAmount_SaleInvoiceProduct,
					TaxCurrency_SaleInvoiceProduct,
					Name_BillType,
					No_Product,
					Name_Product,
					InvoiceName_Product,
					Unit_Product,
					Negative,
					No_Customer,
					ShortName_Customer,
					Money
				};
				base.Rows.Add(saleInvoiceProductRow);
				return saleInvoiceProductRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnType_FromBill = base.Columns["Type_FromBill"];
				columnNo_FromBill = base.Columns["No_FromBill"];
				columnNo_FromBillProduct = base.Columns["No_FromBillProduct"];
				columnQuantity_SaleInvoiceProduct = base.Columns["Quantity_SaleInvoiceProduct"];
				columnUnitPrice_SaleInvoiceProduct = base.Columns["UnitPrice_SaleInvoiceProduct"];
				columnTaxRate_SaleInvoiceProduct = base.Columns["TaxRate_SaleInvoiceProduct"];
				columnComment_SaleInvoiceProduct = base.Columns["Comment_SaleInvoiceProduct"];
				columnAmount_SaleInvoiceProduct = base.Columns["Amount_SaleInvoiceProduct"];
				columnTaxAmount_SaleInvoiceProduct = base.Columns["TaxAmount_SaleInvoiceProduct"];
				columnGoodsAmount_SaleInvoiceProduct = base.Columns["GoodsAmount_SaleInvoiceProduct"];
				columnTaxCurrency_SaleInvoiceProduct = base.Columns["TaxCurrency_SaleInvoiceProduct"];
				columnName_BillType = base.Columns["Name_BillType"];
				columnNo_Product = base.Columns["No_Product"];
				columnName_Product = base.Columns["Name_Product"];
				columnInvoiceName_Product = base.Columns["InvoiceName_Product"];
				columnUnit_Product = base.Columns["Unit_Product"];
				columnNegative = base.Columns["Negative"];
				columnNo_Customer = base.Columns["No_Customer"];
				columnShortName_Customer = base.Columns["ShortName_Customer"];
				columnMoney = base.Columns["Money"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnType_FromBill = new DataColumn("Type_FromBill", typeof(int), null, MappingType.Element);
				base.Columns.Add(columnType_FromBill);
				columnNo_FromBill = new DataColumn("No_FromBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_FromBill);
				columnNo_FromBillProduct = new DataColumn("No_FromBillProduct", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_FromBillProduct);
				columnQuantity_SaleInvoiceProduct = new DataColumn("Quantity_SaleInvoiceProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnQuantity_SaleInvoiceProduct);
				columnUnitPrice_SaleInvoiceProduct = new DataColumn("UnitPrice_SaleInvoiceProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnUnitPrice_SaleInvoiceProduct);
				columnTaxRate_SaleInvoiceProduct = new DataColumn("TaxRate_SaleInvoiceProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnTaxRate_SaleInvoiceProduct);
				columnComment_SaleInvoiceProduct = new DataColumn("Comment_SaleInvoiceProduct", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnComment_SaleInvoiceProduct);
				columnAmount_SaleInvoiceProduct = new DataColumn("Amount_SaleInvoiceProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnAmount_SaleInvoiceProduct);
				columnTaxAmount_SaleInvoiceProduct = new DataColumn("TaxAmount_SaleInvoiceProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnTaxAmount_SaleInvoiceProduct);
				columnGoodsAmount_SaleInvoiceProduct = new DataColumn("GoodsAmount_SaleInvoiceProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnGoodsAmount_SaleInvoiceProduct);
				columnTaxCurrency_SaleInvoiceProduct = new DataColumn("TaxCurrency_SaleInvoiceProduct", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnTaxCurrency_SaleInvoiceProduct);
				columnName_BillType = new DataColumn("Name_BillType", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_BillType);
				columnNo_Product = new DataColumn("No_Product", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_Product);
				columnName_Product = new DataColumn("Name_Product", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Product);
				columnInvoiceName_Product = new DataColumn("InvoiceName_Product", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnInvoiceName_Product);
				columnUnit_Product = new DataColumn("Unit_Product", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnUnit_Product);
				columnNegative = new DataColumn("Negative", typeof(bool), null, MappingType.Element);
				base.Columns.Add(columnNegative);
				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);
				columnMoney = new DataColumn("Money", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnMoney);
			}

			[DebuggerNonUserCode]
			public SaleInvoiceProductRow NewSaleInvoiceProductRow()
			{
				return (SaleInvoiceProductRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveSaleInvoiceProductRow(SaleInvoiceProductRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsFrmSaleInvoicce dsFrmSaleInvoicce = new dsFrmSaleInvoicce();
				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 = dsFrmSaleInvoicce.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "SaleInvoiceProductDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				XmlSchema schemaSerializable = dsFrmSaleInvoicce.GetSchemaSerializable();
				if (xs.Contains(schemaSerializable.TargetNamespace))
				{
					MemoryStream memoryStream = new MemoryStream();
					MemoryStream memoryStream2 = new MemoryStream();
					try
					{
						XmlSchema xmlSchema = null;
						schemaSerializable.Write(memoryStream);
						IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
						while (enumerator.MoveNext())
						{
							xmlSchema = (XmlSchema)enumerator.Current;
							memoryStream2.SetLength(0L);
							xmlSchema.Write(memoryStream2);
							if (memoryStream.Length == memoryStream2.Length)
							{
								memoryStream.Position = 0L;
								memoryStream2.Position = 0L;
								while (memoryStream.Position != memoryStream.Length && memoryStream.ReadByte() == memoryStream2.ReadByte())
								{
								}
								if (memoryStream.Position == memoryStream.Length)
								{
									return xmlSchemaComplexType;
								}
							}
						}
					}
					finally
					{
						memoryStream?.Close();
						memoryStream2?.Close();
					}
				}
				xs.Add(schemaSerializable);
				return xmlSchemaComplexType;
			}
		}

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

			private DataColumn columnCurrentUser;

			[DebuggerNonUserCode]
			public DataColumn CurrentCompanyColumn => columnCurrentCompany;

			[DebuggerNonUserCode]
			public DataColumn CurrentUserColumn => columnCurrentUser;

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

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

			public event AppendInfoRowChangeEventHandler AppendInfoRowChanging;

			public event AppendInfoRowChangeEventHandler AppendInfoRowChanged;

			public event AppendInfoRowChangeEventHandler AppendInfoRowDeleting;

			public event AppendInfoRowChangeEventHandler AppendInfoRowDeleted;

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

			[DebuggerNonUserCode]
			internal AppendInfoDataTable(DataTable table)
			{
				base.TableName = table.TableName;
				if (table.CaseSensitive != table.DataSet.CaseSensitive)
				{
					base.CaseSensitive = table.CaseSensitive;
				}
				if (table.Locale.ToString() != table.DataSet.Locale.ToString())
				{
					base.Locale = table.Locale;
				}
				if (table.Namespace != table.DataSet.Namespace)
				{
					base.Namespace = table.Namespace;
				}
				base.Prefix = table.Prefix;
				base.MinimumCapacity = table.MinimumCapacity;
			}

			[DebuggerNonUserCode]
			protected AppendInfoDataTable(SerializationInfo info, StreamingContext context)
				: base(info, context)
			{
				InitVars();
			}

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

			[DebuggerNonUserCode]
			public AppendInfoRow AddAppendInfoRow(string CurrentCompany, string CurrentUser)
			{
				AppendInfoRow appendInfoRow = (AppendInfoRow)NewRow();
				object[] array2 = 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();
				dsFrmSaleInvoicce dsFrmSaleInvoicce = new dsFrmSaleInvoicce();
				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 = dsFrmSaleInvoicce.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "AppendInfoDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				XmlSchema schemaSerializable = dsFrmSaleInvoicce.GetSchemaSerializable();
				if (xs.Contains(schemaSerializable.TargetNamespace))
				{
					MemoryStream memoryStream = new MemoryStream();
					MemoryStream memoryStream2 = new MemoryStream();
					try
					{
						XmlSchema xmlSchema = null;
						schemaSerializable.Write(memoryStream);
						IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
						while (enumerator.MoveNext())
						{
							xmlSchema = (XmlSchema)enumerator.Current;
							memoryStream2.SetLength(0L);
							xmlSchema.Write(memoryStream2);
							if (memoryStream.Length == memoryStream2.Length)
							{
								memoryStream.Position = 0L;
								memoryStream2.Position = 0L;
								while (memoryStream.Position != memoryStream.Length && memoryStream.ReadByte() == memoryStream2.ReadByte())
								{
								}
								if (memoryStream.Position == memoryStream.Length)
								{
									return xmlSchemaComplexType;
								}
							}
						}
					}
					finally
					{
						memoryStream?.Close();
						memoryStream2?.Close();
					}
				}
				xs.Add(schemaSerializable);
				return xmlSchemaComplexType;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class SaleInvoiceRow : DataRow
		{
			private SaleInvoiceDataTable tableSaleInvoice;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			internal SaleInvoiceRow(DataRowBuilder rb)
				: base(rb)
			{
				tableSaleInvoice = (SaleInvoiceDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsNo_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.No_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_SaleInvoiceNull()
			{
				base[tableSaleInvoice.No_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsDate_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.Date_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetDate_SaleInvoiceNull()
			{
				base[tableSaleInvoice.Date_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsType_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.Type_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetType_SaleInvoiceNull()
			{
				base[tableSaleInvoice.Type_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsInvoiceDate_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.InvoiceDate_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetInvoiceDate_SaleInvoiceNull()
			{
				base[tableSaleInvoice.InvoiceDate_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsNo_InvoiceNull()
			{
				return IsNull(tableSaleInvoice.No_InvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_InvoiceNull()
			{
				base[tableSaleInvoice.No_InvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsInvoiceAddress_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.InvoiceAddress_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetInvoiceAddress_SaleInvoiceNull()
			{
				base[tableSaleInvoice.InvoiceAddress_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsInvoiceTitle_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.InvoiceTitle_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetInvoiceTitle_SaleInvoiceNull()
			{
				base[tableSaleInvoice.InvoiceTitle_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsBank_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.Bank_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetBank_SaleInvoiceNull()
			{
				base[tableSaleInvoice.Bank_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAccount_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.Account_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetAccount_SaleInvoiceNull()
			{
				base[tableSaleInvoice.Account_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCurrency_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.Currency_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetCurrency_SaleInvoiceNull()
			{
				base[tableSaleInvoice.Currency_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsPayDate_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.PayDate_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetPayDate_SaleInvoiceNull()
			{
				base[tableSaleInvoice.PayDate_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCreateDate_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.CreateDate_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetCreateDate_SaleInvoiceNull()
			{
				base[tableSaleInvoice.CreateDate_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsLastModDate_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.LastModDate_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetLastModDate_SaleInvoiceNull()
			{
				base[tableSaleInvoice.LastModDate_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAssessDate_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.AssessDate_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetAssessDate_SaleInvoiceNull()
			{
				base[tableSaleInvoice.AssessDate_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsDisable_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.Disable_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetDisable_SaleInvoiceNull()
			{
				base[tableSaleInvoice.Disable_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAmount_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.Amount_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetAmount_SaleInvoiceNull()
			{
				base[tableSaleInvoice.Amount_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsIncludeTax_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.IncludeTax_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetIncludeTax_SaleInvoiceNull()
			{
				base[tableSaleInvoice.IncludeTax_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsGoodsAmount_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.GoodsAmount_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetGoodsAmount_SaleInvoiceNull()
			{
				base[tableSaleInvoice.GoodsAmount_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTaxAmount_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.TaxAmount_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetTaxAmount_SaleInvoiceNull()
			{
				base[tableSaleInvoice.TaxAmount_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsStrikedAmount_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.StrikedAmount_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetStrikedAmount_SaleInvoiceNull()
			{
				base[tableSaleInvoice.StrikedAmount_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsDiscountAmount_SaleInvoiceNull()
			{
				return IsNull(tableSaleInvoice.DiscountAmount_SaleInvoiceColumn);
			}

			[DebuggerNonUserCode]
			public void SetDiscountAmount_SaleInvoiceNull()
			{
				base[tableSaleInvoice.DiscountAmount_SaleInvoiceColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsCreatorNull()
			{
				return IsNull(tableSaleInvoice.CreatorColumn);
			}

			[DebuggerNonUserCode]
			public void SetCreatorNull()
			{
				base[tableSaleInvoice.CreatorColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAssessorNull()
			{
				return IsNull(tableSaleInvoice.AssessorColumn);
			}

			[DebuggerNonUserCode]
			public void SetAssessorNull()
			{
				base[tableSaleInvoice.AssessorColumn] = Convert.DBNull;
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsTypeNameNull()
			{
				return IsNull(tableSaleInvoice.TypeNameColumn);
			}

			[DebuggerNonUserCode]
			public void SetTypeNameNull()
			{
				base[tableSaleInvoice.TypeNameColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsStartDateNull()
			{
				return IsNull(tableSaleInvoice.StartDateColumn);
			}

			[DebuggerNonUserCode]
			public void SetStartDateNull()
			{
				base[tableSaleInvoice.StartDateColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEndDateNull()
			{
				return IsNull(tableSaleInvoice.EndDateColumn);
			}

			[DebuggerNonUserCode]
			public void SetEndDateNull()
			{
				base[tableSaleInvoice.EndDateColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsckRtnNull()
			{
				return IsNull(tableSaleInvoice.ckRtnColumn);
			}

			[DebuggerNonUserCode]
			public void SetckRtnNull()
			{
				base[tableSaleInvoice.ckRtnColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class SaleInvoiceProductRow : DataRow
		{
			private SaleInvoiceProductDataTable tableSaleInvoiceProduct;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			internal SaleInvoiceProductRow(DataRowBuilder rb)
				: base(rb)
			{
				tableSaleInvoiceProduct = (SaleInvoiceProductDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsType_FromBillNull()
			{
				return IsNull(tableSaleInvoiceProduct.Type_FromBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetType_FromBillNull()
			{
				base[tableSaleInvoiceProduct.Type_FromBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsNo_FromBillNull()
			{
				return IsNull(tableSaleInvoiceProduct.No_FromBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_FromBillNull()
			{
				base[tableSaleInvoiceProduct.No_FromBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsNo_FromBillProductNull()
			{
				return IsNull(tableSaleInvoiceProduct.No_FromBillProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_FromBillProductNull()
			{
				base[tableSaleInvoiceProduct.No_FromBillProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsQuantity_SaleInvoiceProductNull()
			{
				return IsNull(tableSaleInvoiceProduct.Quantity_SaleInvoiceProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetQuantity_SaleInvoiceProductNull()
			{
				base[tableSaleInvoiceProduct.Quantity_SaleInvoiceProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsUnitPrice_SaleInvoiceProductNull()
			{
				return IsNull(tableSaleInvoiceProduct.UnitPrice_SaleInvoiceProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetUnitPrice_SaleInvoiceProductNull()
			{
				base[tableSaleInvoiceProduct.UnitPrice_SaleInvoiceProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTaxRate_SaleInvoiceProductNull()
			{
				return IsNull(tableSaleInvoiceProduct.TaxRate_SaleInvoiceProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetTaxRate_SaleInvoiceProductNull()
			{
				base[tableSaleInvoiceProduct.TaxRate_SaleInvoiceProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsComment_SaleInvoiceProductNull()
			{
				return IsNull(tableSaleInvoiceProduct.Comment_SaleInvoiceProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetComment_SaleInvoiceProductNull()
			{
				base[tableSaleInvoiceProduct.Comment_SaleInvoiceProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsAmount_SaleInvoiceProductNull()
			{
				return IsNull(tableSaleInvoiceProduct.Amount_SaleInvoiceProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetAmount_SaleInvoiceProductNull()
			{
				base[tableSaleInvoiceProduct.Amount_SaleInvoiceProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTaxAmount_SaleInvoiceProductNull()
			{
				return IsNull(tableSaleInvoiceProduct.TaxAmount_SaleInvoiceProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetTaxAmount_SaleInvoiceProductNull()
			{
				base[tableSaleInvoiceProduct.TaxAmount_SaleInvoiceProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsGoodsAmount_SaleInvoiceProductNull()
			{
				return IsNull(tableSaleInvoiceProduct.GoodsAmount_SaleInvoiceProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetGoodsAmount_SaleInvoiceProductNull()
			{
				base[tableSaleInvoiceProduct.GoodsAmount_SaleInvoiceProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsTaxCurrency_SaleInvoiceProductNull()
			{
				return IsNull(tableSaleInvoiceProduct.TaxCurrency_SaleInvoiceProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetTaxCurrency_SaleInvoiceProductNull()
			{
				base[tableSaleInvoiceProduct.TaxCurrency_SaleInvoiceProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsName_BillTypeNull()
			{
				return IsNull(tableSaleInvoiceProduct.Name_BillTypeColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_BillTypeNull()
			{
				base[tableSaleInvoiceProduct.Name_BillTypeColumn] = Convert.DBNull;
			}

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsInvoiceName_ProductNull()
			{
				return IsNull(tableSaleInvoiceProduct.InvoiceName_ProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetInvoiceName_ProductNull()
			{
				base[tableSaleInvoiceProduct.InvoiceName_ProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsUnit_ProductNull()
			{
				return IsNull(tableSaleInvoiceProduct.Unit_ProductColumn);
			}

			[DebuggerNonUserCode]
			public void SetUnit_ProductNull()
			{
				base[tableSaleInvoiceProduct.Unit_ProductColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsNegativeNull()
			{
				return IsNull(tableSaleInvoiceProduct.NegativeColumn);
			}

			[DebuggerNonUserCode]
			public void SetNegativeNull()
			{
				base[tableSaleInvoiceProduct.NegativeColumn] = Convert.DBNull;
			}

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsMoneyNull()
			{
				return IsNull(tableSaleInvoiceProduct.MoneyColumn);
			}

			[DebuggerNonUserCode]
			public void SetMoneyNull()
			{
				base[tableSaleInvoiceProduct.MoneyColumn] = 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 SaleInvoiceRowChangeEvent : EventArgs
		{
			private SaleInvoiceRow eventRow;

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public SaleInvoiceRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public SaleInvoiceProductRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

			[DebuggerNonUserCode]
			public SaleInvoiceProductRowChangeEvent(SaleInvoiceProductRow 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 SaleInvoiceDataTable tableSaleInvoice;

		private SaleInvoiceProductDataTable tableSaleInvoiceProduct;

		private AppendInfoDataTable tableAppendInfo;

		private SchemaSerializationMode _schemaSerializationMode = SchemaSerializationMode.IncludeSchema;

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[DebuggerNonUserCode]
		[Browsable(false)]
		public SaleInvoiceDataTable SaleInvoice => tableSaleInvoice;

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[DebuggerNonUserCode]
		[Browsable(false)]
		public SaleInvoiceProductDataTable SaleInvoiceProduct => tableSaleInvoiceProduct;

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

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

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

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

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

		[DebuggerNonUserCode]
		protected dsFrmSaleInvoicce(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["SaleInvoice"] != null)
				{
					base.Tables.Add(new SaleInvoiceDataTable(dataSet.Tables["SaleInvoice"]));
				}
				if (dataSet.Tables["SaleInvoiceProduct"] != null)
				{
					base.Tables.Add(new SaleInvoiceProductDataTable(dataSet.Tables["SaleInvoiceProduct"]));
				}
				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()
		{
			dsFrmSaleInvoicce dsFrmSaleInvoicce = (dsFrmSaleInvoicce)base.Clone();
			dsFrmSaleInvoicce.InitVars();
			dsFrmSaleInvoicce.SchemaSerializationMode = SchemaSerializationMode;
			return dsFrmSaleInvoicce;
		}

		[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["SaleInvoice"] != null)
				{
					base.Tables.Add(new SaleInvoiceDataTable(dataSet.Tables["SaleInvoice"]));
				}
				if (dataSet.Tables["SaleInvoiceProduct"] != null)
				{
					base.Tables.Add(new SaleInvoiceProductDataTable(dataSet.Tables["SaleInvoiceProduct"]));
				}
				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)
		{
			tableSaleInvoice = (SaleInvoiceDataTable)base.Tables["SaleInvoice"];
			if (initTable && tableSaleInvoice != null)
			{
				tableSaleInvoice.InitVars();
			}
			tableSaleInvoiceProduct = (SaleInvoiceProductDataTable)base.Tables["SaleInvoiceProduct"];
			if (initTable && tableSaleInvoiceProduct != null)
			{
				tableSaleInvoiceProduct.InitVars();
			}
			tableAppendInfo = (AppendInfoDataTable)base.Tables["AppendInfo"];
			if (initTable && tableAppendInfo != null)
			{
				tableAppendInfo.InitVars();
			}
		}

		[DebuggerNonUserCode]
		private void InitClass()
		{
			base.DataSetName = "dsFrmSaleInvoicce";
			base.Prefix = "";
			base.Namespace = "http://tempuri.org/dsFrmSaleInvoicce.xsd";
			base.Locale = new CultureInfo("en-US");
			base.EnforceConstraints = true;
			SchemaSerializationMode = SchemaSerializationMode.IncludeSchema;
			tableSaleInvoice = new SaleInvoiceDataTable();
			base.Tables.Add(tableSaleInvoice);
			tableSaleInvoiceProduct = new SaleInvoiceProductDataTable();
			base.Tables.Add(tableSaleInvoiceProduct);
			tableAppendInfo = new AppendInfoDataTable();
			base.Tables.Add(tableAppendInfo);
		}

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

		[DebuggerNonUserCode]
		private bool ShouldSerializeSaleInvoiceProduct()
		{
			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)
		{
			dsFrmSaleInvoicce dsFrmSaleInvoicce = new dsFrmSaleInvoicce();
			XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
			XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
			XmlSchemaAny xmlSchemaAny = new XmlSchemaAny();
			xmlSchemaAny.Namespace = dsFrmSaleInvoicce.Namespace;
			xmlSchemaSequence.Items.Add(xmlSchemaAny);
			xmlSchemaComplexType.Particle = xmlSchemaSequence;
			XmlSchema schemaSerializable = dsFrmSaleInvoicce.GetSchemaSerializable();
			if (xs.Contains(schemaSerializable.TargetNamespace))
			{
				MemoryStream memoryStream = new MemoryStream();
				MemoryStream memoryStream2 = new MemoryStream();
				try
				{
					XmlSchema xmlSchema = null;
					schemaSerializable.Write(memoryStream);
					IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
					while (enumerator.MoveNext())
					{
						xmlSchema = (XmlSchema)enumerator.Current;
						memoryStream2.SetLength(0L);
						xmlSchema.Write(memoryStream2);
						if (memoryStream.Length == memoryStream2.Length)
						{
							memoryStream.Position = 0L;
							memoryStream2.Position = 0L;
							while (memoryStream.Position != memoryStream.Length && memoryStream.ReadByte() == memoryStream2.ReadByte())
							{
							}
							if (memoryStream.Position == memoryStream.Length)
							{
								return xmlSchemaComplexType;
							}
						}
					}
				}
				finally
				{
					memoryStream?.Close();
					memoryStream2?.Close();
				}
			}
			xs.Add(schemaSerializable);
			return xmlSchemaComplexType;
		}
	}
}