EDIFACT ORDERS Purchase Order

Download EDIFACT ORDERS C# Template


namespace EdiFabric.Templates.EdifactD96A
{
    using System;
    using System.Collections.Generic;
    using System.Runtime.Serialization;
    using EdiFabric.Core.Annotations.Edi;
    using EdiFabric.Core.Annotations.Validation;
    using EdiFabric.Core.Model.Edi;
    using EdiFabric.Core.Model.Edi.Edifact;
    using System.Xml.Serialization;
    
    
    ///
    /// Loop for ALLOWANCE OR CHARGE
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(ALC))]
    public class Loop_ALC_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// ALLOWANCE OR CHARGE
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual ALC ALC { get; set; }
        ///
        /// ADDITIONAL INFORMATION
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(2)]
        public virtual List ALI { get; set; }
        ///
        /// DATE/TIME/PERIOD
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(3)]
        public virtual List DTM { get; set; }
        ///
        /// Loop for QUANTITY
        /// 
        [DataMember]
        [Pos(4)]
        public virtual Loop_QTY_ORDERS_2 QTYLoop { get; set; }
        ///
        /// Loop for PERCENTAGE DETAILS
        /// 
        [DataMember]
        [Pos(5)]
        public virtual Loop_PCD_ORDERS PCDLoop { get; set; }
        ///
        /// Loop for MONETARY AMOUNT
        /// 
        [DataMember]
        [ListCount(2)]
        [Pos(6)]
        public virtual List MOALoop { get; set; }
        ///
        /// Loop for RATE DETAILS
        /// 
        [DataMember]
        [Pos(7)]
        public virtual Loop_RTE_ORDERS RTELoop { get; set; }
        ///
        /// Loop for DUTY/TAX/FEE DETAILS
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(8)]
        public virtual List TAXLoop { get; set; }
    }
    
    ///
    /// Loop for ALLOWANCE OR CHARGE
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(ALC))]
    public class Loop_ALC_ORDERS_2
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// ALLOWANCE OR CHARGE
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual ALC ALC { get; set; }
        ///
        /// ADDITIONAL INFORMATION
        /// 
        [DataMember]
        [Pos(2)]
        public virtual ALI ALI { get; set; }
        ///
        /// MONETARY AMOUNT
        /// 
        [DataMember]
        [Required]
        [ListCount(2)]
        [Pos(3)]
        public virtual List MOA { get; set; }
    }
    
    ///
    /// Loop for ADDITIONAL PRICE INFORMATION
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(APR))]
    public class Loop_APR_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// ADDITIONAL PRICE INFORMATION
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual APR APR { get; set; }
        ///
        /// DATE/TIME/PERIOD
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(2)]
        public virtual List DTM { get; set; }
        ///
        /// RANGE DETAILS
        /// 
        [DataMember]
        [Pos(3)]
        public virtual RNG RNG { get; set; }
    }
    
    ///
    /// Loop for CHARACTERISTIC/CLASS ID
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(CCI))]
    public class Loop_CCI_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// CHARACTERISTIC/CLASS ID
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual CCI CCI { get; set; }
        ///
        /// CHARACTERISTIC VALUE
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(2)]
        public virtual List CAV { get; set; }
        ///
        /// MEASUREMENTS
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(3)]
        public virtual List MEA { get; set; }
    }
    
    ///
    /// Loop for CONTACT INFORMATION
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(CTA))]
    public class Loop_CTA_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// CONTACT INFORMATION
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual CTA CTA { get; set; }
        ///
        /// COMMUNICATION CONTACT
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(2)]
        public virtual List COM { get; set; }
    }
    
    ///
    /// Loop for CURRENCIES
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(CUX))]
    public class Loop_CUX_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// CURRENCIES
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual CUX CUX { get; set; }
        ///
        /// PERCENTAGE DETAILS
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(2)]
        public virtual List PCD { get; set; }
        ///
        /// DATE/TIME/PERIOD
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(3)]
        public virtual List DTM { get; set; }
    }
    
    ///
    /// Loop for DOCUMENT/MESSAGE DETAILS
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(DOC))]
    public class Loop_DOC_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// DOCUMENT/MESSAGE DETAILS
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual DOC DOC { get; set; }
        ///
        /// DATE/TIME/PERIOD
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(2)]
        public virtual List DTM { get; set; }
    }
    
    ///
    /// Loop for EQUIPMENT DETAILS
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(EQD))]
    public class Loop_EQD_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// EQUIPMENT DETAILS
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual EQD EQD { get; set; }
        ///
        /// HANDLING INSTRUCTIONS
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(2)]
        public virtual List HAN { get; set; }
        ///
        /// MEASUREMENTS
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(3)]
        public virtual List MEA { get; set; }
        ///
        /// FREE TEXT
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(4)]
        public virtual List FTX { get; set; }
    }
    
    ///
    /// Loop for LINE ITEM
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(LIN))]
    public partial class Loop_LIN_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// LINE ITEM
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual LIN LIN { get; set; }
        ///
        /// ADDITIONAL PRODUCT ID
        /// 
        [DataMember]
        [ListCount(25)]
        [Pos(2)]
        public virtual List PIA { get; set; }
        ///
        /// ITEM DESCRIPTION
        /// 
        [DataMember]
        [ListCount(99)]
        [Pos(3)]
        public virtual List IMD { get; set; }
        ///
        /// MEASUREMENTS
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(4)]
        public virtual List MEA { get; set; }
        ///
        /// QUANTITY
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(5)]
        public virtual List QTY { get; set; }
        ///
        /// PERCENTAGE DETAILS
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(6)]
        public virtual List PCD { get; set; }
        ///
        /// ADDITIONAL INFORMATION
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(7)]
        public virtual List ALI { get; set; }
        ///
        /// DATE/TIME/PERIOD
        /// 
        [DataMember]
        [ListCount(35)]
        [Pos(8)]
        public virtual List DTM { get; set; }
        ///
        /// MONETARY AMOUNT
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(9)]
        public virtual List MOA { get; set; }
        ///
        /// GOODS IDENTITY NUMBER
        /// 
        [DataMember]
        [ListCount(1000)]
        [Pos(10)]
        public virtual List GIN { get; set; }
        ///
        /// RELATED IDENTIFICATION NUMBERS
        /// 
        [DataMember]
        [ListCount(1000)]
        [Pos(11)]
        public virtual List GIR { get; set; }
        ///
        /// QUANTITY VARIANCES
        /// 
        [DataMember]
        [Pos(12)]
        public virtual QVR QVR { get; set; }
        ///
        /// DOCUMENT/MESSAGE DETAILS
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(13)]
        public virtual List DOC { get; set; }
        ///
        /// PAYMENT INSTRUCTIONS
        /// 
        [DataMember]
        [Pos(14)]
        public virtual PAI PAI { get; set; }
        ///
        /// FREE TEXT
        /// 
        [DataMember]
        [ListCount(99)]
        [Pos(15)]
        public virtual List FTX { get; set; }
        ///
        /// Loop for CHARACTERISTIC/CLASS ID
        /// 
        [DataMember]
        [ListCount(999)]
        [Pos(16)]
        public virtual List CCILoop { get; set; }
        ///
        /// Loop for PAYMENT TERMS BASIS
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(17)]
        public virtual List PATLoop { get; set; }
        ///
        /// Loop for PRICE DETAILS
        /// 
        [DataMember]
        [ListCount(25)]
        [Pos(18)]
        public virtual List PRILoop { get; set; }
        ///
        /// Loop for REFERENCE
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(19)]
        public virtual List RFFLoop { get; set; }
        ///
        /// Loop for PACKAGE
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(20)]
        public virtual List PACLoop { get; set; }
        ///
        /// Loop for PLACE/LOCATION IDENTIFICATION
        /// 
        [DataMember]
        [ListCount(9999)]
        [Pos(21)]
        public virtual List LOCLoop { get; set; }
        ///
        /// Loop for DUTY/TAX/FEE DETAILS
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(22)]
        public virtual List TAXLoop { get; set; }
        ///
        /// Loop for NAME AND ADDRESS
        /// 
        [DataMember]
        [ListCount(99)]
        [Pos(23)]
        public virtual List NADLoop { get; set; }
        ///
        /// Loop for ALLOWANCE OR CHARGE
        /// 
        [DataMember]
        [ListCount(99)]
        [Pos(24)]
        public virtual List ALCLoop { get; set; }
        ///
        /// Loop for DETAILS OF TRANSPORT
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(25)]
        public virtual List TDTLoop { get; set; }
        ///
        /// Loop for TERMS OF DELIVERY OR TRANSPORT
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(26)]
        public virtual List TODLoop { get; set; }
        ///
        /// Loop for EQUIPMENT DETAILS
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(27)]
        public virtual List EQDLoop { get; set; }
        ///
        /// Loop for SCHEDULING CONDITIONS
        /// 
        [DataMember]
        [ListCount(100)]
        [Pos(28)]
        public virtual List SCCLoop { get; set; }
        ///
        /// Loop for REQUIREMENTS AND CONDITIONS
        /// 
        [DataMember]
        [ListCount(100)]
        [Pos(29)]
        public virtual List RCSLoop { get; set; }
        ///
        /// Loop for STAGES
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(30)]
        public virtual List STGLoop { get; set; }
    }
    
    ///
    /// Loop for PLACE/LOCATION IDENTIFICATION
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(LOC))]
    public class Loop_LOC_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// PLACE/LOCATION IDENTIFICATION
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual LOC LOC { get; set; }
        ///
        /// DATE/TIME/PERIOD
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(2)]
        public virtual List DTM { get; set; }
    }
    
    ///
    /// Loop for PLACE/LOCATION IDENTIFICATION
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(LOC))]
    public class Loop_LOC_ORDERS_2
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// PLACE/LOCATION IDENTIFICATION
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual LOC LOC { get; set; }
        ///
        /// QUANTITY
        /// 
        [DataMember]
        [Pos(2)]
        public virtual QTY QTY { get; set; }
        ///
        /// DATE/TIME/PERIOD
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(3)]
        public virtual List DTM { get; set; }
    }
    
    ///
    /// Loop for MONETARY AMOUNT
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(MOA))]
    public class Loop_MOA_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// MONETARY AMOUNT
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual MOA MOA { get; set; }
        ///
        /// RANGE DETAILS
        /// 
        [DataMember]
        [Pos(2)]
        public virtual RNG RNG { get; set; }
    }
    
    ///
    /// Loop for NAME AND ADDRESS
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(NAD))]
    public class Loop_NAD_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// NAME AND ADDRESS
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual NAD NAD { get; set; }
        ///
        /// PLACE/LOCATION IDENTIFICATION
        /// 
        [DataMember]
        [ListCount(25)]
        [Pos(2)]
        public virtual List LOC { get; set; }
        ///
        /// FINANCIAL INSTITUTION INFORMATION
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(3)]
        public virtual List FII { get; set; }
        ///
        /// Loop for REFERENCE
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(4)]
        public virtual List RFFLoop { get; set; }
        ///
        /// Loop for DOCUMENT/MESSAGE DETAILS
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(5)]
        public virtual List DOCLoop { get; set; }
        ///
        /// Loop for CONTACT INFORMATION
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(6)]
        public virtual List CTALoop { get; set; }
    }
    
    ///
    /// Loop for NAME AND ADDRESS
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(NAD))]
    public class Loop_NAD_ORDERS_2
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// NAME AND ADDRESS
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual NAD NAD { get; set; }
        ///
        /// PLACE/LOCATION IDENTIFICATION
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(2)]
        public virtual List LOC { get; set; }
        ///
        /// Loop for REFERENCE
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(3)]
        public virtual List RFFLoop { get; set; }
        ///
        /// Loop for DOCUMENT/MESSAGE DETAILS
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(4)]
        public virtual List DOCLoop { get; set; }
        ///
        /// Loop for CONTACT INFORMATION
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(5)]
        public virtual List CTALoop { get; set; }
    }
    
    ///
    /// Loop for PACKAGE
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(PAC))]
    public class Loop_PAC_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// PACKAGE
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual PAC PAC { get; set; }
        ///
        /// MEASUREMENTS
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(2)]
        public virtual List MEA { get; set; }
        ///
        /// Loop for PACKAGE IDENTIFICATION
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(3)]
        public virtual List PCILoop { get; set; }
    }
    
    ///
    /// Loop for PACKAGE
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(PAC))]
    public class Loop_PAC_ORDERS_2
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// PACKAGE
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual PAC PAC { get; set; }
        ///
        /// MEASUREMENTS
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(2)]
        public virtual List MEA { get; set; }
        ///
        /// QUANTITY
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(3)]
        public virtual List QTY { get; set; }
        ///
        /// DATE/TIME/PERIOD
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(4)]
        public virtual List DTM { get; set; }
        ///
        /// Loop for REFERENCE
        /// 
        [DataMember]
        [Pos(5)]
        public virtual Loop_RFF_ORDERS RFFLoop { get; set; }
        ///
        /// Loop for PACKAGE IDENTIFICATION
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(6)]
        public virtual List PCILoop { get; set; }
    }
    
    ///
    /// Loop for PAYMENT TERMS BASIS
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(PAT))]
    public class Loop_PAT_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// PAYMENT TERMS BASIS
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual PAT PAT { get; set; }
        ///
        /// DATE/TIME/PERIOD
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(2)]
        public virtual List DTM { get; set; }
        ///
        /// PERCENTAGE DETAILS
        /// 
        [DataMember]
        [Pos(3)]
        public virtual PCD PCD { get; set; }
        ///
        /// MONETARY AMOUNT
        /// 
        [DataMember]
        [Pos(4)]
        public virtual MOA MOA { get; set; }
    }
    
    ///
    /// Loop for PERCENTAGE DETAILS
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(PCD))]
    public class Loop_PCD_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// PERCENTAGE DETAILS
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual PCD PCD { get; set; }
        ///
        /// RANGE DETAILS
        /// 
        [DataMember]
        [Pos(2)]
        public virtual RNG RNG { get; set; }
    }
    
    ///
    /// Loop for PACKAGE IDENTIFICATION
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(PCI))]
    public class Loop_PCI_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// PACKAGE IDENTIFICATION
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual PCI PCI { get; set; }
        ///
        /// REFERENCE
        /// 
        [DataMember]
        [Pos(2)]
        public virtual RFF RFF { get; set; }
        ///
        /// DATE/TIME/PERIOD
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(3)]
        public virtual List DTM { get; set; }
        ///
        /// GOODS IDENTITY NUMBER
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(4)]
        public virtual List GIN { get; set; }
    }
    
    ///
    /// Loop for PRICE DETAILS
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(PRI))]
    public class Loop_PRI_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// PRICE DETAILS
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual PRI PRI { get; set; }
        ///
        /// CURRENCIES
        /// 
        [DataMember]
        [Pos(2)]
        public virtual CUX CUX { get; set; }
        ///
        /// ADDITIONAL PRICE INFORMATION
        /// 
        [DataMember]
        [Pos(3)]
        public virtual APR APR { get; set; }
        ///
        /// RANGE DETAILS
        /// 
        [DataMember]
        [Pos(4)]
        public virtual RNG RNG { get; set; }
        ///
        /// DATE/TIME/PERIOD
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(5)]
        public virtual List DTM { get; set; }
    }
    
    ///
    /// Loop for QUANTITY
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(QTY))]
    public class Loop_QTY_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// QUANTITY
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual QTY QTY { get; set; }
        ///
        /// DATE/TIME/PERIOD
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(2)]
        public virtual List DTM { get; set; }
    }
    
    ///
    /// Loop for QUANTITY
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(QTY))]
    public class Loop_QTY_ORDERS_2
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// QUANTITY
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual QTY QTY { get; set; }
        ///
        /// RANGE DETAILS
        /// 
        [DataMember]
        [Pos(2)]
        public virtual RNG RNG { get; set; }
    }
    
    ///
    /// Loop for QUANTITY
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(QTY))]
    public class Loop_QTY_ORDERS_3
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// QUANTITY
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual QTY QTY { get; set; }
        ///
        /// MONETARY AMOUNT
        /// 
        [DataMember]
        [Pos(2)]
        public virtual MOA MOA { get; set; }
    }
    
    ///
    /// Loop for REQUIREMENTS AND CONDITIONS
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(RCS))]
    public class Loop_RCS_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// REQUIREMENTS AND CONDITIONS
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual RCS RCS { get; set; }
        ///
        /// REFERENCE
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(2)]
        public virtual List RFF { get; set; }
        ///
        /// DATE/TIME/PERIOD
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(3)]
        public virtual List DTM { get; set; }
        ///
        /// FREE TEXT
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(4)]
        public virtual List FTX { get; set; }
    }
    
    ///
    /// Loop for REFERENCE
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(RFF))]
    public class Loop_RFF_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// REFERENCE
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual RFF RFF { get; set; }
        ///
        /// DATE/TIME/PERIOD
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(2)]
        public virtual List DTM { get; set; }
    }
    
    ///
    /// Loop for RATE DETAILS
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(RTE))]
    public class Loop_RTE_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// RATE DETAILS
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual RTE RTE { get; set; }
        ///
        /// RANGE DETAILS
        /// 
        [DataMember]
        [Pos(2)]
        public virtual RNG RNG { get; set; }
    }
    
    ///
    /// Loop for SCHEDULING CONDITIONS
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(SCC))]
    public class Loop_SCC_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// SCHEDULING CONDITIONS
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual SCC SCC { get; set; }
        ///
        /// FREE TEXT
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(2)]
        public virtual List FTX { get; set; }
        ///
        /// REFERENCE
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(3)]
        public virtual List RFF { get; set; }
        ///
        /// Loop for QUANTITY
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(4)]
        public virtual List QTYLoop { get; set; }
    }
    
    ///
    /// Loop for STAGES
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(STG))]
    public class Loop_STG_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// STAGES
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual STG STG { get; set; }
        ///
        /// Loop for QUANTITY
        /// 
        [DataMember]
        [ListCount(3)]
        [Pos(2)]
        public virtual List QTYLoop { get; set; }
    }
    
    ///
    /// Loop for DUTY/TAX/FEE DETAILS
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(TAX))]
    public class Loop_TAX_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// DUTY/TAX/FEE DETAILS
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual TAX TAX { get; set; }
        ///
        /// MONETARY AMOUNT
        /// 
        [DataMember]
        [Pos(2)]
        public virtual MOA MOA { get; set; }
        ///
        /// PLACE/LOCATION IDENTIFICATION
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(3)]
        public virtual List LOC { get; set; }
    }
    
    ///
    /// Loop for DUTY/TAX/FEE DETAILS
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(TAX))]
    public class Loop_TAX_ORDERS_2
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// DUTY/TAX/FEE DETAILS
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual TAX TAX { get; set; }
        ///
        /// MONETARY AMOUNT
        /// 
        [DataMember]
        [Pos(2)]
        public virtual MOA MOA { get; set; }
    }
    
    ///
    /// Loop for DETAILS OF TRANSPORT
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(TDT))]
    public class Loop_TDT_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// DETAILS OF TRANSPORT
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual TDT TDT { get; set; }
        ///
        /// Loop for PLACE/LOCATION IDENTIFICATION
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(2)]
        public virtual List LOCLoop { get; set; }
    }
    
    ///
    /// Loop for TERMS OF DELIVERY OR TRANSPORT
    /// 
    [Serializable()]
    [DataContract()]
    [Group(typeof(TOD))]
    public class Loop_TOD_ORDERS
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// TERMS OF DELIVERY OR TRANSPORT
        /// 
        [DataMember]
        [Required]
        [Pos(1)]
        public virtual TOD TOD { get; set; }
        ///
        /// PLACE/LOCATION IDENTIFICATION
        /// 
        [DataMember]
        [ListCount(2)]
        [Pos(2)]
        public virtual List LOC { get; set; }
    }
    
    ///
    /// Purchase order message
    /// 
    [Serializable()]
    [DataContract()]
    [Message("EDIFACT", "D96A", "ORDERS")]
    public class TSORDERS : EdiMessage
    {
        
        [XmlIgnore]
        [IgnoreDataMember]
        public int Id { get; set; }
        ///
        /// Message Header
        /// 
        [DataMember]
        [Pos(1)]
        public virtual UNH UNH { get; set; }
        ///
        /// BEGINNING OF MESSAGE
        /// 
        [DataMember]
        [Required]
        [Pos(2)]
        public virtual BGM BGM { get; set; }
        ///
        /// DATE/TIME/PERIOD
        /// 
        [DataMember]
        [Required]
        [ListCount(35)]
        [Pos(3)]
        public virtual List DTM { get; set; }
        ///
        /// PAYMENT INSTRUCTIONS
        /// 
        [DataMember]
        [Pos(4)]
        public virtual PAI PAI { get; set; }
        ///
        /// ADDITIONAL INFORMATION
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(5)]
        public virtual List ALI { get; set; }
        ///
        /// ITEM DESCRIPTION
        /// 
        [DataMember]
        [Pos(6)]
        public virtual IMD IMD { get; set; }
        ///
        /// FREE TEXT
        /// 
        [DataMember]
        [ListCount(99)]
        [Pos(7)]
        public virtual List FTX { get; set; }
        ///
        /// Loop for REFERENCE
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(8)]
        public virtual List RFFLoop { get; set; }
        ///
        /// Loop for NAME AND ADDRESS
        /// 
        [DataMember]
        [ListCount(99)]
        [Pos(9)]
        public virtual List NADLoop { get; set; }
        ///
        /// Loop for DUTY/TAX/FEE DETAILS
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(10)]
        public virtual List TAXLoop { get; set; }
        ///
        /// Loop for CURRENCIES
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(11)]
        public virtual List CUXLoop { get; set; }
        ///
        /// Loop for PAYMENT TERMS BASIS
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(12)]
        public virtual List PATLoop { get; set; }
        ///
        /// Loop for DETAILS OF TRANSPORT
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(13)]
        public virtual List TDTLoop { get; set; }
        ///
        /// Loop for TERMS OF DELIVERY OR TRANSPORT
        /// 
        [DataMember]
        [ListCount(5)]
        [Pos(14)]
        public virtual List TODLoop { get; set; }
        ///
        /// Loop for PACKAGE
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(15)]
        public virtual List PACLoop { get; set; }
        ///
        /// Loop for EQUIPMENT DETAILS
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(16)]
        public virtual List EQDLoop { get; set; }
        ///
        /// Loop for SCHEDULING CONDITIONS
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(17)]
        public virtual List SCCLoop { get; set; }
        ///
        /// Loop for ADDITIONAL PRICE INFORMATION
        /// 
        [DataMember]
        [ListCount(25)]
        [Pos(18)]
        public virtual List APRLoop { get; set; }
        ///
        /// Loop for ALLOWANCE OR CHARGE
        /// 
        [DataMember]
        [ListCount(15)]
        [Pos(19)]
        public virtual List ALCLoop { get; set; }
        ///
        /// Loop for REQUIREMENTS AND CONDITIONS
        /// 
        [DataMember]
        [ListCount(100)]
        [Pos(20)]
        public virtual List RCSLoop { get; set; }
        ///
        /// Loop for LINE ITEM
        /// 
        [Splitter]
        [DataMember]
        [ListCount(200000)]
        [Pos(21)]
        public virtual List LINLoop { get; set; }
        ///
        /// SECTION CONTROL
        /// 
        [DataMember]
        [Required]
        [Pos(22)]
        public virtual UNS UNS { get; set; }
        ///
        /// MONETARY AMOUNT
        /// 
        [DataMember]
        [ListCount(12)]
        [Pos(23)]
        public virtual List MOA { get; set; }
        ///
        /// CONTROL TOTAL
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(24)]
        public virtual List CNT { get; set; }
        ///
        /// Loop for ALLOWANCE OR CHARGE
        /// 
        [DataMember]
        [ListCount(10)]
        [Pos(25)]
        public virtual List ALCLoop2 { get; set; }
        ///
        /// Message Trailer
        /// 
        [DataMember]
        [Pos(26)]
        public virtual UNT UNT { get; set; }
    }
}
Was this article helpful?
1 out of 1 found this helpful