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

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

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

		public delegate void MonthStatisticsRowChangeEventHandler(object sender, MonthStatisticsRowChangeEvent e);

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

			private DataColumn columnStartNo_Customer;

			private DataColumn columnEndNo_Customer;

			private DataColumn columnStartZone;

			private DataColumn columnEndZone;

			private DataColumn columnStartNo_Principal;

			private DataColumn columnEndNo_Principal;

			private DataColumn columnStartPrincipal_SaleBill;

			private DataColumn columnEndPrincipal_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn dtStartColumn => columndtStart;

			[DebuggerNonUserCode]
			public DataColumn StartNo_CustomerColumn => columnStartNo_Customer;

			[DebuggerNonUserCode]
			public DataColumn EndNo_CustomerColumn => columnEndNo_Customer;

			[DebuggerNonUserCode]
			public DataColumn StartZoneColumn => columnStartZone;

			[DebuggerNonUserCode]
			public DataColumn EndZoneColumn => columnEndZone;

			[DebuggerNonUserCode]
			public DataColumn StartNo_PrincipalColumn => columnStartNo_Principal;

			[DebuggerNonUserCode]
			public DataColumn EndNo_PrincipalColumn => columnEndNo_Principal;

			[DebuggerNonUserCode]
			public DataColumn StartPrincipal_SaleBillColumn => columnStartPrincipal_SaleBill;

			[DebuggerNonUserCode]
			public DataColumn EndPrincipal_SaleBillColumn => columnEndPrincipal_SaleBill;

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

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

			public event UIRowChangeEventHandler UIRowChanging;

			public event UIRowChangeEventHandler UIRowChanged;

			public event UIRowChangeEventHandler UIRowDeleting;

			public event UIRowChangeEventHandler UIRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddUIRow(UIRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public UIRow AddUIRow(DateTime dtStart, string StartNo_Customer, string EndNo_Customer, string StartZone, string EndZone, string StartNo_Principal, string EndNo_Principal, string StartPrincipal_SaleBill, string EndPrincipal_SaleBill)
			{
				UIRow uIRow = (UIRow)NewRow();
				object[] array2 = uIRow.ItemArray = new object[9]
				{
					dtStart,
					StartNo_Customer,
					EndNo_Customer,
					StartZone,
					EndZone,
					StartNo_Principal,
					EndNo_Principal,
					StartPrincipal_SaleBill,
					EndPrincipal_SaleBill
				};
				base.Rows.Add(uIRow);
				return uIRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columndtStart = base.Columns["dtStart"];
				columnStartNo_Customer = base.Columns["StartNo_Customer"];
				columnEndNo_Customer = base.Columns["EndNo_Customer"];
				columnStartZone = base.Columns["StartZone"];
				columnEndZone = base.Columns["EndZone"];
				columnStartNo_Principal = base.Columns["StartNo_Principal"];
				columnEndNo_Principal = base.Columns["EndNo_Principal"];
				columnStartPrincipal_SaleBill = base.Columns["StartPrincipal_SaleBill"];
				columnEndPrincipal_SaleBill = base.Columns["EndPrincipal_SaleBill"];
			}

			[DebuggerNonUserCode]
			private void InitClass()
			{
				columndtStart = new DataColumn("dtStart", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columndtStart);
				columnStartNo_Customer = new DataColumn("StartNo_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnStartNo_Customer);
				columnEndNo_Customer = new DataColumn("EndNo_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnEndNo_Customer);
				columnStartZone = new DataColumn("StartZone", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnStartZone);
				columnEndZone = new DataColumn("EndZone", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnEndZone);
				columnStartNo_Principal = new DataColumn("StartNo_Principal", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnStartNo_Principal);
				columnEndNo_Principal = new DataColumn("EndNo_Principal", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnEndNo_Principal);
				columnStartPrincipal_SaleBill = new DataColumn("StartPrincipal_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnStartPrincipal_SaleBill);
				columnEndPrincipal_SaleBill = new DataColumn("EndPrincipal_SaleBill", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnEndPrincipal_SaleBill);
			}

			[DebuggerNonUserCode]
			public UIRow NewUIRow()
			{
				return (UIRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveUIRow(UIRow row)
			{
				base.Rows.Remove(row);
			}

			[DebuggerNonUserCode]
			public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
			{
				XmlSchemaComplexType xmlSchemaComplexType = new XmlSchemaComplexType();
				XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence();
				dsUIMonthStatistics dsUIMonthStatistics = new dsUIMonthStatistics();
				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 = dsUIMonthStatistics.Namespace;
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute);
				XmlSchemaAttribute xmlSchemaAttribute2 = new XmlSchemaAttribute();
				xmlSchemaAttribute2.Name = "tableTypeName";
				xmlSchemaAttribute2.FixedValue = "UIDataTable";
				xmlSchemaComplexType.Attributes.Add(xmlSchemaAttribute2);
				xmlSchemaComplexType.Particle = xmlSchemaSequence;
				XmlSchema schemaSerializable = dsUIMonthStatistics.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]
		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		[XmlSchemaProvider("GetTypedTableSchema")]
		public class MonthStatisticsDataTable : DataTable, IEnumerable
		{
			private DataColumn columnNo_Customer;

			private DataColumn columnShortName_Customer;

			private DataColumn columnType_Customer;

			private DataColumn columnZone_Customer;

			private DataColumn columnBeginDate_Customer;

			private DataColumn columnSumGoodsAmount1;

			private DataColumn columnSumGoodsAmount2;

			private DataColumn columnSumGoodsAmount3;

			private DataColumn columnSumGoodsAmount4;

			private DataColumn columnSumGoodsAmount5;

			private DataColumn columnSumGoodsAmount6;

			private DataColumn columnSumGoodsAmount7;

			private DataColumn columnSumGoodsAmount8;

			private DataColumn columnSumGoodsAmount9;

			private DataColumn columnSumGoodsAmount10;

			private DataColumn columnSumGoodsAmount11;

			private DataColumn columnSumGoodsAmount12;

			[DebuggerNonUserCode]
			public DataColumn No_CustomerColumn => columnNo_Customer;

			[DebuggerNonUserCode]
			public DataColumn ShortName_CustomerColumn => columnShortName_Customer;

			[DebuggerNonUserCode]
			public DataColumn Type_CustomerColumn => columnType_Customer;

			[DebuggerNonUserCode]
			public DataColumn Zone_CustomerColumn => columnZone_Customer;

			[DebuggerNonUserCode]
			public DataColumn BeginDate_CustomerColumn => columnBeginDate_Customer;

			[DebuggerNonUserCode]
			public DataColumn SumGoodsAmount1Column => columnSumGoodsAmount1;

			[DebuggerNonUserCode]
			public DataColumn SumGoodsAmount2Column => columnSumGoodsAmount2;

			[DebuggerNonUserCode]
			public DataColumn SumGoodsAmount3Column => columnSumGoodsAmount3;

			[DebuggerNonUserCode]
			public DataColumn SumGoodsAmount4Column => columnSumGoodsAmount4;

			[DebuggerNonUserCode]
			public DataColumn SumGoodsAmount5Column => columnSumGoodsAmount5;

			[DebuggerNonUserCode]
			public DataColumn SumGoodsAmount6Column => columnSumGoodsAmount6;

			[DebuggerNonUserCode]
			public DataColumn SumGoodsAmount7Column => columnSumGoodsAmount7;

			[DebuggerNonUserCode]
			public DataColumn SumGoodsAmount8Column => columnSumGoodsAmount8;

			[DebuggerNonUserCode]
			public DataColumn SumGoodsAmount9Column => columnSumGoodsAmount9;

			[DebuggerNonUserCode]
			public DataColumn SumGoodsAmount10Column => columnSumGoodsAmount10;

			[DebuggerNonUserCode]
			public DataColumn SumGoodsAmount11Column => columnSumGoodsAmount11;

			[DebuggerNonUserCode]
			public DataColumn SumGoodsAmount12Column => columnSumGoodsAmount12;

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

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

			public event MonthStatisticsRowChangeEventHandler MonthStatisticsRowChanging;

			public event MonthStatisticsRowChangeEventHandler MonthStatisticsRowChanged;

			public event MonthStatisticsRowChangeEventHandler MonthStatisticsRowDeleting;

			public event MonthStatisticsRowChangeEventHandler MonthStatisticsRowDeleted;

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

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

			[DebuggerNonUserCode]
			public void AddMonthStatisticsRow(MonthStatisticsRow row)
			{
				base.Rows.Add(row);
			}

			[DebuggerNonUserCode]
			public MonthStatisticsRow AddMonthStatisticsRow(string No_Customer, string ShortName_Customer, string Type_Customer, string Zone_Customer, DateTime BeginDate_Customer, decimal SumGoodsAmount1, decimal SumGoodsAmount2, decimal SumGoodsAmount3, decimal SumGoodsAmount4, decimal SumGoodsAmount5, decimal SumGoodsAmount6, decimal SumGoodsAmount7, decimal SumGoodsAmount8, decimal SumGoodsAmount9, decimal SumGoodsAmount10, decimal SumGoodsAmount11, decimal SumGoodsAmount12)
			{
				MonthStatisticsRow monthStatisticsRow = (MonthStatisticsRow)NewRow();
				object[] array2 = monthStatisticsRow.ItemArray = new object[17]
				{
					No_Customer,
					ShortName_Customer,
					Type_Customer,
					Zone_Customer,
					BeginDate_Customer,
					SumGoodsAmount1,
					SumGoodsAmount2,
					SumGoodsAmount3,
					SumGoodsAmount4,
					SumGoodsAmount5,
					SumGoodsAmount6,
					SumGoodsAmount7,
					SumGoodsAmount8,
					SumGoodsAmount9,
					SumGoodsAmount10,
					SumGoodsAmount11,
					SumGoodsAmount12
				};
				base.Rows.Add(monthStatisticsRow);
				return monthStatisticsRow;
			}

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

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

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

			[DebuggerNonUserCode]
			internal void InitVars()
			{
				columnNo_Customer = base.Columns["No_Customer"];
				columnShortName_Customer = base.Columns["ShortName_Customer"];
				columnType_Customer = base.Columns["Type_Customer"];
				columnZone_Customer = base.Columns["Zone_Customer"];
				columnBeginDate_Customer = base.Columns["BeginDate_Customer"];
				columnSumGoodsAmount1 = base.Columns["SumGoodsAmount1"];
				columnSumGoodsAmount2 = base.Columns["SumGoodsAmount2"];
				columnSumGoodsAmount3 = base.Columns["SumGoodsAmount3"];
				columnSumGoodsAmount4 = base.Columns["SumGoodsAmount4"];
				columnSumGoodsAmount5 = base.Columns["SumGoodsAmount5"];
				columnSumGoodsAmount6 = base.Columns["SumGoodsAmount6"];
				columnSumGoodsAmount7 = base.Columns["SumGoodsAmount7"];
				columnSumGoodsAmount8 = base.Columns["SumGoodsAmount8"];
				columnSumGoodsAmount9 = base.Columns["SumGoodsAmount9"];
				columnSumGoodsAmount10 = base.Columns["SumGoodsAmount10"];
				columnSumGoodsAmount11 = base.Columns["SumGoodsAmount11"];
				columnSumGoodsAmount12 = base.Columns["SumGoodsAmount12"];
			}

			[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);
				columnType_Customer = new DataColumn("Type_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnType_Customer);
				columnZone_Customer = new DataColumn("Zone_Customer", typeof(string), null, MappingType.Element);
				base.Columns.Add(columnZone_Customer);
				columnBeginDate_Customer = new DataColumn("BeginDate_Customer", typeof(DateTime), null, MappingType.Element);
				base.Columns.Add(columnBeginDate_Customer);
				columnSumGoodsAmount1 = new DataColumn("SumGoodsAmount1", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnSumGoodsAmount1);
				columnSumGoodsAmount2 = new DataColumn("SumGoodsAmount2", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnSumGoodsAmount2);
				columnSumGoodsAmount3 = new DataColumn("SumGoodsAmount3", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnSumGoodsAmount3);
				columnSumGoodsAmount4 = new DataColumn("SumGoodsAmount4", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnSumGoodsAmount4);
				columnSumGoodsAmount5 = new DataColumn("SumGoodsAmount5", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnSumGoodsAmount5);
				columnSumGoodsAmount6 = new DataColumn("SumGoodsAmount6", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnSumGoodsAmount6);
				columnSumGoodsAmount7 = new DataColumn("SumGoodsAmount7", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnSumGoodsAmount7);
				columnSumGoodsAmount8 = new DataColumn("SumGoodsAmount8", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnSumGoodsAmount8);
				columnSumGoodsAmount9 = new DataColumn("SumGoodsAmount9", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnSumGoodsAmount9);
				columnSumGoodsAmount10 = new DataColumn("SumGoodsAmount10", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnSumGoodsAmount10);
				columnSumGoodsAmount11 = new DataColumn("SumGoodsAmount11", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnSumGoodsAmount11);
				columnSumGoodsAmount12 = new DataColumn("SumGoodsAmount12", typeof(decimal), null, MappingType.Element);
				base.Columns.Add(columnSumGoodsAmount12);
			}

			[DebuggerNonUserCode]
			public MonthStatisticsRow NewMonthStatisticsRow()
			{
				return (MonthStatisticsRow)NewRow();
			}

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public void RemoveMonthStatisticsRow(MonthStatisticsRow row)
			{
				base.Rows.Remove(row);
			}

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

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

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

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			internal UIRow(DataRowBuilder rb)
				: base(rb)
			{
				tableUI = (UIDataTable)base.Table;
			}

			[DebuggerNonUserCode]
			public bool IsdtStartNull()
			{
				return IsNull(tableUI.dtStartColumn);
			}

			[DebuggerNonUserCode]
			public void SetdtStartNull()
			{
				base[tableUI.dtStartColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsStartNo_CustomerNull()
			{
				return IsNull(tableUI.StartNo_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetStartNo_CustomerNull()
			{
				base[tableUI.StartNo_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEndNo_CustomerNull()
			{
				return IsNull(tableUI.EndNo_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetEndNo_CustomerNull()
			{
				base[tableUI.EndNo_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsStartZoneNull()
			{
				return IsNull(tableUI.StartZoneColumn);
			}

			[DebuggerNonUserCode]
			public void SetStartZoneNull()
			{
				base[tableUI.StartZoneColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEndZoneNull()
			{
				return IsNull(tableUI.EndZoneColumn);
			}

			[DebuggerNonUserCode]
			public void SetEndZoneNull()
			{
				base[tableUI.EndZoneColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsStartNo_PrincipalNull()
			{
				return IsNull(tableUI.StartNo_PrincipalColumn);
			}

			[DebuggerNonUserCode]
			public void SetStartNo_PrincipalNull()
			{
				base[tableUI.StartNo_PrincipalColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEndNo_PrincipalNull()
			{
				return IsNull(tableUI.EndNo_PrincipalColumn);
			}

			[DebuggerNonUserCode]
			public void SetEndNo_PrincipalNull()
			{
				base[tableUI.EndNo_PrincipalColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsStartPrincipal_SaleBillNull()
			{
				return IsNull(tableUI.StartPrincipal_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetStartPrincipal_SaleBillNull()
			{
				base[tableUI.StartPrincipal_SaleBillColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsEndPrincipal_SaleBillNull()
			{
				return IsNull(tableUI.EndPrincipal_SaleBillColumn);
			}

			[DebuggerNonUserCode]
			public void SetEndPrincipal_SaleBillNull()
			{
				base[tableUI.EndPrincipal_SaleBillColumn] = Convert.DBNull;
			}
		}

		[GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
		public class MonthStatisticsRow : DataRow
		{
			private MonthStatisticsDataTable tableMonthStatistics;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			internal MonthStatisticsRow(DataRowBuilder rb)
				: base(rb)
			{
				tableMonthStatistics = (MonthStatisticsDataTable)base.Table;
			}

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

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

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

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

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

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

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

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

			[DebuggerNonUserCode]
			public bool IsBeginDate_CustomerNull()
			{
				return IsNull(tableMonthStatistics.BeginDate_CustomerColumn);
			}

			[DebuggerNonUserCode]
			public void SetBeginDate_CustomerNull()
			{
				base[tableMonthStatistics.BeginDate_CustomerColumn] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSumGoodsAmount1Null()
			{
				return IsNull(tableMonthStatistics.SumGoodsAmount1Column);
			}

			[DebuggerNonUserCode]
			public void SetSumGoodsAmount1Null()
			{
				base[tableMonthStatistics.SumGoodsAmount1Column] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSumGoodsAmount2Null()
			{
				return IsNull(tableMonthStatistics.SumGoodsAmount2Column);
			}

			[DebuggerNonUserCode]
			public void SetSumGoodsAmount2Null()
			{
				base[tableMonthStatistics.SumGoodsAmount2Column] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSumGoodsAmount3Null()
			{
				return IsNull(tableMonthStatistics.SumGoodsAmount3Column);
			}

			[DebuggerNonUserCode]
			public void SetSumGoodsAmount3Null()
			{
				base[tableMonthStatistics.SumGoodsAmount3Column] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSumGoodsAmount4Null()
			{
				return IsNull(tableMonthStatistics.SumGoodsAmount4Column);
			}

			[DebuggerNonUserCode]
			public void SetSumGoodsAmount4Null()
			{
				base[tableMonthStatistics.SumGoodsAmount4Column] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSumGoodsAmount5Null()
			{
				return IsNull(tableMonthStatistics.SumGoodsAmount5Column);
			}

			[DebuggerNonUserCode]
			public void SetSumGoodsAmount5Null()
			{
				base[tableMonthStatistics.SumGoodsAmount5Column] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSumGoodsAmount6Null()
			{
				return IsNull(tableMonthStatistics.SumGoodsAmount6Column);
			}

			[DebuggerNonUserCode]
			public void SetSumGoodsAmount6Null()
			{
				base[tableMonthStatistics.SumGoodsAmount6Column] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSumGoodsAmount7Null()
			{
				return IsNull(tableMonthStatistics.SumGoodsAmount7Column);
			}

			[DebuggerNonUserCode]
			public void SetSumGoodsAmount7Null()
			{
				base[tableMonthStatistics.SumGoodsAmount7Column] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSumGoodsAmount8Null()
			{
				return IsNull(tableMonthStatistics.SumGoodsAmount8Column);
			}

			[DebuggerNonUserCode]
			public void SetSumGoodsAmount8Null()
			{
				base[tableMonthStatistics.SumGoodsAmount8Column] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSumGoodsAmount9Null()
			{
				return IsNull(tableMonthStatistics.SumGoodsAmount9Column);
			}

			[DebuggerNonUserCode]
			public void SetSumGoodsAmount9Null()
			{
				base[tableMonthStatistics.SumGoodsAmount9Column] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSumGoodsAmount10Null()
			{
				return IsNull(tableMonthStatistics.SumGoodsAmount10Column);
			}

			[DebuggerNonUserCode]
			public void SetSumGoodsAmount10Null()
			{
				base[tableMonthStatistics.SumGoodsAmount10Column] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSumGoodsAmount11Null()
			{
				return IsNull(tableMonthStatistics.SumGoodsAmount11Column);
			}

			[DebuggerNonUserCode]
			public void SetSumGoodsAmount11Null()
			{
				base[tableMonthStatistics.SumGoodsAmount11Column] = Convert.DBNull;
			}

			[DebuggerNonUserCode]
			public bool IsSumGoodsAmount12Null()
			{
				return IsNull(tableMonthStatistics.SumGoodsAmount12Column);
			}

			[DebuggerNonUserCode]
			public void SetSumGoodsAmount12Null()
			{
				base[tableMonthStatistics.SumGoodsAmount12Column] = Convert.DBNull;
			}
		}

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public UIRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

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

			private DataRowAction eventAction;

			[DebuggerNonUserCode]
			public MonthStatisticsRow Row => eventRow;

			[DebuggerNonUserCode]
			public DataRowAction Action => eventAction;

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

		private UIDataTable tableUI;

		private MonthStatisticsDataTable tableMonthStatistics;

		private SchemaSerializationMode _schemaSerializationMode = SchemaSerializationMode.IncludeSchema;

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[DebuggerNonUserCode]
		[Browsable(false)]
		public UIDataTable UI => tableUI;

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[Browsable(false)]
		[DebuggerNonUserCode]
		public MonthStatisticsDataTable MonthStatistics => tableMonthStatistics;

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

		[DebuggerNonUserCode]
		protected dsUIMonthStatistics(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["UI"] != null)
				{
					base.Tables.Add(new UIDataTable(dataSet.Tables["UI"]));
				}
				if (dataSet.Tables["MonthStatistics"] != null)
				{
					base.Tables.Add(new MonthStatisticsDataTable(dataSet.Tables["MonthStatistics"]));
				}
				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()
		{
			dsUIMonthStatistics dsUIMonthStatistics = (dsUIMonthStatistics)base.Clone();
			dsUIMonthStatistics.InitVars();
			dsUIMonthStatistics.SchemaSerializationMode = SchemaSerializationMode;
			return dsUIMonthStatistics;
		}

		[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["UI"] != null)
				{
					base.Tables.Add(new UIDataTable(dataSet.Tables["UI"]));
				}
				if (dataSet.Tables["MonthStatistics"] != null)
				{
					base.Tables.Add(new MonthStatisticsDataTable(dataSet.Tables["MonthStatistics"]));
				}
				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)
		{
			tableUI = (UIDataTable)base.Tables["UI"];
			if (initTable && tableUI != null)
			{
				tableUI.InitVars();
			}
			tableMonthStatistics = (MonthStatisticsDataTable)base.Tables["MonthStatistics"];
			if (initTable && tableMonthStatistics != null)
			{
				tableMonthStatistics.InitVars();
			}
		}

		[DebuggerNonUserCode]
		private void InitClass()
		{
			base.DataSetName = "dsUIMonthStatistics";
			base.Prefix = "";
			base.Namespace = "http://tempuri.org/dsUIMonthStatistics.xsd";
			base.EnforceConstraints = true;
			SchemaSerializationMode = SchemaSerializationMode.IncludeSchema;
			tableUI = new UIDataTable();
			base.Tables.Add(tableUI);
			tableMonthStatistics = new MonthStatisticsDataTable();
			base.Tables.Add(tableMonthStatistics);
		}

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

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

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

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