using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.Runtime.Serialization;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;

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

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

			private DataColumn columnDate;

			private DataColumn columnGetMethod_Bill;

			private DataColumn columnNo_Customer;

			private DataColumn columnShortName_Customer;

			private DataColumn columnNo_Product;

			private DataColumn columnName_Product;

			private DataColumn columnQuantity_SaleBillProduct;

			private DataColumn columnName_Bill;

			private DataColumn columnUnitPrice_SaleBillProduct;

			private DataColumn columnTaxCurrency_SaleBill;

			private DataColumn columnMoneyCurrency;

			private DataColumn columnTaxCurrency;

			[DebuggerNonUserCode]
			public DataColumn No_BillColumn => columnNo_Bill;

			[DebuggerNonUserCode]
			public DataColumn DateColumn => columnDate;

			[DebuggerNonUserCode]
			public DataColumn GetMethod_BillColumn => columnGetMethod_Bill;

			[DebuggerNonUserCode]
			public DataColumn No_CustomerColumn => columnNo_Customer;

			[DebuggerNonUserCode]
			public DataColumn ShortName_CustomerColumn => columnShortName_Customer;

			[DebuggerNonUserCode]
			public DataColumn No_ProductColumn => columnNo_Product;

			[DebuggerNonUserCode]
			public DataColumn Name_ProductColumn => columnName_Product;

			[DebuggerNonUserCode]
			public DataColumn Quantity_SaleBillProductColumn => columnQuantity_SaleBillProduct;

			[DebuggerNonUserCode]
			public DataColumn Name_BillColumn => columnName_Bill;

			[DebuggerNonUserCode]
			public DataColumn UnitPrice_SaleBillProductColumn => columnUnitPrice_SaleBillProduct;

			[DebuggerNonUserCode]
			public DataColumn TaxCurrency_SaleBillColumn => columnTaxCurrency_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn MoneyCurrencyColumn => columnMoneyCurrency;

			[DebuggerNonUserCode]
			public DataColumn TaxCurrencyColumn => columnTaxCurrency;

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

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

			public event SaleBillDetailRowChangeEventHandler SaleBillDetailRowChanging;

			public event SaleBillDetailRowChangeEventHandler SaleBillDetailRowChanged;

			public event SaleBillDetailRowChangeEventHandler SaleBillDetailRowDeleting;

			public event SaleBillDetailRowChangeEventHandler SaleBillDetailRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddSaleBillDetailRow(SaleBillDetailRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public SaleBillDetailRow AddSaleBillDetailRow(string No_Bill, DateTime Date, string GetMethod_Bill, string No_Customer, string ShortName_Customer, string No_Product, string Name_Product, decimal Quantity_SaleBillProduct, string Name_Bill, decimal UnitPrice_SaleBillProduct, string TaxCurrency_SaleBill, decimal MoneyCurrency, decimal TaxCurrency)
			{
				SaleBillDetailRow saleBillDetailRow = (SaleBillDetailRow)NewRow();
				object[] array2 = saleBillDetailRow.ItemArray = new object[13]
				{
					No_Bill,
					Date,
					GetMethod_Bill,
					No_Customer,
					ShortName_Customer,
					No_Product,
					Name_Product,
					Quantity_SaleBillProduct,
					Name_Bill,
					UnitPrice_SaleBillProduct,
					TaxCurrency_SaleBill,
					MoneyCurrency,
					TaxCurrency
				};
				base.Rows.Add(saleBillDetailRow);
				return saleBillDetailRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnNo_Bill = base.Columns["No_Bill"];
				columnDate = base.Columns["Date"];
				columnGetMethod_Bill = base.Columns["GetMethod_Bill"];
				columnNo_Customer = base.Columns["No_Customer"];
				columnShortName_Customer = base.Columns["ShortName_Customer"];
				columnNo_Product = base.Columns["No_Product"];
				columnName_Product = base.Columns["Name_Product"];
				columnQuantity_SaleBillProduct = base.Columns["Quantity_SaleBillProduct"];
				columnName_Bill = base.Columns["Name_Bill"];
				columnUnitPrice_SaleBillProduct = base.Columns["UnitPrice_SaleBillProduct"];
				columnTaxCurrency_SaleBill = base.Columns["TaxCurrency_SaleBill"];
				columnMoneyCurrency = base.Columns["MoneyCurrency"];
				columnTaxCurrency = base.Columns["TaxCurrency"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnNo_Bill = new DataColumn("No_Bill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_Bill);
				columnDate = new DataColumn("Date", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnDate);
				columnGetMethod_Bill = new DataColumn("GetMethod_Bill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnGetMethod_Bill);
				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);
				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);
				columnQuantity_SaleBillProduct = new DataColumn("Quantity_SaleBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnQuantity_SaleBillProduct);
				columnName_Bill = new DataColumn("Name_Bill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnName_Bill);
				columnUnitPrice_SaleBillProduct = new DataColumn("UnitPrice_SaleBillProduct", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnUnitPrice_SaleBillProduct);
				columnTaxCurrency_SaleBill = new DataColumn("TaxCurrency_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnTaxCurrency_SaleBill);
				columnMoneyCurrency = new DataColumn("MoneyCurrency", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnMoneyCurrency);
				columnTaxCurrency = new DataColumn("TaxCurrency", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnTaxCurrency);
			}

			[DebuggerNonUserCode]
			public SaleBillDetailRow NewSaleBillDetailRow()
			{
				return (SaleBillDetailRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveSaleBillDetailRow(SaleBillDetailRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsFrmSaleNoBilling dsFrmSaleNoBilling = new dsFrmSaleNoBilling();
				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 = dsFrmSaleNoBilling.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "SaleBillDetailDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				XmlSchema schemaSerializable = dsFrmSaleNoBilling.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 SaleBillDetailRow : DataRow
		{
			private SaleBillDetailDataTable tableSaleBillDetail;

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

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

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

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

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

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

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			internal SaleBillDetailRow(DataRowBuilder rb)
				: base(rb)
			{
				tableSaleBillDetail = (SaleBillDetailDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsNo_BillNull()
			{
				return IsNull(tableSaleBillDetail.No_BillColumn);
			}

			[DebuggerNonUserCode]
			public void SetNo_BillNull()
			{
				base[tableSaleBillDetail.No_BillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsDateNull()
			{
				return IsNull(tableSaleBillDetail.DateColumn);
			}

			[DebuggerNonUserCode]
			public void SetDateNull()
			{
				base[tableSaleBillDetail.DateColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsGetMethod_BillNull()
			{
				return IsNull(tableSaleBillDetail.GetMethod_BillColumn);
			}

			[DebuggerNonUserCode]
			public void SetGetMethod_BillNull()
			{
				base[tableSaleBillDetail.GetMethod_BillColumn] = Convert.DBNull;
			}

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

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

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

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsName_BillNull()
			{
				return IsNull(tableSaleBillDetail.Name_BillColumn);
			}

			[DebuggerNonUserCode]
			public void SetName_BillNull()
			{
				base[tableSaleBillDetail.Name_BillColumn] = Convert.DBNull;
			}

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

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

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

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

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

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

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

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public SaleBillDetailRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

		private SaleBillDetailDataTable tableSaleBillDetail;

		private SchemaSerializationMode _schemaSerializationMode = SchemaSerializationMode.IncludeSchema;

		[DebuggerNonUserCode]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[Browsable(false)]
		public SaleBillDetailDataTable SaleBillDetail => tableSaleBillDetail;

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

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

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

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

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

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

		[DebuggerNonUserCode]
		private void InitClass()
		{
			base.DataSetName = "dsFrmSaleNoBilling";
			base.Prefix = "";
			base.Namespace = "http://tempuri.org/dsFrmSaleNoBilling.xsd";
			base.EnforceConstraints = true;
			SchemaSerializationMode = SchemaSerializationMode.IncludeSchema;
			tableSaleBillDetail = new SaleBillDetailDataTable();
			base.Tables.Add(tableSaleBillDetail);
		}

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

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

		[DebuggerNonUserCode]
		public static XmlSchemaComplexType GetTypedDataSetSchema(XmlSchemaSet xs)
		{
			dsFrmSaleNoBilling dsFrmSaleNoBilling = new dsFrmSaleNoBilling();
			XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
			XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
			XmlSchemaAny xmlSchemaAny = new XmlSchemaAny();
			xmlSchemaAny.Namespace = dsFrmSaleNoBilling.Namespace;
			xmlSchemaSequence.Items.Add(xmlSchemaAny);
			xmlSchemaComplexType.Particle = xmlSchemaSequence;
			XmlSchema schemaSerializable = dsFrmSaleNoBilling.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;
		}
	}
}