public Protocols.FieldOps.AddServiceInterruptionResultProtocol AddServiceInterruption(System.String caseIDNum)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.FieldOps.AddServiceInterruptionResultProtocol( toolkit.AddServiceInterruption(caseIDNum) );
        }
        public Protocols.ToolkitResultProtocol LogPartsUsedInstall(System.String partRequestDetailIDNum, System.String caseIDNum, System.String installPartNumber, System.String installPartRevision, System.String installPartDomain, System.String installSerialNumber)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.LogPartsUsedInstall(partRequestDetailIDNum, caseIDNum, installPartNumber, installPartRevision, installPartDomain, installSerialNumber) );
        }
        public Protocols.ToolkitResultProtocol InstallSitePart(System.String siteIDNum, System.String partNumber, System.String partrevision, System.String partdomain, System.String serialNumber)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.InstallSitePart(siteIDNum, partNumber, partrevision, partdomain, serialNumber) );
        }
        public Protocols.ToolkitResultProtocol DispatchFieldEngineer(System.String caseIDNum)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.DispatchFieldEngineer(caseIDNum) );
        }
        public Protocols.ToolkitResultProtocol DeleteTimeLog(System.Int32 timeLogObjid)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.DeleteTimeLog(timeLogObjid) );
        }
        public Protocols.FieldOps.AddServiceInterruptionResultProtocol AddServiceInterruption(Protocols.FieldOps.AddServiceInterruptionSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );
            FChoice.Toolkits.Clarify.FieldOps.AddServiceInterruptionSetup setup;

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

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

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

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

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

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

            if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
            {
                setup.Duration = TimeSpan.FromSeconds(setupParam.Duration);
            }

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

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

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

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

            return new Protocols.FieldOps.AddServiceInterruptionResultProtocol( toolkit.AddServiceInterruption(setup) );
        }
        public Protocols.ToolkitResultProtocol MoveSitePartToBin(System.Int32 sitePartObjid, System.Int32 parentBinObjid)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.MoveSitePartToBin(sitePartObjid, parentBinObjid) );
        }
        public Protocols.FieldOps.CreateTimeLogResultProtocol CreateTimeLog(System.Int32 onsiteLogObjid, System.DateTime startDate, System.Int32 duration)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.FieldOps.CreateTimeLogResultProtocol( toolkit.CreateTimeLog(onsiteLogObjid, startDate, TimeSpan.FromSeconds(duration)) );
        }
        public Protocols.ToolkitResultProtocol LogPartsUsedUpgrade(System.String partRequestDetailIDNum, System.String caseIDNum, System.Int32 removeSitePartObjid, System.String installPartNumber, System.String installPartRevision, System.String installPartDomain, System.Int32 installQuantity)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.LogPartsUsedUpgrade(partRequestDetailIDNum, caseIDNum, removeSitePartObjid, installPartNumber, installPartRevision, installPartDomain, installQuantity) );
        }
        public Protocols.ToolkitResultProtocol LogPartsUsedUpgrade(Protocols.FieldOps.LogPartsUsedUpgradeSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );
            FChoice.Toolkits.Clarify.FieldOps.LogPartsUsedUpgradeSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.FieldOps.LogPartsUsedUpgradeSetup(setupParam.PartRequestDetailIDNum, setupParam.RemoveSitePartObjid, setupParam.InstallPartNumber, setupParam.InstallPartRevision, setupParam.InstallPartDomain, setupParam.InstallSerialNumber);
                    break;
                case 1:
                    setup = new FChoice.Toolkits.Clarify.FieldOps.LogPartsUsedUpgradeSetup(setupParam.PartRequestDetailIDNum, setupParam.RemoveSitePartObjid, setupParam.InstallPartNumber, setupParam.InstallPartRevision, setupParam.InstallPartDomain, setupParam.InstallQuantity);
                    break;
                case 2:
                    setup = new FChoice.Toolkits.Clarify.FieldOps.LogPartsUsedUpgradeSetup(setupParam.PartRequestDetailIDNum, setupParam.CaseIDNum, setupParam.RemoveSitePartObjid, setupParam.InstallPartNumber, setupParam.InstallPartRevision, setupParam.InstallPartDomain, setupParam.InstallSerialNumber);
                    break;
                case 3:
                    setup = new FChoice.Toolkits.Clarify.FieldOps.LogPartsUsedUpgradeSetup(setupParam.PartRequestDetailIDNum, setupParam.CaseIDNum, setupParam.RemoveSitePartObjid, setupParam.InstallPartNumber, setupParam.InstallPartRevision, setupParam.InstallPartDomain, setupParam.InstallQuantity);
                    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.CaseIDNum = setupParam.CaseIDNum;
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            if( Global.IsPropertyDirty(2097152, setupParam.DirtyFieldFlags) )
            {
                setup.EngineerUserName = setupParam.EngineerUserName;
            }

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

            if( Global.IsPropertyDirty(8388608, setupParam.DirtyFieldFlags) )
            {
                setup.AllowMove = setupParam.AllowMove;
            }

            if( Global.IsPropertyDirty(16777216, setupParam.DirtyFieldFlags) )
            {
                setup.LogDate = setupParam.LogDate;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.LogPartsUsedUpgrade(setup) );
        }
        public Protocols.ToolkitResultProtocol LogPartsUsedRemove(System.String partRequestDetailIDNum, System.String caseIDNum, System.Int32 removeSitePartObjid)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.LogPartsUsedRemove(partRequestDetailIDNum, caseIDNum, removeSitePartObjid) );
        }
        public Protocols.FieldOps.CreateAppointmentResultProtocol CreateAppointment(Protocols.FieldOps.CreateAppointmentSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );
            FChoice.Toolkits.Clarify.FieldOps.CreateAppointmentSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.FieldOps.CreateAppointmentSetup(setupParam.StartDate, setupParam.EndDate);
                    break;
                case 1:
                    setup = new FChoice.Toolkits.Clarify.FieldOps.CreateAppointmentSetup(setupParam.StartDate, TimeSpan.FromSeconds(setupParam.Duration));
                    break;
                case 2:
                    setup = new FChoice.Toolkits.Clarify.FieldOps.CreateAppointmentSetup(TimeSpan.FromSeconds(setupParam.Duration), setupParam.EndDate);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

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

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

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

            if( Global.IsPropertyDirty(8, setupParam.DirtyFieldFlags) )
            {
                setup.Duration = TimeSpan.FromSeconds(setupParam.Duration);
            }

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

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

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

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

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

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

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

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

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

            return new Protocols.FieldOps.CreateAppointmentResultProtocol( toolkit.CreateAppointment(setup) );
        }
        public Protocols.FieldOps.CreateAppointmentResultProtocol CreateAppointment(System.Int32 duration, System.DateTime endDate)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.FieldOps.CreateAppointmentResultProtocol( toolkit.CreateAppointment(TimeSpan.FromSeconds(duration), endDate) );
        }
        public Protocols.ToolkitResultProtocol CreateOnsiteLog(FChoice.Toolkits.Clarify.CaseObjectType objectType, System.String objectIDNum)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.CreateOnsiteLog(objectType, objectIDNum) );
        }
        public Protocols.ToolkitResultProtocol MoveSitePartToSite(System.Int32 sitePartObjid, System.String siteIDNum)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.MoveSitePartToSite(sitePartObjid, siteIDNum) );
        }
        public Protocols.ToolkitResultProtocol CreateOnsiteLog(Protocols.FieldOps.CreateOnsiteLogSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );
            FChoice.Toolkits.Clarify.FieldOps.CreateOnsiteLogSetup setup;

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

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

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

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

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

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

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

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

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

            return new Protocols.ToolkitResultProtocol( toolkit.CreateOnsiteLog(setup) );
        }
        public Protocols.FieldOps.PartTransferResultProtocol PartTransfer(System.String partNumber, System.String partRevision, System.String partDomain, System.String serialNumber, Protocols.LocationProtocol fromlocation, Protocols.LocationProtocol tolocation)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.FieldOps.PartTransferResultProtocol( toolkit.PartTransfer(partNumber, partRevision, partDomain, serialNumber, fromlocation.ToLocation(), tolocation.ToLocation()) );
        }
        public Protocols.FieldOps.CreateTimeLogResultProtocol CreateTimeLog(Protocols.FieldOps.CreateTimeLogSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );
            FChoice.Toolkits.Clarify.FieldOps.CreateTimeLogSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.FieldOps.CreateTimeLogSetup(setupParam.OnsiteLogObjid, setupParam.StartDate, TimeSpan.FromSeconds(setupParam.Duration));
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

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

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

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

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

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

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

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

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

            if( Global.IsPropertyDirty(256, setupParam.DirtyFieldFlags) )
            {
                setup.Duration = TimeSpan.FromSeconds(setupParam.Duration);
            }

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

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

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

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

            return new Protocols.FieldOps.CreateTimeLogResultProtocol( toolkit.CreateTimeLog(setup) );
        }
        public Protocols.FieldOps.PartTransferResultProtocol PartTransfer(Protocols.FieldOps.PartTransferSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );
            FChoice.Toolkits.Clarify.FieldOps.PartTransferSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.FieldOps.PartTransferSetup(setupParam.PartNumber, setupParam.PartRevision, setupParam.PartDomain, setupParam.Quantity, setupParam.FromLocation.ToLocation(), setupParam.ToLocation.ToLocation());
                    break;
                case 1:
                    setup = new FChoice.Toolkits.Clarify.FieldOps.PartTransferSetup(setupParam.PartNumber, setupParam.PartRevision, setupParam.PartDomain, setupParam.SerialNumber, setupParam.FromLocation.ToLocation(), setupParam.ToLocation.ToLocation());
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

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

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

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

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

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

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

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

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

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

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

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

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

            if( Global.IsPropertyDirty(8388608, 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;
            }

            if( Global.IsPropertyDirty(16777216, 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;
            }

            return new Protocols.FieldOps.PartTransferResultProtocol( toolkit.PartTransfer(setup) );
        }
        public Protocols.ToolkitResultProtocol DeinstallSitePart(System.Int32 sitePartObjid)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.DeinstallSitePart(sitePartObjid) );
        }
        public Protocols.ToolkitResultProtocol ReinstallSitePart(Protocols.FieldOps.ReinstallSitePartSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );
            FChoice.Toolkits.Clarify.FieldOps.ReinstallSitePartSetup setup;

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

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

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

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

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

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

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

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

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

            return new Protocols.ToolkitResultProtocol( toolkit.ReinstallSitePart(setup) );
        }
        public Protocols.ToolkitResultProtocol DeleteServiceInterruption(System.Int32 appointmentObjid)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.DeleteServiceInterruption(appointmentObjid) );
        }
        public Protocols.ToolkitResultProtocol UpdateExpenseLog(System.Int32 expenseLogObjid, System.Double quantity, System.Double rate)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.UpdateExpenseLog(expenseLogObjid, quantity, rate) );
        }
        public Protocols.ToolkitResultProtocol DeleteTimeLog(Protocols.FieldOps.DeleteTimeLogSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );
            FChoice.Toolkits.Clarify.FieldOps.DeleteTimeLogSetup setup;

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

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

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

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

            return new Protocols.ToolkitResultProtocol( toolkit.DeleteTimeLog(setup) );
        }
        public Protocols.ToolkitResultProtocol UpdateExpenseLog(Protocols.FieldOps.UpdateExpenseLogSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );
            FChoice.Toolkits.Clarify.FieldOps.UpdateExpenseLogSetup setup;

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

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

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

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

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

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

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

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

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

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

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

            return new Protocols.ToolkitResultProtocol( toolkit.UpdateExpenseLog(setup) );
        }
        public Protocols.ToolkitResultProtocol DispatchFieldEngineer(Protocols.FieldOps.DispatchFieldEngineerSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );
            FChoice.Toolkits.Clarify.FieldOps.DispatchFieldEngineerSetup setup;

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

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

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

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

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

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

            if( Global.IsPropertyDirty(32, setupParam.DirtyFieldFlags) )
            {
                setup.Duration = TimeSpan.FromSeconds(setupParam.Duration);
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            if( Global.IsPropertyDirty(2097152, setupParam.DirtyFieldFlags) )
            {
                setup.AppointmentConfirmed = setupParam.AppointmentConfirmed;
            }

            if( Global.IsPropertyDirty(4194304, setupParam.DirtyFieldFlags) )
            {
                setup.CellText = setupParam.CellText;
            }

            if( Global.IsPropertyDirty(8388608, setupParam.DirtyFieldFlags) )
            {
                setup.Proxy = setupParam.Proxy;
            }

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

            return new Protocols.ToolkitResultProtocol( toolkit.DispatchFieldEngineer(setup) );
        }
        public Protocols.FieldOps.CreateExpenseLogResultProtocol CreateExpenseLog(System.Int32 onsiteLogObjid)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.FieldOps.CreateExpenseLogResultProtocol( toolkit.CreateExpenseLog(onsiteLogObjid) );
        }
        public Protocols.ToolkitResultProtocol InstallSitePart(Protocols.FieldOps.InstallSitePartSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );
            FChoice.Toolkits.Clarify.FieldOps.InstallSitePartSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.FieldOps.InstallSitePartSetup(setupParam.SiteIDNum, setupParam.PartNumber, setupParam.PartRevision, setupParam.PartDomain, setupParam.Quantity);
                    break;
                case 1:
                    setup = new FChoice.Toolkits.Clarify.FieldOps.InstallSitePartSetup(setupParam.SiteIDNum, setupParam.PartNumber, setupParam.PartRevision, setupParam.PartDomain, setupParam.SerialNumber);
                    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.PartNumber = setupParam.PartNumber;
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            return new Protocols.ToolkitResultProtocol( toolkit.InstallSitePart(setup) );
        }
        public Protocols.FieldOps.CreateAppointmentResultProtocol CreateAppointment(System.DateTime startDate, System.DateTime endDate)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit toolkit = new FChoice.Toolkits.Clarify.FieldOps.FieldOpsToolkit( session );

            return new Protocols.FieldOps.CreateAppointmentResultProtocol( toolkit.CreateAppointment(startDate, endDate) );
        }