public Protocols.ToolkitResultProtocol AcceptPartRequest(System.String partRequestDetailIDNum)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.AcceptPartRequest(partRequestDetailIDNum) );
        }
        public Protocols.ToolkitResultProtocol AcceptPartRequest(Protocols.Logistics.AcceptPartRequestSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );
            FChoice.Toolkits.Clarify.Logistics.AcceptPartRequestSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Logistics.AcceptPartRequestSetup(setupParam.PartRequestDetailIDNum);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
            {
                setup.PartRequestDetailIDNum = setupParam.PartRequestDetailIDNum;
            }

            if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
            {
                setup.AcceptDate = setupParam.AcceptDate;
            }

            if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
            {
                setup.WipBin = setupParam.WipBin;
            }

            if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
            {
                setup.UserName = setupParam.UserName;
            }

            if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
            {
                setup.GenerateTimeBombs = setupParam.GenerateTimeBombs;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.AcceptPartRequest(setup) );
        }
        public Protocols.ToolkitResultProtocol AddInventoryLocation(System.String locationName, System.String capitalGLAccount, System.String siteIDNum, FChoice.Toolkits.Clarify.PartAuthorizationLevel partAuthorizationLevel)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.AddInventoryLocation(locationName, capitalGLAccount, siteIDNum, partAuthorizationLevel) );
        }
        public Protocols.ToolkitResultProtocol SetLogisticsTransition(Protocols.Logistics.SetLogisticsTransitionSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );
            FChoice.Toolkits.Clarify.Logistics.SetLogisticsTransitionSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Logistics.SetLogisticsTransitionSetup(setupParam.PartRequestType, setupParam.StartCondition, setupParam.EndCondition, setupParam.PrivilegeClasses);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
            {
                setup.PartRequestType = setupParam.PartRequestType;
            }

            if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
            {
                setup.StartCondition = setupParam.StartCondition;
            }

            if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
            {
                setup.EndCondition = setupParam.EndCondition;
            }

            if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
            {
                setup.PrivilegeClasses = setupParam.PrivilegeClasses;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.SetLogisticsTransition(setup) );
        }
        public Protocols.ToolkitResultProtocol AddLocationServicingSite(Protocols.Logistics.AddLocationServicingSiteSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );
            FChoice.Toolkits.Clarify.Logistics.AddLocationServicingSiteSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Logistics.AddLocationServicingSiteSetup(setupParam.SiteIDNum, setupParam.LocationName, setupParam.LocationRank);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
            {
                setup.SiteIDNum = setupParam.SiteIDNum;
            }

            if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
            {
                setup.LocationName = setupParam.LocationName;
            }

            if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
            {
                setup.IsActive = setupParam.IsActive;
            }

            if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
            {
                setup.LocationRank = setupParam.LocationRank;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.AddLocationServicingSite(setup) );
        }
        public Protocols.Logistics.CreatePartRequestDetailResultProtocol CreatePartRequestDetail(Protocols.Logistics.CreatePartRequestDetailSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );
            FChoice.Toolkits.Clarify.Logistics.CreatePartRequestDetailSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Logistics.CreatePartRequestDetailSetup(setupParam.PartRequestHeaderIDNum, setupParam.PartNumber, setupParam.PartDomain, setupParam.PartRevision, setupParam.Quantity);
                    break;
                case 1:
                    setup = new FChoice.Toolkits.Clarify.Logistics.CreatePartRequestDetailSetup(setupParam.PartRequestHeaderIDNum, setupParam.Quantity, setupParam.SitePartObjid);
                    break;
                case 2:
                    setup = new FChoice.Toolkits.Clarify.Logistics.CreatePartRequestDetailSetup(setupParam.PartRequestHeaderIDNum, setupParam.PartNumber, setupParam.PartDomain, setupParam.PartRevision, setupParam.SerialNumber);
                    break;
                case 3:
                    setup = new FChoice.Toolkits.Clarify.Logistics.CreatePartRequestDetailSetup(setupParam.PartRequestHeaderIDNum, setupParam.SerialNumber, setupParam.SitePartObjid);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
            {
                setup.PartRequestHeaderIDNum = setupParam.PartRequestHeaderIDNum;
            }

            if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
            {
                setup.Queue = setupParam.Queue;
            }

            if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
            {
                setup.PartNumber = setupParam.PartNumber;
            }

            if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
            {
                setup.PartDomain = setupParam.PartDomain;
            }

            if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
            {
                setup.PartRevision = setupParam.PartRevision;
            }

            if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
            {
                setup.SerialNumber = setupParam.SerialNumber;
            }

            if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
            {
                setup.Quantity = setupParam.Quantity;
            }

            if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
            {
                setup.SitePartObjid = setupParam.SitePartObjid;
            }

            if( Global.IsPropertyDirty(512, setupParam.DirtyFieldFlags) )
            {
                setup.DetailType = setupParam.DetailType;
            }

            if( Global.IsPropertyDirty(1024, setupParam.DirtyFieldFlags) )
            {
                setup.Priority = setupParam.Priority;
            }

            if( Global.IsPropertyDirty(2048, setupParam.DirtyFieldFlags) )
            {
                setup.ShippingMethod = setupParam.ShippingMethod;
            }

            if( Global.IsPropertyDirty(4096, setupParam.DirtyFieldFlags) )
            {
                setup.CarrierName = setupParam.CarrierName;
            }

            if( Global.IsPropertyDirty(8192, setupParam.DirtyFieldFlags) )
            {
                setup.UserName = setupParam.UserName;
            }

            if( Global.IsPropertyDirty(16384, setupParam.DirtyFieldFlags) )
            {
                setup.HasWarranty = setupParam.HasWarranty;
            }

            if( Global.IsPropertyDirty(32768, setupParam.DirtyFieldFlags) )
            {
                setup.Notes = setupParam.Notes;
            }

            if( Global.IsPropertyDirty(65536, setupParam.DirtyFieldFlags) )
            {
                setup.Status = setupParam.Status;
            }

            if( Global.IsPropertyDirty(131072, setupParam.DirtyFieldFlags) )
            {
                setup.CreateDate = setupParam.CreateDate;
            }

            if( Global.IsPropertyDirty(262144, setupParam.DirtyFieldFlags) )
            {
                setup.DueDate = setupParam.DueDate;
            }

            if( Global.IsPropertyDirty(524288, setupParam.DirtyFieldFlags) )
            {
                setup.GenerateTimeBombs = setupParam.GenerateTimeBombs;
            }

            if( Global.IsPropertyDirty(1048576, setupParam.DirtyFieldFlags) )
            {
                setup.ContractItemObjid = setupParam.ContractItemObjid;
            }

            if( Global.IsPropertyDirty(2097152, setupParam.DirtyFieldFlags) )
            {
                foreach(Protocols.AdditionalFieldProtocol field in setupParam.AdditionalFields){setup.AdditionalFields.Append( field.FieldName, field.FieldType, field.FieldValue);}
            }

            return new Protocols.Logistics.CreatePartRequestDetailResultProtocol( toolkit.CreatePartRequestDetail(setup) );
        }
        public Protocols.ToolkitResultProtocol CreatePartRequestHeader(Protocols.Logistics.CreatePartRequestHeaderSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );
            FChoice.Toolkits.Clarify.Logistics.CreatePartRequestHeaderSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Logistics.CreatePartRequestHeaderSetup(setupParam.ContactFirstName, setupParam.ContactLastName, setupParam.ContactPhone, setupParam.ShipToSiteIDNum);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
            {
                setup.ContactFirstName = setupParam.ContactFirstName;
            }

            if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
            {
                setup.ContactLastName = setupParam.ContactLastName;
            }

            if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
            {
                setup.ContactPhone = setupParam.ContactPhone;
            }

            if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
            {
                setup.ShipToSiteIDNum = setupParam.ShipToSiteIDNum;
            }

            if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
            {
                setup.BillSiteIDNum = setupParam.BillSiteIDNum;
            }

            if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
            {
                setup.CaseIDNum = setupParam.CaseIDNum;
            }

            if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
            {
                setup.PaymentMethod = setupParam.PaymentMethod;
            }

            if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
            {
                setup.PaymentTerms = setupParam.PaymentTerms;
            }

            if( Global.IsPropertyDirty(256, setupParam.DirtyFieldFlags) )
            {
                setup.Priority = setupParam.Priority;
            }

            if( Global.IsPropertyDirty(512, setupParam.DirtyFieldFlags) )
            {
                setup.UserName = setupParam.UserName;
            }

            if( Global.IsPropertyDirty(1024, setupParam.DirtyFieldFlags) )
            {
                setup.Notes = setupParam.Notes;
            }

            if( Global.IsPropertyDirty(2048, setupParam.DirtyFieldFlags) )
            {
                setup.CreateDate = setupParam.CreateDate;
            }

            if( Global.IsPropertyDirty(4096, setupParam.DirtyFieldFlags) )
            {
                setup.ContractObjid = setupParam.ContractObjid;
            }

            if( Global.IsPropertyDirty(8192, setupParam.DirtyFieldFlags) )
            {
                foreach(Protocols.AdditionalFieldProtocol field in setupParam.AdditionalFields){setup.AdditionalFields.Append( field.FieldName, field.FieldType, field.FieldValue);}
            }

            return new Protocols.ToolkitResultProtocol( toolkit.CreatePartRequestHeader(setup) );
        }
        public Protocols.ToolkitResultProtocol CreateContainer(System.String containerName, System.String locationName)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.CreateContainer(containerName, locationName) );
        }
        public Protocols.Logistics.CreatePartRequestDetailResultProtocol CreatePartRequestDetail(System.String partRequestHeaderIDNum, System.String partNumber, System.String partDomain, System.String partRevision, System.Int32 quantity)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.Logistics.CreatePartRequestDetailResultProtocol( toolkit.CreatePartRequestDetail(partRequestHeaderIDNum, partNumber, partDomain, partRevision, quantity) );
        }
        public Protocols.ToolkitResultProtocol BackorderPartRequest(System.String partRequestDetailIDNum, System.DateTime expectedDate, System.Int32 quantity)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.BackorderPartRequest(partRequestDetailIDNum, expectedDate, quantity) );
        }
        public Protocols.ToolkitResultProtocol BackorderPartRequest(Protocols.Logistics.BackorderPartRequestSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );
            FChoice.Toolkits.Clarify.Logistics.BackorderPartRequestSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Logistics.BackorderPartRequestSetup(setupParam.PartRequestDetailIDNum, setupParam.ExpectedDate, setupParam.Quantity);
                    break;
                case 1:
                    setup = new FChoice.Toolkits.Clarify.Logistics.BackorderPartRequestSetup(setupParam.PartRequestDetailIDNum, setupParam.ExpectedDate, setupParam.SerialNumber);
                    break;
                case 2:
                    setup = new FChoice.Toolkits.Clarify.Logistics.BackorderPartRequestSetup(setupParam.PartRequestDetailIDNum, setupParam.ExpectedDate, setupParam.UseTransitions, setupParam.Quantity);
                    break;
                case 3:
                    setup = new FChoice.Toolkits.Clarify.Logistics.BackorderPartRequestSetup(setupParam.PartRequestDetailIDNum, setupParam.ExpectedDate, setupParam.UseTransitions, setupParam.SerialNumber);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
            {
                setup.PartRequestDetailIDNum = setupParam.PartRequestDetailIDNum;
            }

            if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
            {
                setup.Quantity = setupParam.Quantity;
            }

            if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
            {
                setup.FromGood = setupParam.FromGood;
            }

            if( Global.IsPropertyDirty(1024, setupParam.DirtyFieldFlags) )
            {
                setup.ToGood = setupParam.ToGood;
            }

            if( Global.IsPropertyDirty(2048, setupParam.DirtyFieldFlags) )
            {
                setup.SerialNumber = setupParam.SerialNumber;
            }

            if( Global.IsPropertyDirty(4096, setupParam.DirtyFieldFlags) )
            {
                setup.NewStatus = setupParam.NewStatus;
            }

            if( Global.IsPropertyDirty(8192, setupParam.DirtyFieldFlags) )
            {
                setup.ExpectedDate = setupParam.ExpectedDate;
            }

            if( Global.IsPropertyDirty(16384, setupParam.DirtyFieldFlags) )
            {
                setup.UserName = setupParam.UserName;
            }

            if( Global.IsPropertyDirty(65536, setupParam.DirtyFieldFlags) )
            {
                setup.GenerateTimeBombs = setupParam.GenerateTimeBombs;
            }

            if( Global.IsPropertyDirty(131072, setupParam.DirtyFieldFlags) )
            {
                setup.UseTransitions = setupParam.UseTransitions;
            }

            if( Global.IsPropertyDirty(262144, setupParam.DirtyFieldFlags) )
            {
                setupParam.ToLocation = new Protocols.LocationProtocol(); setupParam.ToLocation.IsPrimaryBinSuggestion = setup.ToLocation.IsPrimaryBinSuggestion; setupParam.ToLocation.LocationName = setup.ToLocation.LocationName; setupParam.ToLocation.BinName = setup.ToLocation.BinName;
            }

            if( Global.IsPropertyDirty(524288, setupParam.DirtyFieldFlags) )
            {
                setupParam.FromLocation = new Protocols.LocationProtocol(); setupParam.FromLocation.IsPrimaryBinSuggestion = setup.FromLocation.IsPrimaryBinSuggestion; setupParam.FromLocation.LocationName = setup.FromLocation.LocationName; setupParam.FromLocation.BinName = setup.FromLocation.BinName;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.BackorderPartRequest(setup) );
        }
        public Protocols.ToolkitResultProtocol UpdateGLAccount(System.String currentName, System.String siteIDNum)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.UpdateGLAccount(currentName, siteIDNum) );
        }
        public Protocols.ToolkitResultProtocol UpdateGLAccount(Protocols.Logistics.UpdateGLAccountSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );
            FChoice.Toolkits.Clarify.Logistics.UpdateGLAccountSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Logistics.UpdateGLAccountSetup(setupParam.CurrentName, setupParam.SiteIDNum);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
            {
                setup.CurrentName = setupParam.CurrentName;
            }

            if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
            {
                setup.NewName = setupParam.NewName;
            }

            if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
            {
                setup.AccountType = setupParam.AccountType;
            }

            if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
            {
                setup.Description = setupParam.Description;
            }

            if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
            {
                setup.AccountNumber = setupParam.AccountNumber;
            }

            if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
            {
                setup.IsExpenseGLAccount = setupParam.IsExpenseGLAccount;
            }

            if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
            {
                setup.IsActive = setupParam.IsActive;
            }

            if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
            {
                setup.IsCompany = setupParam.IsCompany;
            }

            if( Global.IsPropertyDirty(256, setupParam.DirtyFieldFlags) )
            {
                setup.SiteIDNum = setupParam.SiteIDNum;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.UpdateGLAccount(setup) );
        }
        public Protocols.ToolkitResultProtocol Unpick(Protocols.Logistics.UnpickSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );
            FChoice.Toolkits.Clarify.Logistics.UnpickSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Logistics.UnpickSetup(setupParam.PartRequestDetailIDNum, setupParam.Location.ToLocation());
                    break;
                case 1:
                    setup = new FChoice.Toolkits.Clarify.Logistics.UnpickSetup(setupParam.PartRequestDetailIDNum, setupParam.Location.ToLocation(), setupParam.SerialNumbers);
                    break;
                case 2:
                    setup = new FChoice.Toolkits.Clarify.Logistics.UnpickSetup(setupParam.PartRequestDetailIDNum, setupParam.Location.ToLocation(), setupParam.UseTransitions);
                    break;
                case 3:
                    setup = new FChoice.Toolkits.Clarify.Logistics.UnpickSetup(setupParam.PartRequestDetailIDNum, setupParam.Location.ToLocation(), setupParam.UseTransitions, setupParam.SerialNumbers);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
            {
                setup.PartRequestDetailIDNum = setupParam.PartRequestDetailIDNum;
            }

            if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
            {
                setup.UseGood = setupParam.UseGood;
            }

            if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
            {
                setup.UserName = setupParam.UserName;
            }

            if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
            {
                setup.UnpickDate = setupParam.UnpickDate;
            }

            if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
            {
                setup.SerialNumbers = setupParam.SerialNumbers;
            }

            if( Global.IsPropertyDirty(256, setupParam.DirtyFieldFlags) )
            {
                setup.UseTransitions = setupParam.UseTransitions;
            }

            if( Global.IsPropertyDirty(512, setupParam.DirtyFieldFlags) )
            {
                setup.GenerateTimeBombs = setupParam.GenerateTimeBombs;
            }

            if( Global.IsPropertyDirty(1024, setupParam.DirtyFieldFlags) )
            {
                setupParam.Location = new Protocols.LocationProtocol(); setupParam.Location.IsPrimaryBinSuggestion = setup.Location.IsPrimaryBinSuggestion; setupParam.Location.LocationName = setup.Location.LocationName; setupParam.Location.BinName = setup.Location.BinName;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.Unpick(setup) );
        }
        public Protocols.ToolkitResultProtocol Unpick(System.String partRequestDetailIDNum, Protocols.LocationProtocol location, System.Boolean useTransitions, System.String[] serialNumbers)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.Unpick(partRequestDetailIDNum, location.ToLocation(), useTransitions, serialNumbers) );
        }
        public Protocols.ToolkitResultProtocol Ship(Protocols.Logistics.ShipSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );
            FChoice.Toolkits.Clarify.Logistics.ShipSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Logistics.ShipSetup(setupParam.PartRequestDetailIDNum);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
            {
                setup.PartRequestDetailIDNum = setupParam.PartRequestDetailIDNum;
            }

            if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
            {
                setup.SiteName = setupParam.SiteName;
            }

            if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
            {
                setup.Address1 = setupParam.Address1;
            }

            if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
            {
                setup.Address2 = setupParam.Address2;
            }

            if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
            {
                setup.City = setupParam.City;
            }

            if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
            {
                setup.State = setupParam.State;
            }

            if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
            {
                setup.ZipCode = setupParam.ZipCode;
            }

            if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
            {
                setup.Country = setupParam.Country;
            }

            if( Global.IsPropertyDirty(256, setupParam.DirtyFieldFlags) )
            {
                setup.ContactFirstName = setupParam.ContactFirstName;
            }

            if( Global.IsPropertyDirty(512, setupParam.DirtyFieldFlags) )
            {
                setup.ContactLastName = setupParam.ContactLastName;
            }

            if( Global.IsPropertyDirty(1024, setupParam.DirtyFieldFlags) )
            {
                setup.WaybillName = setupParam.WaybillName;
            }

            if( Global.IsPropertyDirty(2048, setupParam.DirtyFieldFlags) )
            {
                setup.PackingList = setupParam.PackingList;
            }

            if( Global.IsPropertyDirty(4096, setupParam.DirtyFieldFlags) )
            {
                setup.PieceCount = setupParam.PieceCount;
            }

            if( Global.IsPropertyDirty(8192, setupParam.DirtyFieldFlags) )
            {
                setup.TotalWeight = setupParam.TotalWeight;
            }

            if( Global.IsPropertyDirty(16384, setupParam.DirtyFieldFlags) )
            {
                setup.Status = setupParam.Status;
            }

            if( Global.IsPropertyDirty(32768, setupParam.DirtyFieldFlags) )
            {
                setup.ShipDate = setupParam.ShipDate;
            }

            if( Global.IsPropertyDirty(65536, setupParam.DirtyFieldFlags) )
            {
                setup.UserName = setupParam.UserName;
            }

            if( Global.IsPropertyDirty(131072, setupParam.DirtyFieldFlags) )
            {
                setup.CarrierName = setupParam.CarrierName;
            }

            if( Global.IsPropertyDirty(262144, setupParam.DirtyFieldFlags) )
            {
                setup.GenerateTimeBombs = setupParam.GenerateTimeBombs;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.Ship(setup) );
        }
        public Protocols.ToolkitResultProtocol SetPartStockingLevel(Protocols.LocationProtocol location, System.String queue, System.String partNumber, System.String partRevision, System.String partDomain, System.Int16 partMinimum, System.Int16 partMaximum, System.Int16 partReorderLevel, System.Int16 partReorderQuantity)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.SetPartStockingLevel(location.ToLocation(), queue, partNumber, partRevision, partDomain, partMinimum, partMaximum, partReorderLevel, partReorderQuantity) );
        }
        public Protocols.ToolkitResultProtocol AddInventoryBin(Protocols.LocationProtocol location)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.AddInventoryBin(location.ToLocation()) );
        }
        public Protocols.ToolkitResultProtocol BackorderPartRequest(System.String partRequestDetailIDNum, System.DateTime expectedDate, System.Boolean useTransitions, System.String serialNumber)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.BackorderPartRequest(partRequestDetailIDNum, expectedDate, useTransitions, serialNumber) );
        }
        public Protocols.ToolkitResultProtocol UpdateInventoryBin(Protocols.LocationProtocol currentLocation, System.String newBinName)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.UpdateInventoryBin(currentLocation.ToLocation(), newBinName) );
        }
        public Protocols.ToolkitResultProtocol UpdateInventoryBin(Protocols.Logistics.UpdateInventoryBinSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );
            FChoice.Toolkits.Clarify.Logistics.UpdateInventoryBinSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Logistics.UpdateInventoryBinSetup(setupParam.CurrentLocation.ToLocation(), setupParam.NewBinName);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
            {
                setup.NewBinName = setupParam.NewBinName;
            }

            if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
            {
                setup.IsActive = setupParam.IsActive;
            }

            if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
            {
                setupParam.CurrentLocation = new Protocols.LocationProtocol(); setupParam.CurrentLocation.IsPrimaryBinSuggestion = setup.CurrentLocation.IsPrimaryBinSuggestion; setupParam.CurrentLocation.LocationName = setup.CurrentLocation.LocationName; setupParam.CurrentLocation.BinName = setup.CurrentLocation.BinName;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.UpdateInventoryBin(setup) );
        }
        public Protocols.ToolkitResultProtocol AddInventoryLocation(Protocols.Logistics.AddInventoryLocationSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );
            FChoice.Toolkits.Clarify.Logistics.AddInventoryLocationSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Logistics.AddInventoryLocationSetup(setupParam.LocationName, setupParam.CapitalGLAccount, setupParam.SiteIDNum, setupParam.PartAuthorizationLevel);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
            {
                setup.LocationName = setupParam.LocationName;
            }

            if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
            {
                setup.AccountType = setupParam.AccountType;
            }

            if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
            {
                setup.Description = setupParam.Description;
            }

            if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
            {
                setup.ReportsToLocation = setupParam.ReportsToLocation;
            }

            if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
            {
                setup.CapitalGLAccount = setupParam.CapitalGLAccount;
            }

            if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
            {
                setup.IsActive = setupParam.IsActive;
            }

            if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
            {
                setup.IsCompany = setupParam.IsCompany;
            }

            if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
            {
                setup.SiteIDNum = setupParam.SiteIDNum;
            }

            if( Global.IsPropertyDirty(256, setupParam.DirtyFieldFlags) )
            {
                setup.PartAuthorizationLevel = setupParam.PartAuthorizationLevel;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.AddInventoryLocation(setup) );
        }
        public Protocols.ToolkitResultProtocol CreateContainer(Protocols.Logistics.CreateContainerSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );
            FChoice.Toolkits.Clarify.Logistics.CreateContainerSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Logistics.CreateContainerSetup(setupParam.ContainerName, setupParam.LocationName);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(1, setupParam.DirtyFieldFlags) )
            {
                setup.ContainerName = setupParam.ContainerName;
            }

            if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
            {
                setup.LocationName = setupParam.LocationName;
            }

            if( Global.IsPropertyDirty(4, setupParam.DirtyFieldFlags) )
            {
                setup.BinName = setupParam.BinName;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.CreateContainer(setup) );
        }
        public Protocols.ToolkitResultProtocol UpdatePartStockingLevel(Protocols.LocationProtocol currentLocation, System.String queue, System.String partNumber, System.String partRevision, System.String partDomain)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.UpdatePartStockingLevel(currentLocation.ToLocation(), queue, partNumber, partRevision, partDomain) );
        }
        public Protocols.Logistics.CreatePartRequestDetailResultProtocol CreatePartRequestDetail(System.String partRequestHeaderIDNum, System.String serialNumber, System.Int32 sitePartObjid)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.Logistics.CreatePartRequestDetailResultProtocol( toolkit.CreatePartRequestDetail(partRequestHeaderIDNum, serialNumber, sitePartObjid) );
        }
        public Protocols.ToolkitResultProtocol UpdatePartStockingLevel(Protocols.Logistics.UpdatePartStockingLevelSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );
            FChoice.Toolkits.Clarify.Logistics.UpdatePartStockingLevelSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Logistics.UpdatePartStockingLevelSetup(setupParam.CurrentLocation.ToLocation(), setupParam.Queue, setupParam.PartNumber, setupParam.PartRevision, setupParam.PartDomain);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

            if( Global.IsPropertyDirty(2, setupParam.DirtyFieldFlags) )
            {
                setup.ToBinName = setupParam.ToBinName;
            }

            if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
            {
                setup.Queue = setupParam.Queue;
            }

            if( Global.IsPropertyDirty(16, setupParam.DirtyFieldFlags) )
            {
                setup.ToQueue = setupParam.ToQueue;
            }

            if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
            {
                setup.PartNumber = setupParam.PartNumber;
            }

            if( Global.IsPropertyDirty(64, setupParam.DirtyFieldFlags) )
            {
                setup.PartRevision = setupParam.PartRevision;
            }

            if( Global.IsPropertyDirty(128, setupParam.DirtyFieldFlags) )
            {
                setup.PartDomain = setupParam.PartDomain;
            }

            if( Global.IsPropertyDirty(256, setupParam.DirtyFieldFlags) )
            {
                setup.PartMinimum = setupParam.PartMinimum;
            }

            if( Global.IsPropertyDirty(512, setupParam.DirtyFieldFlags) )
            {
                setup.PartMaximum = setupParam.PartMaximum;
            }

            if( Global.IsPropertyDirty(1024, setupParam.DirtyFieldFlags) )
            {
                setup.PartReorderLevel = setupParam.PartReorderLevel;
            }

            if( Global.IsPropertyDirty(2048, setupParam.DirtyFieldFlags) )
            {
                setup.PartReorderQuantity = setupParam.PartReorderQuantity;
            }

            if( Global.IsPropertyDirty(4096, setupParam.DirtyFieldFlags) )
            {
                setup.IsActive = setupParam.IsActive;
            }

            if( Global.IsPropertyDirty(8192, setupParam.DirtyFieldFlags) )
            {
                setupParam.CurrentLocation = new Protocols.LocationProtocol(); setupParam.CurrentLocation.IsPrimaryBinSuggestion = setup.CurrentLocation.IsPrimaryBinSuggestion; setupParam.CurrentLocation.LocationName = setup.CurrentLocation.LocationName; setupParam.CurrentLocation.BinName = setup.CurrentLocation.BinName;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.UpdatePartStockingLevel(setup) );
        }
        public Protocols.ToolkitResultProtocol CreatePartRequestHeader(System.String contactFirstName, System.String contactLastName, System.String contactPhone, System.String shipToSiteIDNum)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.CreatePartRequestHeader(contactFirstName, contactLastName, contactPhone, shipToSiteIDNum) );
        }
        public Protocols.ToolkitResultProtocol AddLocationServicingSite(System.String siteIDNum, System.String locationName, System.Int16 locationRank)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.AddLocationServicingSite(siteIDNum, locationName, locationRank) );
        }
        public Protocols.ToolkitResultProtocol AddAlternatePart(System.String partNumber, System.String partRevision, System.String partDomain, System.String alternatePartNumber, System.String alternatePartRevision, System.String alternatePartDomain)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.AddAlternatePart(partNumber, partRevision, partDomain, alternatePartNumber, alternatePartRevision, alternatePartDomain) );
        }
        public Protocols.ToolkitResultProtocol SetLogisticsTransition(FChoice.Toolkits.Clarify.PartRequestType partRequestType, FChoice.Toolkits.Clarify.PartRequestCondition startCondition, FChoice.Toolkits.Clarify.PartRequestCondition endCondition, System.String[] privilegeClasses)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit toolkit = new FChoice.Toolkits.Clarify.Logistics.LogisticsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.SetLogisticsTransition(partRequestType, startCondition, endCondition, privilegeClasses) );
        }