/*
 * An XML document type.
 * Localname: rosettanet-binding
 * Namespace: http://www.bea.com/2003/03/wli/tpm
 * Java type: com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument
 *
 * Automatically generated - do not modify.
 */
package com.bea.x2003.x03.wli.tpm.impl;
/**
 * A document containing one rosettanet-binding(@http://www.bea.com/2003/03/wli/tpm) element.
 *
 * This is a complex type.
 */
public class RosettanetBindingDocumentImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument
{
    
    public RosettanetBindingDocumentImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName ROSETTANETBINDING$0 = 
        new javax.xml.namespace.QName("http://www.bea.com/2003/03/wli/tpm", "rosettanet-binding");
    
    
    /**
     * Gets the "rosettanet-binding" element
     */
    public com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding getRosettanetBinding()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding target = null;
            target = (com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding)get_store().find_element_user(ROSETTANETBINDING$0, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * Sets the "rosettanet-binding" element
     */
    public void setRosettanetBinding(com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding rosettanetBinding)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding target = null;
            target = (com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding)get_store().find_element_user(ROSETTANETBINDING$0, 0);
            if (target == null)
            {
                target = (com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding)get_store().add_element_user(ROSETTANETBINDING$0);
            }
            target.set(rosettanetBinding);
        }
    }
    
    /**
     * Appends and returns a new empty "rosettanet-binding" element
     */
    public com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding addNewRosettanetBinding()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding target = null;
            target = (com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding)get_store().add_element_user(ROSETTANETBINDING$0);
            return target;
        }
    }
    /**
     * An XML rosettanet-binding(@http://www.bea.com/2003/03/wli/tpm).
     *
     * This is a complex type.
     */
    public static class RosettanetBindingImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding
    {
        
        public RosettanetBindingImpl(org.apache.xmlbeans.SchemaType sType)
        {
            super(sType);
        }
        
        private static final javax.xml.namespace.QName FAILUREREPORTADMINISTRATOR$0 = 
            new javax.xml.namespace.QName("http://www.bea.com/2003/03/wli/tpm", "failure-report-administrator");
        private static final javax.xml.namespace.QName FAILURENOTIFIER$2 = 
            new javax.xml.namespace.QName("http://www.bea.com/2003/03/wli/tpm", "failure-notifier");
        private static final javax.xml.namespace.QName TRANSPORT$4 = 
            new javax.xml.namespace.QName("http://www.bea.com/2003/03/wli/tpm", "transport");
        private static final javax.xml.namespace.QName NAME$6 = 
            new javax.xml.namespace.QName("", "name");
        private static final javax.xml.namespace.QName BUSINESSPROTOCOLNAME$8 = 
            new javax.xml.namespace.QName("", "business-protocol-name");
        private static final javax.xml.namespace.QName BUSINESSPROTOCOLVERSION$10 = 
            new javax.xml.namespace.QName("", "business-protocol-version");
        private static final javax.xml.namespace.QName ISDEFAULT$12 = 
            new javax.xml.namespace.QName("", "is-default");
        private static final javax.xml.namespace.QName ENCRYPTIONCERTIFICATENAME$14 = 
            new javax.xml.namespace.QName("", "encryption-certificate-name");
        private static final javax.xml.namespace.QName CIPHERALGORITHM$16 = 
            new javax.xml.namespace.QName("", "cipher-algorithm");
        private static final javax.xml.namespace.QName ENCRYPTIONLEVEL$18 = 
            new javax.xml.namespace.QName("", "encryption-level");
        private static final javax.xml.namespace.QName ISSIGNATUREREQUIRED$20 = 
            new javax.xml.namespace.QName("", "is-signature-required");
        private static final javax.xml.namespace.QName ISRECEIPTSIGNATUREREQUIRED$22 = 
            new javax.xml.namespace.QName("", "is-receipt-signature-required");
        private static final javax.xml.namespace.QName SIGNATUREDIGESTALGORITHM$24 = 
            new javax.xml.namespace.QName("", "signature-digest-algorithm");
        private static final javax.xml.namespace.QName SIGNATURECERTIFICATENAME$26 = 
            new javax.xml.namespace.QName("", "signature-certificate-name");
        private static final javax.xml.namespace.QName RETRIES$28 = 
            new javax.xml.namespace.QName("", "retries");
        private static final javax.xml.namespace.QName RETRYINTERVAL$30 = 
            new javax.xml.namespace.QName("", "retry-interval");
        private static final javax.xml.namespace.QName PROCESSTIMEOUT$32 = 
            new javax.xml.namespace.QName("", "process-timeout");
        
        
        /**
         * Gets the "failure-report-administrator" element
         */
        public com.bea.x2003.x03.wli.tpm.FailureReportAdministratorDocument.FailureReportAdministrator getFailureReportAdministrator()
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.FailureReportAdministratorDocument.FailureReportAdministrator target = null;
                target = (com.bea.x2003.x03.wli.tpm.FailureReportAdministratorDocument.FailureReportAdministrator)get_store().find_element_user(FAILUREREPORTADMINISTRATOR$0, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "failure-report-administrator" element
         */
        public boolean isSetFailureReportAdministrator()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(FAILUREREPORTADMINISTRATOR$0) != 0;
            }
        }
        
        /**
         * Sets the "failure-report-administrator" element
         */
        public void setFailureReportAdministrator(com.bea.x2003.x03.wli.tpm.FailureReportAdministratorDocument.FailureReportAdministrator failureReportAdministrator)
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.FailureReportAdministratorDocument.FailureReportAdministrator target = null;
                target = (com.bea.x2003.x03.wli.tpm.FailureReportAdministratorDocument.FailureReportAdministrator)get_store().find_element_user(FAILUREREPORTADMINISTRATOR$0, 0);
                if (target == null)
                {
                    target = (com.bea.x2003.x03.wli.tpm.FailureReportAdministratorDocument.FailureReportAdministrator)get_store().add_element_user(FAILUREREPORTADMINISTRATOR$0);
                }
                target.set(failureReportAdministrator);
            }
        }
        
        /**
         * Appends and returns a new empty "failure-report-administrator" element
         */
        public com.bea.x2003.x03.wli.tpm.FailureReportAdministratorDocument.FailureReportAdministrator addNewFailureReportAdministrator()
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.FailureReportAdministratorDocument.FailureReportAdministrator target = null;
                target = (com.bea.x2003.x03.wli.tpm.FailureReportAdministratorDocument.FailureReportAdministrator)get_store().add_element_user(FAILUREREPORTADMINISTRATOR$0);
                return target;
            }
        }
        
        /**
         * Unsets the "failure-report-administrator" element
         */
        public void unsetFailureReportAdministrator()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(FAILUREREPORTADMINISTRATOR$0, 0);
            }
        }
        
        /**
         * Gets the "failure-notifier" element
         */
        public com.bea.x2003.x03.wli.tpm.FailureNotifierDocument.FailureNotifier getFailureNotifier()
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.FailureNotifierDocument.FailureNotifier target = null;
                target = (com.bea.x2003.x03.wli.tpm.FailureNotifierDocument.FailureNotifier)get_store().find_element_user(FAILURENOTIFIER$2, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "failure-notifier" element
         */
        public boolean isSetFailureNotifier()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(FAILURENOTIFIER$2) != 0;
            }
        }
        
        /**
         * Sets the "failure-notifier" element
         */
        public void setFailureNotifier(com.bea.x2003.x03.wli.tpm.FailureNotifierDocument.FailureNotifier failureNotifier)
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.FailureNotifierDocument.FailureNotifier target = null;
                target = (com.bea.x2003.x03.wli.tpm.FailureNotifierDocument.FailureNotifier)get_store().find_element_user(FAILURENOTIFIER$2, 0);
                if (target == null)
                {
                    target = (com.bea.x2003.x03.wli.tpm.FailureNotifierDocument.FailureNotifier)get_store().add_element_user(FAILURENOTIFIER$2);
                }
                target.set(failureNotifier);
            }
        }
        
        /**
         * Appends and returns a new empty "failure-notifier" element
         */
        public com.bea.x2003.x03.wli.tpm.FailureNotifierDocument.FailureNotifier addNewFailureNotifier()
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.FailureNotifierDocument.FailureNotifier target = null;
                target = (com.bea.x2003.x03.wli.tpm.FailureNotifierDocument.FailureNotifier)get_store().add_element_user(FAILURENOTIFIER$2);
                return target;
            }
        }
        
        /**
         * Unsets the "failure-notifier" element
         */
        public void unsetFailureNotifier()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(FAILURENOTIFIER$2, 0);
            }
        }
        
        /**
         * Gets the "transport" element
         */
        public com.bea.x2003.x03.wli.tpm.TransportDocument.Transport getTransport()
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.TransportDocument.Transport target = null;
                target = (com.bea.x2003.x03.wli.tpm.TransportDocument.Transport)get_store().find_element_user(TRANSPORT$4, 0);
                if (target == null)
                {
                    return null;
                }
                return target;
            }
        }
        
        /**
         * True if has "transport" element
         */
        public boolean isSetTransport()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().count_elements(TRANSPORT$4) != 0;
            }
        }
        
        /**
         * Sets the "transport" element
         */
        public void setTransport(com.bea.x2003.x03.wli.tpm.TransportDocument.Transport transport)
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.TransportDocument.Transport target = null;
                target = (com.bea.x2003.x03.wli.tpm.TransportDocument.Transport)get_store().find_element_user(TRANSPORT$4, 0);
                if (target == null)
                {
                    target = (com.bea.x2003.x03.wli.tpm.TransportDocument.Transport)get_store().add_element_user(TRANSPORT$4);
                }
                target.set(transport);
            }
        }
        
        /**
         * Appends and returns a new empty "transport" element
         */
        public com.bea.x2003.x03.wli.tpm.TransportDocument.Transport addNewTransport()
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.TransportDocument.Transport target = null;
                target = (com.bea.x2003.x03.wli.tpm.TransportDocument.Transport)get_store().add_element_user(TRANSPORT$4);
                return target;
            }
        }
        
        /**
         * Unsets the "transport" element
         */
        public void unsetTransport()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_element(TRANSPORT$4, 0);
            }
        }
        
        /**
         * Gets the "name" attribute
         */
        public java.lang.String getName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(NAME$6);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "name" attribute
         */
        public org.apache.xmlbeans.XmlString xgetName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlString target = null;
                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(NAME$6);
                return target;
            }
        }
        
        /**
         * Sets the "name" attribute
         */
        public void setName(java.lang.String name)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(NAME$6);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(NAME$6);
                }
                target.setStringValue(name);
            }
        }
        
        /**
         * Sets (as xml) the "name" attribute
         */
        public void xsetName(org.apache.xmlbeans.XmlString name)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlString target = null;
                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(NAME$6);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(NAME$6);
                }
                target.set(name);
            }
        }
        
        /**
         * Gets the "business-protocol-name" attribute
         */
        public java.lang.String getBusinessProtocolName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(BUSINESSPROTOCOLNAME$8);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "business-protocol-name" attribute
         */
        public org.apache.xmlbeans.XmlString xgetBusinessProtocolName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlString target = null;
                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(BUSINESSPROTOCOLNAME$8);
                return target;
            }
        }
        
        /**
         * True if has "business-protocol-name" attribute
         */
        public boolean isSetBusinessProtocolName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(BUSINESSPROTOCOLNAME$8) != null;
            }
        }
        
        /**
         * Sets the "business-protocol-name" attribute
         */
        public void setBusinessProtocolName(java.lang.String businessProtocolName)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(BUSINESSPROTOCOLNAME$8);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(BUSINESSPROTOCOLNAME$8);
                }
                target.setStringValue(businessProtocolName);
            }
        }
        
        /**
         * Sets (as xml) the "business-protocol-name" attribute
         */
        public void xsetBusinessProtocolName(org.apache.xmlbeans.XmlString businessProtocolName)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlString target = null;
                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(BUSINESSPROTOCOLNAME$8);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(BUSINESSPROTOCOLNAME$8);
                }
                target.set(businessProtocolName);
            }
        }
        
        /**
         * Unsets the "business-protocol-name" attribute
         */
        public void unsetBusinessProtocolName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(BUSINESSPROTOCOLNAME$8);
            }
        }
        
        /**
         * Gets the "business-protocol-version" attribute
         */
        public java.lang.String getBusinessProtocolVersion()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(BUSINESSPROTOCOLVERSION$10);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "business-protocol-version" attribute
         */
        public org.apache.xmlbeans.XmlString xgetBusinessProtocolVersion()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlString target = null;
                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(BUSINESSPROTOCOLVERSION$10);
                return target;
            }
        }
        
        /**
         * True if has "business-protocol-version" attribute
         */
        public boolean isSetBusinessProtocolVersion()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(BUSINESSPROTOCOLVERSION$10) != null;
            }
        }
        
        /**
         * Sets the "business-protocol-version" attribute
         */
        public void setBusinessProtocolVersion(java.lang.String businessProtocolVersion)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(BUSINESSPROTOCOLVERSION$10);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(BUSINESSPROTOCOLVERSION$10);
                }
                target.setStringValue(businessProtocolVersion);
            }
        }
        
        /**
         * Sets (as xml) the "business-protocol-version" attribute
         */
        public void xsetBusinessProtocolVersion(org.apache.xmlbeans.XmlString businessProtocolVersion)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlString target = null;
                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(BUSINESSPROTOCOLVERSION$10);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(BUSINESSPROTOCOLVERSION$10);
                }
                target.set(businessProtocolVersion);
            }
        }
        
        /**
         * Unsets the "business-protocol-version" attribute
         */
        public void unsetBusinessProtocolVersion()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(BUSINESSPROTOCOLVERSION$10);
            }
        }
        
        /**
         * Gets the "is-default" attribute
         */
        public boolean getIsDefault()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ISDEFAULT$12);
                if (target == null)
                {
                    return false;
                }
                return target.getBooleanValue();
            }
        }
        
        /**
         * Gets (as xml) the "is-default" attribute
         */
        public org.apache.xmlbeans.XmlBoolean xgetIsDefault()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlBoolean target = null;
                target = (org.apache.xmlbeans.XmlBoolean)get_store().find_attribute_user(ISDEFAULT$12);
                return target;
            }
        }
        
        /**
         * True if has "is-default" attribute
         */
        public boolean isSetIsDefault()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ISDEFAULT$12) != null;
            }
        }
        
        /**
         * Sets the "is-default" attribute
         */
        public void setIsDefault(boolean isDefault)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ISDEFAULT$12);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ISDEFAULT$12);
                }
                target.setBooleanValue(isDefault);
            }
        }
        
        /**
         * Sets (as xml) the "is-default" attribute
         */
        public void xsetIsDefault(org.apache.xmlbeans.XmlBoolean isDefault)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlBoolean target = null;
                target = (org.apache.xmlbeans.XmlBoolean)get_store().find_attribute_user(ISDEFAULT$12);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlBoolean)get_store().add_attribute_user(ISDEFAULT$12);
                }
                target.set(isDefault);
            }
        }
        
        /**
         * Unsets the "is-default" attribute
         */
        public void unsetIsDefault()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ISDEFAULT$12);
            }
        }
        
        /**
         * Gets the "encryption-certificate-name" attribute
         */
        public java.lang.String getEncryptionCertificateName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ENCRYPTIONCERTIFICATENAME$14);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "encryption-certificate-name" attribute
         */
        public com.bea.x2003.x03.wli.tpm.Reference xgetEncryptionCertificateName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.Reference target = null;
                target = (com.bea.x2003.x03.wli.tpm.Reference)get_store().find_attribute_user(ENCRYPTIONCERTIFICATENAME$14);
                return target;
            }
        }
        
        /**
         * True if has "encryption-certificate-name" attribute
         */
        public boolean isSetEncryptionCertificateName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ENCRYPTIONCERTIFICATENAME$14) != null;
            }
        }
        
        /**
         * Sets the "encryption-certificate-name" attribute
         */
        public void setEncryptionCertificateName(java.lang.String encryptionCertificateName)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ENCRYPTIONCERTIFICATENAME$14);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ENCRYPTIONCERTIFICATENAME$14);
                }
                target.setStringValue(encryptionCertificateName);
            }
        }
        
        /**
         * Sets (as xml) the "encryption-certificate-name" attribute
         */
        public void xsetEncryptionCertificateName(com.bea.x2003.x03.wli.tpm.Reference encryptionCertificateName)
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.Reference target = null;
                target = (com.bea.x2003.x03.wli.tpm.Reference)get_store().find_attribute_user(ENCRYPTIONCERTIFICATENAME$14);
                if (target == null)
                {
                    target = (com.bea.x2003.x03.wli.tpm.Reference)get_store().add_attribute_user(ENCRYPTIONCERTIFICATENAME$14);
                }
                target.set(encryptionCertificateName);
            }
        }
        
        /**
         * Unsets the "encryption-certificate-name" attribute
         */
        public void unsetEncryptionCertificateName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ENCRYPTIONCERTIFICATENAME$14);
            }
        }
        
        /**
         * Gets the "cipher-algorithm" attribute
         */
        public com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.CipherAlgorithm.Enum getCipherAlgorithm()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(CIPHERALGORITHM$16);
                if (target == null)
                {
                    return null;
                }
                return (com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.CipherAlgorithm.Enum)target.getEnumValue();
            }
        }
        
        /**
         * Gets (as xml) the "cipher-algorithm" attribute
         */
        public com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.CipherAlgorithm xgetCipherAlgorithm()
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.CipherAlgorithm target = null;
                target = (com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.CipherAlgorithm)get_store().find_attribute_user(CIPHERALGORITHM$16);
                return target;
            }
        }
        
        /**
         * True if has "cipher-algorithm" attribute
         */
        public boolean isSetCipherAlgorithm()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(CIPHERALGORITHM$16) != null;
            }
        }
        
        /**
         * Sets the "cipher-algorithm" attribute
         */
        public void setCipherAlgorithm(com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.CipherAlgorithm.Enum cipherAlgorithm)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(CIPHERALGORITHM$16);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(CIPHERALGORITHM$16);
                }
                target.setEnumValue(cipherAlgorithm);
            }
        }
        
        /**
         * Sets (as xml) the "cipher-algorithm" attribute
         */
        public void xsetCipherAlgorithm(com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.CipherAlgorithm cipherAlgorithm)
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.CipherAlgorithm target = null;
                target = (com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.CipherAlgorithm)get_store().find_attribute_user(CIPHERALGORITHM$16);
                if (target == null)
                {
                    target = (com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.CipherAlgorithm)get_store().add_attribute_user(CIPHERALGORITHM$16);
                }
                target.set(cipherAlgorithm);
            }
        }
        
        /**
         * Unsets the "cipher-algorithm" attribute
         */
        public void unsetCipherAlgorithm()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(CIPHERALGORITHM$16);
            }
        }
        
        /**
         * Gets the "encryption-level" attribute
         */
        public com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.EncryptionLevel.Enum getEncryptionLevel()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ENCRYPTIONLEVEL$18);
                if (target == null)
                {
                    return null;
                }
                return (com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.EncryptionLevel.Enum)target.getEnumValue();
            }
        }
        
        /**
         * Gets (as xml) the "encryption-level" attribute
         */
        public com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.EncryptionLevel xgetEncryptionLevel()
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.EncryptionLevel target = null;
                target = (com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.EncryptionLevel)get_store().find_attribute_user(ENCRYPTIONLEVEL$18);
                return target;
            }
        }
        
        /**
         * True if has "encryption-level" attribute
         */
        public boolean isSetEncryptionLevel()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ENCRYPTIONLEVEL$18) != null;
            }
        }
        
        /**
         * Sets the "encryption-level" attribute
         */
        public void setEncryptionLevel(com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.EncryptionLevel.Enum encryptionLevel)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ENCRYPTIONLEVEL$18);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ENCRYPTIONLEVEL$18);
                }
                target.setEnumValue(encryptionLevel);
            }
        }
        
        /**
         * Sets (as xml) the "encryption-level" attribute
         */
        public void xsetEncryptionLevel(com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.EncryptionLevel encryptionLevel)
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.EncryptionLevel target = null;
                target = (com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.EncryptionLevel)get_store().find_attribute_user(ENCRYPTIONLEVEL$18);
                if (target == null)
                {
                    target = (com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.EncryptionLevel)get_store().add_attribute_user(ENCRYPTIONLEVEL$18);
                }
                target.set(encryptionLevel);
            }
        }
        
        /**
         * Unsets the "encryption-level" attribute
         */
        public void unsetEncryptionLevel()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ENCRYPTIONLEVEL$18);
            }
        }
        
        /**
         * Gets the "is-signature-required" attribute
         */
        public boolean getIsSignatureRequired()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ISSIGNATUREREQUIRED$20);
                if (target == null)
                {
                    return false;
                }
                return target.getBooleanValue();
            }
        }
        
        /**
         * Gets (as xml) the "is-signature-required" attribute
         */
        public org.apache.xmlbeans.XmlBoolean xgetIsSignatureRequired()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlBoolean target = null;
                target = (org.apache.xmlbeans.XmlBoolean)get_store().find_attribute_user(ISSIGNATUREREQUIRED$20);
                return target;
            }
        }
        
        /**
         * True if has "is-signature-required" attribute
         */
        public boolean isSetIsSignatureRequired()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ISSIGNATUREREQUIRED$20) != null;
            }
        }
        
        /**
         * Sets the "is-signature-required" attribute
         */
        public void setIsSignatureRequired(boolean isSignatureRequired)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ISSIGNATUREREQUIRED$20);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ISSIGNATUREREQUIRED$20);
                }
                target.setBooleanValue(isSignatureRequired);
            }
        }
        
        /**
         * Sets (as xml) the "is-signature-required" attribute
         */
        public void xsetIsSignatureRequired(org.apache.xmlbeans.XmlBoolean isSignatureRequired)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlBoolean target = null;
                target = (org.apache.xmlbeans.XmlBoolean)get_store().find_attribute_user(ISSIGNATUREREQUIRED$20);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlBoolean)get_store().add_attribute_user(ISSIGNATUREREQUIRED$20);
                }
                target.set(isSignatureRequired);
            }
        }
        
        /**
         * Unsets the "is-signature-required" attribute
         */
        public void unsetIsSignatureRequired()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ISSIGNATUREREQUIRED$20);
            }
        }
        
        /**
         * Gets the "is-receipt-signature-required" attribute
         */
        public boolean getIsReceiptSignatureRequired()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ISRECEIPTSIGNATUREREQUIRED$22);
                if (target == null)
                {
                    return false;
                }
                return target.getBooleanValue();
            }
        }
        
        /**
         * Gets (as xml) the "is-receipt-signature-required" attribute
         */
        public org.apache.xmlbeans.XmlBoolean xgetIsReceiptSignatureRequired()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlBoolean target = null;
                target = (org.apache.xmlbeans.XmlBoolean)get_store().find_attribute_user(ISRECEIPTSIGNATUREREQUIRED$22);
                return target;
            }
        }
        
        /**
         * True if has "is-receipt-signature-required" attribute
         */
        public boolean isSetIsReceiptSignatureRequired()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(ISRECEIPTSIGNATUREREQUIRED$22) != null;
            }
        }
        
        /**
         * Sets the "is-receipt-signature-required" attribute
         */
        public void setIsReceiptSignatureRequired(boolean isReceiptSignatureRequired)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ISRECEIPTSIGNATUREREQUIRED$22);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ISRECEIPTSIGNATUREREQUIRED$22);
                }
                target.setBooleanValue(isReceiptSignatureRequired);
            }
        }
        
        /**
         * Sets (as xml) the "is-receipt-signature-required" attribute
         */
        public void xsetIsReceiptSignatureRequired(org.apache.xmlbeans.XmlBoolean isReceiptSignatureRequired)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlBoolean target = null;
                target = (org.apache.xmlbeans.XmlBoolean)get_store().find_attribute_user(ISRECEIPTSIGNATUREREQUIRED$22);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlBoolean)get_store().add_attribute_user(ISRECEIPTSIGNATUREREQUIRED$22);
                }
                target.set(isReceiptSignatureRequired);
            }
        }
        
        /**
         * Unsets the "is-receipt-signature-required" attribute
         */
        public void unsetIsReceiptSignatureRequired()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(ISRECEIPTSIGNATUREREQUIRED$22);
            }
        }
        
        /**
         * Gets the "signature-digest-algorithm" attribute
         */
        public java.lang.String getSignatureDigestAlgorithm()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SIGNATUREDIGESTALGORITHM$24);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "signature-digest-algorithm" attribute
         */
        public org.apache.xmlbeans.XmlString xgetSignatureDigestAlgorithm()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlString target = null;
                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(SIGNATUREDIGESTALGORITHM$24);
                return target;
            }
        }
        
        /**
         * True if has "signature-digest-algorithm" attribute
         */
        public boolean isSetSignatureDigestAlgorithm()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(SIGNATUREDIGESTALGORITHM$24) != null;
            }
        }
        
        /**
         * Sets the "signature-digest-algorithm" attribute
         */
        public void setSignatureDigestAlgorithm(java.lang.String signatureDigestAlgorithm)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SIGNATUREDIGESTALGORITHM$24);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(SIGNATUREDIGESTALGORITHM$24);
                }
                target.setStringValue(signatureDigestAlgorithm);
            }
        }
        
        /**
         * Sets (as xml) the "signature-digest-algorithm" attribute
         */
        public void xsetSignatureDigestAlgorithm(org.apache.xmlbeans.XmlString signatureDigestAlgorithm)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlString target = null;
                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(SIGNATUREDIGESTALGORITHM$24);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(SIGNATUREDIGESTALGORITHM$24);
                }
                target.set(signatureDigestAlgorithm);
            }
        }
        
        /**
         * Unsets the "signature-digest-algorithm" attribute
         */
        public void unsetSignatureDigestAlgorithm()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(SIGNATUREDIGESTALGORITHM$24);
            }
        }
        
        /**
         * Gets the "signature-certificate-name" attribute
         */
        public java.lang.String getSignatureCertificateName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SIGNATURECERTIFICATENAME$26);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "signature-certificate-name" attribute
         */
        public com.bea.x2003.x03.wli.tpm.Reference xgetSignatureCertificateName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.Reference target = null;
                target = (com.bea.x2003.x03.wli.tpm.Reference)get_store().find_attribute_user(SIGNATURECERTIFICATENAME$26);
                return target;
            }
        }
        
        /**
         * True if has "signature-certificate-name" attribute
         */
        public boolean isSetSignatureCertificateName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(SIGNATURECERTIFICATENAME$26) != null;
            }
        }
        
        /**
         * Sets the "signature-certificate-name" attribute
         */
        public void setSignatureCertificateName(java.lang.String signatureCertificateName)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SIGNATURECERTIFICATENAME$26);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(SIGNATURECERTIFICATENAME$26);
                }
                target.setStringValue(signatureCertificateName);
            }
        }
        
        /**
         * Sets (as xml) the "signature-certificate-name" attribute
         */
        public void xsetSignatureCertificateName(com.bea.x2003.x03.wli.tpm.Reference signatureCertificateName)
        {
            synchronized (monitor())
            {
                check_orphaned();
                com.bea.x2003.x03.wli.tpm.Reference target = null;
                target = (com.bea.x2003.x03.wli.tpm.Reference)get_store().find_attribute_user(SIGNATURECERTIFICATENAME$26);
                if (target == null)
                {
                    target = (com.bea.x2003.x03.wli.tpm.Reference)get_store().add_attribute_user(SIGNATURECERTIFICATENAME$26);
                }
                target.set(signatureCertificateName);
            }
        }
        
        /**
         * Unsets the "signature-certificate-name" attribute
         */
        public void unsetSignatureCertificateName()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(SIGNATURECERTIFICATENAME$26);
            }
        }
        
        /**
         * Gets the "retries" attribute
         */
        public java.math.BigInteger getRetries()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(RETRIES$28);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_default_attribute_value(RETRIES$28);
                }
                if (target == null)
                {
                    return null;
                }
                return target.getBigIntegerValue();
            }
        }
        
        /**
         * Gets (as xml) the "retries" attribute
         */
        public org.apache.xmlbeans.XmlNonNegativeInteger xgetRetries()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlNonNegativeInteger target = null;
                target = (org.apache.xmlbeans.XmlNonNegativeInteger)get_store().find_attribute_user(RETRIES$28);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlNonNegativeInteger)get_default_attribute_value(RETRIES$28);
                }
                return target;
            }
        }
        
        /**
         * True if has "retries" attribute
         */
        public boolean isSetRetries()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(RETRIES$28) != null;
            }
        }
        
        /**
         * Sets the "retries" attribute
         */
        public void setRetries(java.math.BigInteger retries)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(RETRIES$28);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(RETRIES$28);
                }
                target.setBigIntegerValue(retries);
            }
        }
        
        /**
         * Sets (as xml) the "retries" attribute
         */
        public void xsetRetries(org.apache.xmlbeans.XmlNonNegativeInteger retries)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlNonNegativeInteger target = null;
                target = (org.apache.xmlbeans.XmlNonNegativeInteger)get_store().find_attribute_user(RETRIES$28);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlNonNegativeInteger)get_store().add_attribute_user(RETRIES$28);
                }
                target.set(retries);
            }
        }
        
        /**
         * Unsets the "retries" attribute
         */
        public void unsetRetries()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(RETRIES$28);
            }
        }
        
        /**
         * Gets the "retry-interval" attribute
         */
        public java.lang.String getRetryInterval()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(RETRYINTERVAL$30);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "retry-interval" attribute
         */
        public org.apache.xmlbeans.XmlString xgetRetryInterval()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlString target = null;
                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(RETRYINTERVAL$30);
                return target;
            }
        }
        
        /**
         * True if has "retry-interval" attribute
         */
        public boolean isSetRetryInterval()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(RETRYINTERVAL$30) != null;
            }
        }
        
        /**
         * Sets the "retry-interval" attribute
         */
        public void setRetryInterval(java.lang.String retryInterval)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(RETRYINTERVAL$30);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(RETRYINTERVAL$30);
                }
                target.setStringValue(retryInterval);
            }
        }
        
        /**
         * Sets (as xml) the "retry-interval" attribute
         */
        public void xsetRetryInterval(org.apache.xmlbeans.XmlString retryInterval)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlString target = null;
                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(RETRYINTERVAL$30);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(RETRYINTERVAL$30);
                }
                target.set(retryInterval);
            }
        }
        
        /**
         * Unsets the "retry-interval" attribute
         */
        public void unsetRetryInterval()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(RETRYINTERVAL$30);
            }
        }
        
        /**
         * Gets the "process-timeout" attribute
         */
        public java.lang.String getProcessTimeout()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(PROCESSTIMEOUT$32);
                if (target == null)
                {
                    return null;
                }
                return target.getStringValue();
            }
        }
        
        /**
         * Gets (as xml) the "process-timeout" attribute
         */
        public org.apache.xmlbeans.XmlString xgetProcessTimeout()
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlString target = null;
                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(PROCESSTIMEOUT$32);
                return target;
            }
        }
        
        /**
         * True if has "process-timeout" attribute
         */
        public boolean isSetProcessTimeout()
        {
            synchronized (monitor())
            {
                check_orphaned();
                return get_store().find_attribute_user(PROCESSTIMEOUT$32) != null;
            }
        }
        
        /**
         * Sets the "process-timeout" attribute
         */
        public void setProcessTimeout(java.lang.String processTimeout)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.SimpleValue target = null;
                target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(PROCESSTIMEOUT$32);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(PROCESSTIMEOUT$32);
                }
                target.setStringValue(processTimeout);
            }
        }
        
        /**
         * Sets (as xml) the "process-timeout" attribute
         */
        public void xsetProcessTimeout(org.apache.xmlbeans.XmlString processTimeout)
        {
            synchronized (monitor())
            {
                check_orphaned();
                org.apache.xmlbeans.XmlString target = null;
                target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(PROCESSTIMEOUT$32);
                if (target == null)
                {
                    target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(PROCESSTIMEOUT$32);
                }
                target.set(processTimeout);
            }
        }
        
        /**
         * Unsets the "process-timeout" attribute
         */
        public void unsetProcessTimeout()
        {
            synchronized (monitor())
            {
                check_orphaned();
                get_store().remove_attribute(PROCESSTIMEOUT$32);
            }
        }
        /**
         * An XML cipher-algorithm(@).
         *
         * This is an atomic type that is a restriction of com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument$RosettanetBinding$CipherAlgorithm.
         */
        public static class CipherAlgorithmImpl extends org.apache.xmlbeans.impl.values.JavaStringEnumerationHolderEx implements com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.CipherAlgorithm
        {
            
            public CipherAlgorithmImpl(org.apache.xmlbeans.SchemaType sType)
            {
                super(sType, false);
            }
            
            protected CipherAlgorithmImpl(org.apache.xmlbeans.SchemaType sType, boolean b)
            {
                super(sType, b);
            }
        }
        /**
         * An XML encryption-level(@).
         *
         * This is an atomic type that is a restriction of com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument$RosettanetBinding$EncryptionLevel.
         */
        public static class EncryptionLevelImpl extends org.apache.xmlbeans.impl.values.JavaStringEnumerationHolderEx implements com.bea.x2003.x03.wli.tpm.RosettanetBindingDocument.RosettanetBinding.EncryptionLevel
        {
            
            public EncryptionLevelImpl(org.apache.xmlbeans.SchemaType sType)
            {
                super(sType, false);
            }
            
            protected EncryptionLevelImpl(org.apache.xmlbeans.SchemaType sType, boolean b)
            {
                super(sType, b);
            }
        }
    }
}
