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

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

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

			private DataColumn columnShortName_Customer;

			private DataColumn columnStrTransBack_SaleBill;

			private DataColumn columnGetMethod_SaleBill;

			private DataColumn columnNo_SaleBill;

			private DataColumn columnAssessDate_SaleBill;

			private DataColumn columnStrRespite_SaleBill;

			private DataColumn columnNo_SaleOutDepotBill;

			private DataColumn columnAssessDate_SaleOutDepotBill;

			private DataColumn columnNo_ExpressDelivery;

			private DataColumn columnComment_ExpressDelivery;

			[DebuggerNonUserCode]
			public DataColumn No_CustomerColumn => columnNo_Customer;

			[DebuggerNonUserCode]
			public DataColumn ShortName_CustomerColumn => columnShortName_Customer;

			[DebuggerNonUserCode]
			public DataColumn StrTransBack_SaleBillColumn => columnStrTransBack_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn GetMethod_SaleBillColumn => columnGetMethod_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn No_SaleBillColumn => columnNo_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn AssessDate_SaleBillColumn => columnAssessDate_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn StrRespite_SaleBillColumn => columnStrRespite_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn No_SaleOutDepotBillColumn => columnNo_SaleOutDepotBill;

			[DebuggerNonUserCode]
			public DataColumn AssessDate_SaleOutDepotBillColumn => columnAssessDate_SaleOutDepotBill;

			[DebuggerNonUserCode]
			public DataColumn No_ExpressDeliveryColumn => columnNo_ExpressDelivery;

			[DebuggerNonUserCode]
			public DataColumn Comment_ExpressDeliveryColumn => columnComment_ExpressDelivery;

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

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

			public event TotalRowChangeEventHandler TotalRowChanging;

			public event TotalRowChangeEventHandler TotalRowChanged;

			public event TotalRowChangeEventHandler TotalRowDeleting;

			public event TotalRowChangeEventHandler TotalRowDeleted;

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

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

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

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

			[DebuggerNonUserCode]
			public TotalRow AddTotalRow(string No_Customer, string ShortName_Customer, string StrTransBack_SaleBill, string GetMethod_SaleBill, string No_SaleBill, DateTime AssessDate_SaleBill, string StrRespite_SaleBill, string No_SaleOutDepotBill, DateTime AssessDate_SaleOutDepotBill, string No_ExpressDelivery, string Comment_ExpressDelivery)
			{
				TotalRow totalRow = (TotalRow)NewRow();
				totalRow.ItemArray = new object[11]
				{
					No_Customer,
					ShortName_Customer,
					StrTransBack_SaleBill,
					GetMethod_SaleBill,
					No_SaleBill,
					AssessDate_SaleBill,
					StrRespite_SaleBill,
					No_SaleOutDepotBill,
					AssessDate_SaleOutDepotBill,
					No_ExpressDelivery,
					Comment_ExpressDelivery
				};
				base.Rows.Add(totalRow);
				return totalRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnNo_Customer = base.Columns["No_Customer"];
				columnShortName_Customer = base.Columns["ShortName_Customer"];
				columnStrTransBack_SaleBill = base.Columns["StrTransBack_SaleBill"];
				columnGetMethod_SaleBill = base.Columns["GetMethod_SaleBill"];
				columnNo_SaleBill = base.Columns["No_SaleBill"];
				columnAssessDate_SaleBill = base.Columns["AssessDate_SaleBill"];
				columnStrRespite_SaleBill = base.Columns["StrRespite_SaleBill"];
				columnNo_SaleOutDepotBill = base.Columns["No_SaleOutDepotBill"];
				columnAssessDate_SaleOutDepotBill = base.Columns["AssessDate_SaleOutDepotBill"];
				columnNo_ExpressDelivery = base.Columns["No_ExpressDelivery"];
				columnComment_ExpressDelivery = base.Columns["Comment_ExpressDelivery"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columnNo_Customer = new DataColumn("No_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_Customer);
				columnShortName_Customer = new DataColumn("ShortName_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnShortName_Customer);
				columnStrTransBack_SaleBill = new DataColumn("StrTransBack_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnStrTransBack_SaleBill);
				columnGetMethod_SaleBill = new DataColumn("GetMethod_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnGetMethod_SaleBill);
				columnNo_SaleBill = new DataColumn("No_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_SaleBill);
				columnAssessDate_SaleBill = new DataColumn("AssessDate_SaleBill", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnAssessDate_SaleBill);
				columnStrRespite_SaleBill = new DataColumn("StrRespite_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnStrRespite_SaleBill);
				columnNo_SaleOutDepotBill = new DataColumn("No_SaleOutDepotBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_SaleOutDepotBill);
				columnAssessDate_SaleOutDepotBill = new DataColumn("AssessDate_SaleOutDepotBill", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnAssessDate_SaleOutDepotBill);
				columnNo_ExpressDelivery = new DataColumn("No_ExpressDelivery", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnNo_ExpressDelivery);
				columnComment_ExpressDelivery = new DataColumn("Comment_ExpressDelivery", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnComment_ExpressDelivery);
			}

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

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsFrmSaleConsignment dsFrmSaleConsignment = new dsFrmSaleConsignment();
				xs.Add(dsFrmSaleConsignment.GetSchemaSerializable());
				XmlSchemaAny xmlSchemaAny = new XmlSchemaAny();
				xmlSchemaAny.Namespace = "http://www.w3.org/2001/XMLSchema";
				xmlSchemaAny.MinOccurs = 0m;
				xmlSchemaAny.MaxOccurs = decimal.MaxValue;
				xmlSchemaAny.ProcessContents = XmlSchemaContentProcessing.Lax;
				xmlSchemaSequence.Items.Add(xmlSchemaAny);
				XmlSchemaAny xmlSchemaAny2 = new XmlSchemaAny();
				xmlSchemaAny2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
				xmlSchemaAny2.MinOccurs = 1m;
				xmlSchemaAny2.ProcessContents = XmlSchemaContentProcessing.Lax;
				xmlSchemaSequence.Items.Add(xmlSchemaAny2);
				XmlSchemaAttribute xmlSchemaAttribute = new XmlSchemaAttribute();
				xmlSchemaAttribute.Name = "namespace";
				xmlSchemaAttribute.FixedValue = dsFrmSaleConsignment.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "TotalDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				return xmlSchemaComplexType;
			}
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsStrTransBack_SaleBillNull()
			{
				return IsNull(tableTotal.StrTransBack_SaleBillColumn);
			}

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

			[DebuggerNonUserCode]
			public bool IsGetMethod_SaleBillNull()
			{
				return IsNull(tableTotal.GetMethod_SaleBillColumn);
			}

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

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

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

			[DebuggerNonUserCode]
			public bool IsAssessDate_SaleBillNull()
			{
				return IsNull(tableTotal.AssessDate_SaleBillColumn);
			}

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

			[DebuggerNonUserCode]
			public bool IsStrRespite_SaleBillNull()
			{
				return IsNull(tableTotal.StrRespite_SaleBillColumn);
			}

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

			[DebuggerNonUserCode]
			public bool IsNo_SaleOutDepotBillNull()
			{
				return IsNull(tableTotal.No_SaleOutDepotBillColumn);
			}

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

			[DebuggerNonUserCode]
			public bool IsAssessDate_SaleOutDepotBillNull()
			{
				return IsNull(tableTotal.AssessDate_SaleOutDepotBillColumn);
			}

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

			[DebuggerNonUserCode]
			public bool IsNo_ExpressDeliveryNull()
			{
				return IsNull(tableTotal.No_ExpressDeliveryColumn);
			}

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

			[DebuggerNonUserCode]
			public bool IsComment_ExpressDeliveryNull()
			{
				return IsNull(tableTotal.Comment_ExpressDeliveryColumn);
			}

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public TotalRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

		private TotalDataTable tableTotal;

		private SchemaSerializationMode _schemaSerializationMode = SchemaSerializationMode.IncludeSchema;

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

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

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

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

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

		[DebuggerNonUserCode]
		protected dsFrmSaleConsignment(SerializationInfo info, StreamingContext context)
			: base(info, context, ConstructSchema: false)
		{
			if (IsBinarySerialized(info, context))
			{
				InitVars(initTable: false);
				CollectionChangeEventHandler value = SchemaChanged;
				Tables.CollectionChanged += value;
				Relations.CollectionChanged += value;
				return;
			}
			string s = (string)info.GetValue("XmlSchema", typeof(string));
			if (DetermineSchemaSerializationMode(info, context) == SchemaSerializationMode.IncludeSchema)
			{
				DataSet dataSet = new DataSet();
				dataSet.ReadXmlSchema(new XmlTextReader(new StringReader(s)));
				if (dataSet.Tables["Total"] != null)
				{
					base.Tables.Add(new TotalDataTable(dataSet.Tables["Total"]));
				}
				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()
		{
			dsFrmSaleConsignment dsFrmSaleConsignment = (dsFrmSaleConsignment)base.Clone();
			dsFrmSaleConsignment.InitVars();
			dsFrmSaleConsignment.SchemaSerializationMode = SchemaSerializationMode;
			return dsFrmSaleConsignment;
		}

		[DebuggerNonUserCode]
		protected override bool ShouldSerializeTables()
		{
			return false;
		}

		[DebuggerNonUserCode]
		protected override bool ShouldSerializeRelations()
		{
			return false;
		}

		[DebuggerNonUserCode]
		protected override void ReadXmlSerializable(XmlReader reader)
		{
			if (DetermineSchemaSerializationMode(reader) == SchemaSerializationMode.IncludeSchema)
			{
				Reset();
				DataSet dataSet = new DataSet();
				dataSet.ReadXml(reader);
				if (dataSet.Tables["Total"] != null)
				{
					base.Tables.Add(new TotalDataTable(dataSet.Tables["Total"]));
				}
				base.DataSetName = dataSet.DataSetName;
				base.Prefix = dataSet.Prefix;
				base.Namespace = dataSet.Namespace;
				base.Locale = dataSet.Locale;
				base.CaseSensitive = dataSet.CaseSensitive;
				base.EnforceConstraints = dataSet.EnforceConstraints;
				Merge(dataSet, preserveChanges: false, MissingSchemaAction.Add);
				InitVars();
			}
			else
			{
				ReadXml(reader);
				InitVars();
			}
		}

		[DebuggerNonUserCode]
		protected override XmlSchema GetSchemaSerializable()
		{
			MemoryStream memoryStream = new MemoryStream();
			WriteXmlSchema(new XmlTextWriter(memoryStream, null));
			memoryStream.Position = 0L;
			return XmlSchema.Read(new XmlTextReader(memoryStream), null);
		}

		[DebuggerNonUserCode]
		internal void InitVars()
		{
			InitVars(initTable: true);
		}

		[DebuggerNonUserCode]
		internal void InitVars(bool initTable)
		{
			tableTotal = (TotalDataTable)base.Tables["Total"];
			if (initTable && tableTotal != null)
			{
				tableTotal.InitVars();
			}
		}

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

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

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

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