public Protocols.ToolkitResultProtocol AcceptQuote(System.String quoteIDNum)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.AcceptQuote(quoteIDNum) );
        }
        public Protocols.ToolkitResultProtocol AcceptQuote(Protocols.Contracts.AcceptQuoteSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
            FChoice.Toolkits.Clarify.Contracts.AcceptQuoteSetup setup;

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

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

            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.AcceptQuote(setup) );
        }
        public Protocols.ToolkitResultProtocol DeleteSitePart(Protocols.Contracts.DeleteSitePartSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
            FChoice.Toolkits.Clarify.Contracts.DeleteSitePartSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Contracts.DeleteSitePartSetup(setupParam.SitePartObjid);
                    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;
            }

            return new Protocols.ToolkitResultProtocol( toolkit.DeleteSitePart(setup) );
        }
        public Protocols.ToolkitResultProtocol DeleteSitePart(System.Int32 sitePartObjid)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.DeleteSitePart(sitePartObjid) );
        }
        public Protocols.ToolkitResultProtocol CreateSchedule(Protocols.Contracts.CreateScheduleSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
            FChoice.Toolkits.Clarify.Contracts.CreateScheduleSetup setup;

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

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

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

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

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

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

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

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

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

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

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

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

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

            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.CreateSchedule(setup) );
        }
        public Protocols.ToolkitResultProtocol CreateSchedule(System.String contractIDNum)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.CreateSchedule(contractIDNum) );
        }
        public Protocols.ToolkitResultProtocol CreatePriceInstance(Protocols.Contracts.CreatePriceInstanceSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
            FChoice.Toolkits.Clarify.Contracts.CreatePriceInstanceSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Contracts.CreatePriceInstanceSetup(setupParam.PartNumber, setupParam.PartRevision, setupParam.PartDomain, setupParam.SupportProgram, setupParam.PriceProgram, setupParam.PriceType, setupParam.Quantity);
                    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.SupportProgram = setupParam.SupportProgram;
            }

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

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

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

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

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

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

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

            return new Protocols.ToolkitResultProtocol( toolkit.CreatePriceInstance(setup) );
        }
        public Protocols.ToolkitResultProtocol ReopenContract(System.String contractIDNum, System.String status)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.ReopenContract(contractIDNum, status) );
        }
        public Protocols.ToolkitResultProtocol LogContractNote(Protocols.Contracts.LogContractNoteSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
            FChoice.Toolkits.Clarify.Contracts.LogContractNoteSetup setup;

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

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

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

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

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

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

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

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

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

            return new Protocols.ToolkitResultProtocol( toolkit.LogContractNote(setup) );
        }
        public Protocols.ToolkitResultProtocol CreateContractLineItem(Protocols.Contracts.CreateContractLineItemSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
            FChoice.Toolkits.Clarify.Contracts.CreateContractLineItemSetup setup;

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

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

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

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

            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.PartNumber = setupParam.PartNumber;
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            return new Protocols.ToolkitResultProtocol( toolkit.CreateContractLineItem(setup) );
        }
        public Protocols.ToolkitResultProtocol CreateContractLineItem(System.String contractIDNum, System.String partNumber, System.String partDomain, System.String partRevision, System.String priceSchedule, System.String serialNumber, System.Int32 parentLineItemObjid)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.CreateContractLineItem(contractIDNum, partNumber, partDomain, partRevision, priceSchedule, serialNumber, parentLineItemObjid) );
        }
        public Protocols.ToolkitResultProtocol CreateContract(Protocols.Contracts.CreateContractSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
            FChoice.Toolkits.Clarify.Contracts.CreateContractSetup setup;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            return new Protocols.ToolkitResultProtocol( toolkit.CreateContract(setup) );
        }
        public Protocols.ToolkitResultProtocol CreateContract(System.String title)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.CreateContract(title) );
        }
        public Protocols.ToolkitResultProtocol UnrelateContractItemFromSitePart(Protocols.Contracts.UnrelateContractItemFromSitePartSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
            FChoice.Toolkits.Clarify.Contracts.UnrelateContractItemFromSitePartSetup setup;

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

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

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

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

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

            return new Protocols.ToolkitResultProtocol( toolkit.UnrelateContractItemFromSitePart(setup) );
        }
        public Protocols.ToolkitResultProtocol UnrelateContractItemFromSitePart(System.Int32 contractObjid, System.String partNumber, System.String partDomain, System.String partRevision)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.UnrelateContractItemFromSitePart(contractObjid, partNumber, partDomain, partRevision) );
        }
        public Protocols.ToolkitResultProtocol ForwardQuote(System.String quoteIDNum, System.String newQueue)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.ForwardQuote(quoteIDNum, newQueue) );
        }
        public Protocols.ToolkitResultProtocol LogContractNote(System.String contractIDNum, System.String notes)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.LogContractNote(contractIDNum, notes) );
        }
        public Protocols.ToolkitResultProtocol CreatePriceInstance(System.String partNumber, System.String partRevision, System.String partDomain, System.String supportProgram, System.String priceProgram, FChoice.Toolkits.Clarify.PriceInstanceType priceType, System.Int32 quantity)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.CreatePriceInstance(partNumber, partRevision, partDomain, supportProgram, priceProgram, priceType, quantity) );
        }
        public Protocols.ToolkitResultProtocol AddPOToSchedule(System.String contractIDNum, System.String scheduleIDNum, System.String poIDNum, System.Decimal poAmount)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );

            return new Protocols.ToolkitResultProtocol( toolkit.AddPOToSchedule(contractIDNum, scheduleIDNum, poIDNum, poAmount) );
        }
        public Protocols.ToolkitResultProtocol AddPOToSchedule(Protocols.Contracts.AddPOToScheduleSetupProtocol setupParam)
        {
            ClarifySession session = Global.GetSession( AuthHeader );
            FChoice.Toolkits.Clarify.Contracts.ContractsToolkit toolkit = new FChoice.Toolkits.Clarify.Contracts.ContractsToolkit( session );
            FChoice.Toolkits.Clarify.Contracts.AddPOToScheduleSetup setup;

            switch( setupParam.ConstructorCue )
            {
                case 0:
                    setup = new FChoice.Toolkits.Clarify.Contracts.AddPOToScheduleSetup(setupParam.ContractIDNum, setupParam.ScheduleIDNum, setupParam.POIDNum, setupParam.POAmount);
                    break;
                default:
                    throw new InvalidOperationException(string.Format("Constructor index '{0}' does not exist.", setupParam.ConstructorCue));
            }

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

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

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

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

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

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

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

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

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

            return new Protocols.ToolkitResultProtocol( toolkit.AddPOToSchedule(setup) );
        }