Projet

Général

Profil

Télécharger (41,8 ko) Statistiques
| Branche: | Tag: | Révision:

root/lib/epcis-0.5.0/epcis-commons/src/main/java/org/fosstrak/epcis/model/ObjectFactory.java @ 2e0a7cb1

package org.fosstrak.epcis.model;

import javax.xml.bind.JAXBElement;
import javax.xml.bind.annotation.XmlElementDecl;
import javax.xml.bind.annotation.XmlRegistry;
import javax.xml.namespace.QName;

/**
* This object contains factory methods for each Java content interface and Java
* element interface generated in the org.fosstrak.epcis.model package.
* <p>
* An ObjectFactory allows you to programatically construct new instances of the
* Java representation for XML content. The Java representation of XML content
* can consist of schema derived interfaces and classes representing the binding
* of schema type definitions, element declarations and model groups. Factory
* methods for each of these are provided in this class.
*/
@XmlRegistry
public class ObjectFactory {

private final static QName _QueryParameterException_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"QueryParameterException");
private final static QName _EPCISException_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1", "EPCISException");
private final static QName _SubscribeNotPermittedException_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"SubscribeNotPermittedException");
private final static QName _InvalidURIException_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"InvalidURIException");
private final static QName _SubscriptionControlsException_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"SubscriptionControlsException");
private final static QName _EPCISDocument_QNAME = new QName("urn:epcglobal:epcis:xsd:1", "EPCISDocument");
private final static QName _SecurityException_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"SecurityException");
private final static QName _NoSuchNameException_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"NoSuchNameException");
private final static QName _StandardBusinessDocument_QNAME = new QName(
"http://www.unece.org/cefact/namespaces/StandardBusinessDocumentHeader", "StandardBusinessDocument");
private final static QName _VoidHolder_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1", "VoidHolder");
private final static QName _Subscribe_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1", "Subscribe");
private final static QName _DuplicateSubscriptionException_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"DuplicateSubscriptionException");
private final static QName _QueryTooLargeException_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"QueryTooLargeException");
private final static QName _GetSubscriptionIDs_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"GetSubscriptionIDs");
private final static QName _UnsubscribeResult_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"UnsubscribeResult");
private final static QName _EPCISQueryDocument_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"EPCISQueryDocument");
private final static QName _ScopeInformation_QNAME = new QName(
"http://www.unece.org/cefact/namespaces/StandardBusinessDocumentHeader", "ScopeInformation");
private final static QName _CorrelationInformation_QNAME = new QName(
"http://www.unece.org/cefact/namespaces/StandardBusinessDocumentHeader", "CorrelationInformation");
private final static QName _GetQueryNamesResult_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"GetQueryNamesResult");
private final static QName _QueryTooComplexException_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"QueryTooComplexException");
private final static QName _EPCISMasterDataDocument_QNAME = new QName("urn:epcglobal:epcis-masterdata:xsd:1",
"EPCISMasterDataDocument");
private final static QName _GetSubscriptionIDsResult_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"GetSubscriptionIDsResult");
private final static QName _GetVendorVersionResult_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"GetVendorVersionResult");
private final static QName _ValidationException_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"ValidationException");
private final static QName _StandardBusinessDocumentHeader_QNAME = new QName(
"http://www.unece.org/cefact/namespaces/StandardBusinessDocumentHeader", "StandardBusinessDocumentHeader");
private final static QName _SubscribeResult_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1", "SubscribeResult");
private final static QName _GetVendorVersion_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"GetVendorVersion");
private final static QName _Unsubscribe_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1", "Unsubscribe");
private final static QName _GetQueryNames_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1", "GetQueryNames");
private final static QName _QueryResults_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1", "QueryResults");
private final static QName _Poll_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1", "Poll");
private final static QName _GetStandardVersion_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"GetStandardVersion");
private final static QName _BusinessService_QNAME = new QName(
"http://www.unece.org/cefact/namespaces/StandardBusinessDocumentHeader", "BusinessService");
private final static QName _DuplicateNameException_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"DuplicateNameException");
private final static QName _GetStandardVersionResult_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"GetStandardVersionResult");
private final static QName _ImplementationException_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"ImplementationException");
private final static QName _NoSuchSubscriptionException_QNAME = new QName("urn:epcglobal:epcis-query:xsd:1",
"NoSuchSubscriptionException");
private final static QName _EventListTypeExtension_QNAME = new QName("", "extension");
private final static QName _EventListTypeObjectEvent_QNAME = new QName("", "ObjectEvent");
private final static QName _EventListTypeTransactionEvent_QNAME = new QName("", "TransactionEvent");
private final static QName _EventListTypeQuantityEvent_QNAME = new QName("", "QuantityEvent");
private final static QName _EventListTypeAggregationEvent_QNAME = new QName("", "AggregationEvent");

/**
* Create a new ObjectFactory that can be used to create new instances of
* schema derived classes for package: org.fosstrak.epcis.model
*/
public ObjectFactory() {
}

/**
* Create an instance of {@link QueryResultsBody }
*/
public QueryResultsBody createQueryResultsBody() {
return new QueryResultsBody();
}

/**
* Create an instance of {@link QueryParam }
*/
public QueryParam createQueryParam() {
return new QueryParam();
}

/**
* Create an instance of {@link EPCISDocumentType }
*/
public EPCISDocumentType createEPCISDocumentType() {
return new EPCISDocumentType();
}

/**
* Create an instance of {@link EPCISBodyType }
*/
public EPCISBodyType createEPCISBodyType() {
return new EPCISBodyType();
}

/**
* Create an instance of {@link EPCISMasterDataDocumentExtensionType }
*/
public EPCISMasterDataDocumentExtensionType createEPCISMasterDataDocumentExtensionType() {
return new EPCISMasterDataDocumentExtensionType();
}

/**
* Create an instance of {@link ReadPointExtensionType }
*/
public ReadPointExtensionType createReadPointExtensionType() {
return new ReadPointExtensionType();
}

/**
* Create an instance of {@link QuantityEventType }
*/
public QuantityEventType createQuantityEventType() {
return new QuantityEventType();
}

/**
* Create an instance of {@link EPC }
*/
public EPC createEPC() {
return new EPC();
}

/**
* Create an instance of {@link Unsubscribe }
*/
public Unsubscribe createUnsubscribe() {
return new Unsubscribe();
}

/**
* Create an instance of {@link BusinessTransactionType }
*/
public BusinessTransactionType createBusinessTransactionType() {
return new BusinessTransactionType();
}

/**
* Create an instance of {@link Partner }
*/
public Partner createPartner() {
return new Partner();
}

/**
* Create an instance of {@link ObjectEventType }
*/
public ObjectEventType createObjectEventType() {
return new ObjectEventType();
}

/**
* Create an instance of {@link NoSuchNameException }
*/
public NoSuchNameException createNoSuchNameException() {
return new NoSuchNameException();
}

/**
* Create an instance of {@link EPCISDocumentExtensionType }
*/
public EPCISDocumentExtensionType createEPCISDocumentExtensionType() {
return new EPCISDocumentExtensionType();
}

/**
* Create an instance of {@link Poll }
*/
public Poll createPoll() {
return new Poll();
}

/**
* Create an instance of {@link IDListType }
*/
public IDListType createIDListType() {
return new IDListType();
}

/**
* Create an instance of {@link DuplicateNameException }
*/
public DuplicateNameException createDuplicateNameException() {
return new DuplicateNameException();
}

/**
* Create an instance of {@link InvalidURIException }
*/
public InvalidURIException createInvalidURIException() {
return new InvalidURIException();
}

/**
* Create an instance of {@link EPCISHeaderExtensionType }
*/
public EPCISHeaderExtensionType createEPCISHeaderExtensionType() {
return new EPCISHeaderExtensionType();
}

/**
* Create an instance of {@link PartnerIdentification }
*/
public PartnerIdentification createPartnerIdentification() {
return new PartnerIdentification();
}

/**
* Create an instance of {@link SubscriptionControls }
*/
public SubscriptionControls createSubscriptionControls() {
return new SubscriptionControls();
}

/**
* Create an instance of {@link VocabularyExtensionType }
*/
public VocabularyExtensionType createVocabularyExtensionType() {
return new VocabularyExtensionType();
}

/**
* Create an instance of {@link EPCISEventListExtensionType }
*/
public EPCISEventListExtensionType createEPCISEventListExtensionType() {
return new EPCISEventListExtensionType();
}

/**
* Create an instance of {@link VocabularyElementExtensionType }
*/
public VocabularyElementExtensionType createVocabularyElementExtensionType() {
return new VocabularyElementExtensionType();
}

/**
* Create an instance of {@link VocabularyType }
*/
public VocabularyType createVocabularyType() {
return new VocabularyType();
}

/**
* Create an instance of {@link ValidationException }
*/
public ValidationException createValidationException() {
return new ValidationException();
}

/**
* Create an instance of {@link AttributeType }
*/
public AttributeType createAttributeType() {
return new AttributeType();
}

/**
* Create an instance of {@link DuplicateSubscriptionException }
*/
public DuplicateSubscriptionException createDuplicateSubscriptionException() {
return new DuplicateSubscriptionException();
}

/**
* Create an instance of {@link TransactionEventType }
*/
public TransactionEventType createTransactionEventType() {
return new TransactionEventType();
}

/**
* Create an instance of {@link QuerySchedule }
*/
public QuerySchedule createQuerySchedule() {
return new QuerySchedule();
}

/**
* Create an instance of {@link ServiceTransaction }
*/
public ServiceTransaction createServiceTransaction() {
return new ServiceTransaction();
}

/**
* Create an instance of {@link EPCISEventExtensionType }
*/
public EPCISEventExtensionType createEPCISEventExtensionType() {
return new EPCISEventExtensionType();
}

/**
* Create an instance of {@link VocabularyElementListType }
*/
public VocabularyElementListType createVocabularyElementListType() {
return new VocabularyElementListType();
}

/**
* Create an instance of {@link VocabularyElementType }
*/
public VocabularyElementType createVocabularyElementType() {
return new VocabularyElementType();
}

/**
* Create an instance of {@link BusinessService }
*/
public BusinessService createBusinessService() {
return new BusinessService();
}

/**
* Create an instance of {@link QueryParameterException }
*/
public QueryParameterException createQueryParameterException() {
return new QueryParameterException();
}

/**
* Create an instance of {@link EPCISQueryDocumentType }
*/
public EPCISQueryDocumentType createEPCISQueryDocumentType() {
return new EPCISQueryDocumentType();
}

/**
* Create an instance of {@link SubscriptionControlsException }
*/
public SubscriptionControlsException createSubscriptionControlsException() {
return new SubscriptionControlsException();
}

/**
* Create an instance of {@link QueryParams }
*/
public QueryParams createQueryParams() {
return new QueryParams();
}

/**
* Create an instance of {@link BusinessTransactionListType }
*/
public BusinessTransactionListType createBusinessTransactionListType() {
return new BusinessTransactionListType();
}

/**
* Create an instance of {@link EmptyParms }
*/
public EmptyParms createEmptyParms() {
return new EmptyParms();
}

/**
* Create an instance of {@link CorrelationInformation }
*/
public CorrelationInformation createCorrelationInformation() {
return new CorrelationInformation();
}

/**
* Create an instance of {@link Manifest }
*/
public Manifest createManifest() {
return new Manifest();
}

/**
* Create an instance of {@link EPCISBodyExtensionType }
*/
public EPCISBodyExtensionType createEPCISBodyExtensionType() {
return new EPCISBodyExtensionType();
}

/**
* Create an instance of {@link StandardBusinessDocumentHeader }
*/
public StandardBusinessDocumentHeader createStandardBusinessDocumentHeader() {
return new StandardBusinessDocumentHeader();
}

/**
* Create an instance of {@link GetSubscriptionIDs }
*/
public GetSubscriptionIDs createGetSubscriptionIDs() {
return new GetSubscriptionIDs();
}

/**
* Create an instance of {@link EPCListType }
*/
public EPCListType createEPCListType() {
return new EPCListType();
}

/**
* Create an instance of {@link QueryTooLargeException }
*/
public QueryTooLargeException createQueryTooLargeException() {
return new QueryTooLargeException();
}

/**
* Create an instance of {@link ManifestItem }
*/
public ManifestItem createManifestItem() {
return new ManifestItem();
}

/**
* Create an instance of {@link ObjectEventExtensionType }
*/
public ObjectEventExtensionType createObjectEventExtensionType() {
return new ObjectEventExtensionType();
}

/**
* Create an instance of {@link AggregationEventType }
*/
public AggregationEventType createAggregationEventType() {
return new AggregationEventType();
}

/**
* Create an instance of {@link VoidHolder }
*/
public VoidHolder createVoidHolder() {
return new VoidHolder();
}

/**
* Create an instance of {@link Subscribe }
*/
public Subscribe createSubscribe() {
return new Subscribe();
}

/**
* Create an instance of {@link QuantityEventExtensionType }
*/
public QuantityEventExtensionType createQuantityEventExtensionType() {
return new QuantityEventExtensionType();
}

/**
* Create an instance of {@link StandardBusinessDocument }
*/
public StandardBusinessDocument createStandardBusinessDocument() {
return new StandardBusinessDocument();
}

/**
* Create an instance of {@link DocumentIdentification }
*/
public DocumentIdentification createDocumentIdentification() {
return new DocumentIdentification();
}

/**
* Create an instance of {@link QueryResults }
*/
public QueryResults createQueryResults() {
return new QueryResults();
}

/**
* Create an instance of {@link BusinessLocationType }
*/
public BusinessLocationType createBusinessLocationType() {
return new BusinessLocationType();
}

/**
* Create an instance of {@link AggregationEventExtensionType }
*/
public AggregationEventExtensionType createAggregationEventExtensionType() {
return new AggregationEventExtensionType();
}

/**
* Create an instance of {@link EPCISHeaderType }
*/
public EPCISHeaderType createEPCISHeaderType() {
return new EPCISHeaderType();
}

/**
* Create an instance of {@link ImplementationException }
*/
public ImplementationException createImplementationException() {
return new ImplementationException();
}

/**
* Create an instance of {@link BusinessScope }
*/
public BusinessScope createBusinessScope() {
return new BusinessScope();
}

/**
* Create an instance of {@link SecurityException }
*/
public SecurityException createSecurityException() {
return new SecurityException();
}

/**
* Create an instance of {@link QueryTooComplexException }
*/
public QueryTooComplexException createQueryTooComplexException() {
return new QueryTooComplexException();
}

/**
* Create an instance of {@link EPCISMasterDataBodyType }
*/
public EPCISMasterDataBodyType createEPCISMasterDataBodyType() {
return new EPCISMasterDataBodyType();
}

/**
* Create an instance of {@link EPCISQueryDocumentExtensionType }
*/
public EPCISQueryDocumentExtensionType createEPCISQueryDocumentExtensionType() {
return new EPCISQueryDocumentExtensionType();
}

/**
* Create an instance of {@link QueryResultsExtensionType }
*/
public QueryResultsExtensionType createQueryResultsExtensionType() {
return new QueryResultsExtensionType();
}

/**
* Create an instance of {@link BusinessLocationExtensionType }
*/
public BusinessLocationExtensionType createBusinessLocationExtensionType() {
return new BusinessLocationExtensionType();
}

/**
* Create an instance of {@link SubscriptionControlsExtensionType }
*/
public SubscriptionControlsExtensionType createSubscriptionControlsExtensionType() {
return new SubscriptionControlsExtensionType();
}

/**
* Create an instance of {@link EPCISException }
*/
public EPCISException createEPCISException() {
return new EPCISException();
}

/**
* Create an instance of {@link NoSuchSubscriptionException }
*/
public NoSuchSubscriptionException createNoSuchSubscriptionException() {
return new NoSuchSubscriptionException();
}

/**
* Create an instance of {@link ArrayOfString }
*/
public ArrayOfString createArrayOfString() {
return new ArrayOfString();
}

/**
* Create an instance of {@link EPCISQueryBodyType }
*/
public EPCISQueryBodyType createEPCISQueryBodyType() {
return new EPCISQueryBodyType();
}

/**
* Create an instance of {@link EPCISMasterDataDocumentType }
*/
public EPCISMasterDataDocumentType createEPCISMasterDataDocumentType() {
return new EPCISMasterDataDocumentType();
}

/**
* Create an instance of {@link SubscribeNotPermittedException }
*/
public SubscribeNotPermittedException createSubscribeNotPermittedException() {
return new SubscribeNotPermittedException();
}

/**
* Create an instance of {@link QueryScheduleExtensionType }
*/
public QueryScheduleExtensionType createQueryScheduleExtensionType() {
return new QueryScheduleExtensionType();
}

/**
* Create an instance of {@link EventListType }
*/
public EventListType createEventListType() {
return new EventListType();
}

/**
* Create an instance of {@link ReadPointType }
*/
public ReadPointType createReadPointType() {
return new ReadPointType();
}

/**
* Create an instance of {@link EPCISMasterDataBodyExtensionType }
*/
public EPCISMasterDataBodyExtensionType createEPCISMasterDataBodyExtensionType() {
return new EPCISMasterDataBodyExtensionType();
}

/**
* Create an instance of {@link TransactionEventExtensionType }
*/
public TransactionEventExtensionType createTransactionEventExtensionType() {
return new TransactionEventExtensionType();
}

/**
* Create an instance of {@link EPCISMasterDataHeaderExtensionType }
*/
public EPCISMasterDataHeaderExtensionType createEPCISMasterDataHeaderExtensionType() {
return new EPCISMasterDataHeaderExtensionType();
}

/**
* Create an instance of {@link VocabularyListType }
*/
public VocabularyListType createVocabularyListType() {
return new VocabularyListType();
}

/**
* Create an instance of {@link ContactInformation }
*/
public ContactInformation createContactInformation() {
return new ContactInformation();
}

/**
* Create an instance of {@link Scope }
*/
public Scope createScope() {
return new Scope();
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link QueryParameterException }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "QueryParameterException")
public JAXBElement<QueryParameterException> createQueryParameterException(QueryParameterException value) {
return new JAXBElement<QueryParameterException>(_QueryParameterException_QNAME, QueryParameterException.class,
null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link EPCISException }
* {@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "EPCISException")
public JAXBElement<EPCISException> createEPCISException(EPCISException value) {
return new JAXBElement<EPCISException>(_EPCISException_QNAME, EPCISException.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link SubscribeNotPermittedException }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "SubscribeNotPermittedException")
public JAXBElement<SubscribeNotPermittedException> createSubscribeNotPermittedException(
SubscribeNotPermittedException value) {
return new JAXBElement<SubscribeNotPermittedException>(_SubscribeNotPermittedException_QNAME,
SubscribeNotPermittedException.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link InvalidURIException }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "InvalidURIException")
public JAXBElement<InvalidURIException> createInvalidURIException(InvalidURIException value) {
return new JAXBElement<InvalidURIException>(_InvalidURIException_QNAME, InvalidURIException.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link SubscriptionControlsException }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "SubscriptionControlsException")
public JAXBElement<SubscriptionControlsException> createSubscriptionControlsException(
SubscriptionControlsException value) {
return new JAXBElement<SubscriptionControlsException>(_SubscriptionControlsException_QNAME,
SubscriptionControlsException.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link EPCISDocumentType }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis:xsd:1", name = "EPCISDocument")
public JAXBElement<EPCISDocumentType> createEPCISDocument(EPCISDocumentType value) {
return new JAXBElement<EPCISDocumentType>(_EPCISDocument_QNAME, EPCISDocumentType.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link SecurityException }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "SecurityException")
public JAXBElement<SecurityException> createSecurityException(SecurityException value) {
return new JAXBElement<SecurityException>(_SecurityException_QNAME, SecurityException.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link NoSuchNameException }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "NoSuchNameException")
public JAXBElement<NoSuchNameException> createNoSuchNameException(NoSuchNameException value) {
return new JAXBElement<NoSuchNameException>(_NoSuchNameException_QNAME, NoSuchNameException.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link StandardBusinessDocument }{@code >}
*/
@XmlElementDecl(namespace = "http://www.unece.org/cefact/namespaces/StandardBusinessDocumentHeader", name = "StandardBusinessDocument")
public JAXBElement<StandardBusinessDocument> createStandardBusinessDocument(StandardBusinessDocument value) {
return new JAXBElement<StandardBusinessDocument>(_StandardBusinessDocument_QNAME,
StandardBusinessDocument.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link VoidHolder }
* {@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "VoidHolder")
public JAXBElement<VoidHolder> createVoidHolder(VoidHolder value) {
return new JAXBElement<VoidHolder>(_VoidHolder_QNAME, VoidHolder.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link Subscribe }
* {@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "Subscribe")
public JAXBElement<Subscribe> createSubscribe(Subscribe value) {
return new JAXBElement<Subscribe>(_Subscribe_QNAME, Subscribe.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link DuplicateSubscriptionException }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "DuplicateSubscriptionException")
public JAXBElement<DuplicateSubscriptionException> createDuplicateSubscriptionException(
DuplicateSubscriptionException value) {
return new JAXBElement<DuplicateSubscriptionException>(_DuplicateSubscriptionException_QNAME,
DuplicateSubscriptionException.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link QueryTooLargeException }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "QueryTooLargeException")
public JAXBElement<QueryTooLargeException> createQueryTooLargeException(QueryTooLargeException value) {
return new JAXBElement<QueryTooLargeException>(_QueryTooLargeException_QNAME, QueryTooLargeException.class,
null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link GetSubscriptionIDs }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "GetSubscriptionIDs")
public JAXBElement<GetSubscriptionIDs> createGetSubscriptionIDs(GetSubscriptionIDs value) {
return new JAXBElement<GetSubscriptionIDs>(_GetSubscriptionIDs_QNAME, GetSubscriptionIDs.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link VoidHolder }
* {@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "UnsubscribeResult")
public JAXBElement<VoidHolder> createUnsubscribeResult(VoidHolder value) {
return new JAXBElement<VoidHolder>(_UnsubscribeResult_QNAME, VoidHolder.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link EPCISQueryDocumentType }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "EPCISQueryDocument")
public JAXBElement<EPCISQueryDocumentType> createEPCISQueryDocument(EPCISQueryDocumentType value) {
return new JAXBElement<EPCISQueryDocumentType>(_EPCISQueryDocument_QNAME, EPCISQueryDocumentType.class, null,
value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link Object }{@code >}
*/
@XmlElementDecl(namespace = "http://www.unece.org/cefact/namespaces/StandardBusinessDocumentHeader", name = "ScopeInformation")
public JAXBElement<Object> createScopeInformation(Object value) {
return new JAXBElement<Object>(_ScopeInformation_QNAME, Object.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link CorrelationInformation }{@code >}
*/
@XmlElementDecl(namespace = "http://www.unece.org/cefact/namespaces/StandardBusinessDocumentHeader", name = "CorrelationInformation", substitutionHeadNamespace = "http://www.unece.org/cefact/namespaces/StandardBusinessDocumentHeader", substitutionHeadName = "ScopeInformation")
public JAXBElement<CorrelationInformation> createCorrelationInformation(CorrelationInformation value) {
return new JAXBElement<CorrelationInformation>(_CorrelationInformation_QNAME, CorrelationInformation.class,
null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link ArrayOfString }
* {@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "GetQueryNamesResult")
public JAXBElement<ArrayOfString> createGetQueryNamesResult(ArrayOfString value) {
return new JAXBElement<ArrayOfString>(_GetQueryNamesResult_QNAME, ArrayOfString.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link QueryTooComplexException }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "QueryTooComplexException")
public JAXBElement<QueryTooComplexException> createQueryTooComplexException(QueryTooComplexException value) {
return new JAXBElement<QueryTooComplexException>(_QueryTooComplexException_QNAME,
QueryTooComplexException.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link EPCISMasterDataDocumentType }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-masterdata:xsd:1", name = "EPCISMasterDataDocument")
public JAXBElement<EPCISMasterDataDocumentType> createEPCISMasterDataDocument(EPCISMasterDataDocumentType value) {
return new JAXBElement<EPCISMasterDataDocumentType>(_EPCISMasterDataDocument_QNAME,
EPCISMasterDataDocumentType.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link ArrayOfString }
* {@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "GetSubscriptionIDsResult")
public JAXBElement<ArrayOfString> createGetSubscriptionIDsResult(ArrayOfString value) {
return new JAXBElement<ArrayOfString>(_GetSubscriptionIDsResult_QNAME, ArrayOfString.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link String }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "GetVendorVersionResult")
public JAXBElement<String> createGetVendorVersionResult(String value) {
return new JAXBElement<String>(_GetVendorVersionResult_QNAME, String.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link ValidationException }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "ValidationException")
public JAXBElement<ValidationException> createValidationException(ValidationException value) {
return new JAXBElement<ValidationException>(_ValidationException_QNAME, ValidationException.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link StandardBusinessDocumentHeader }{@code >}
*/
@XmlElementDecl(namespace = "http://www.unece.org/cefact/namespaces/StandardBusinessDocumentHeader", name = "StandardBusinessDocumentHeader")
public JAXBElement<StandardBusinessDocumentHeader> createStandardBusinessDocumentHeader(
StandardBusinessDocumentHeader value) {
return new JAXBElement<StandardBusinessDocumentHeader>(_StandardBusinessDocumentHeader_QNAME,
StandardBusinessDocumentHeader.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link VoidHolder }
* {@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "SubscribeResult")
public JAXBElement<VoidHolder> createSubscribeResult(VoidHolder value) {
return new JAXBElement<VoidHolder>(_SubscribeResult_QNAME, VoidHolder.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link EmptyParms }
* {@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "GetVendorVersion")
public JAXBElement<EmptyParms> createGetVendorVersion(EmptyParms value) {
return new JAXBElement<EmptyParms>(_GetVendorVersion_QNAME, EmptyParms.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link Unsubscribe }
* {@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "Unsubscribe")
public JAXBElement<Unsubscribe> createUnsubscribe(Unsubscribe value) {
return new JAXBElement<Unsubscribe>(_Unsubscribe_QNAME, Unsubscribe.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link EmptyParms }
* {@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "GetQueryNames")
public JAXBElement<EmptyParms> createGetQueryNames(EmptyParms value) {
return new JAXBElement<EmptyParms>(_GetQueryNames_QNAME, EmptyParms.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link QueryResults }
* {@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "QueryResults")
public JAXBElement<QueryResults> createQueryResults(QueryResults value) {
return new JAXBElement<QueryResults>(_QueryResults_QNAME, QueryResults.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link Poll }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "Poll")
public JAXBElement<Poll> createPoll(Poll value) {
return new JAXBElement<Poll>(_Poll_QNAME, Poll.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link EmptyParms }
* {@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "GetStandardVersion")
public JAXBElement<EmptyParms> createGetStandardVersion(EmptyParms value) {
return new JAXBElement<EmptyParms>(_GetStandardVersion_QNAME, EmptyParms.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link BusinessService }
* {@code >}
*/
@XmlElementDecl(namespace = "http://www.unece.org/cefact/namespaces/StandardBusinessDocumentHeader", name = "BusinessService", substitutionHeadNamespace = "http://www.unece.org/cefact/namespaces/StandardBusinessDocumentHeader", substitutionHeadName = "ScopeInformation")
public JAXBElement<BusinessService> createBusinessService(BusinessService value) {
return new JAXBElement<BusinessService>(_BusinessService_QNAME, BusinessService.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link DuplicateNameException }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "DuplicateNameException")
public JAXBElement<DuplicateNameException> createDuplicateNameException(DuplicateNameException value) {
return new JAXBElement<DuplicateNameException>(_DuplicateNameException_QNAME, DuplicateNameException.class,
null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link String }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "GetStandardVersionResult")
public JAXBElement<String> createGetStandardVersionResult(String value) {
return new JAXBElement<String>(_GetStandardVersionResult_QNAME, String.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link ImplementationException }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "ImplementationException")
public JAXBElement<ImplementationException> createImplementationException(ImplementationException value) {
return new JAXBElement<ImplementationException>(_ImplementationException_QNAME, ImplementationException.class,
null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link NoSuchSubscriptionException }{@code >}
*/
@XmlElementDecl(namespace = "urn:epcglobal:epcis-query:xsd:1", name = "NoSuchSubscriptionException")
public JAXBElement<NoSuchSubscriptionException> createNoSuchSubscriptionException(NoSuchSubscriptionException value) {
return new JAXBElement<NoSuchSubscriptionException>(_NoSuchSubscriptionException_QNAME,
NoSuchSubscriptionException.class, null, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link EPCISEventListExtensionType }{@code >}
*/
@XmlElementDecl(namespace = "", name = "extension", scope = EventListType.class)
public JAXBElement<EPCISEventListExtensionType> createEventListTypeExtension(EPCISEventListExtensionType value) {
return new JAXBElement<EPCISEventListExtensionType>(_EventListTypeExtension_QNAME,
EPCISEventListExtensionType.class, EventListType.class, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}{@link ObjectEventType }
* {@code >}
*/
@XmlElementDecl(namespace = "", name = "ObjectEvent", scope = EventListType.class)
public JAXBElement<ObjectEventType> createEventListTypeObjectEvent(ObjectEventType value) {
return new JAXBElement<ObjectEventType>(_EventListTypeObjectEvent_QNAME, ObjectEventType.class,
EventListType.class, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link TransactionEventType }{@code >}
*/
@XmlElementDecl(namespace = "", name = "TransactionEvent", scope = EventListType.class)
public JAXBElement<TransactionEventType> createEventListTypeTransactionEvent(TransactionEventType value) {
return new JAXBElement<TransactionEventType>(_EventListTypeTransactionEvent_QNAME, TransactionEventType.class,
EventListType.class, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link QuantityEventType }{@code >}
*/
@XmlElementDecl(namespace = "", name = "QuantityEvent", scope = EventListType.class)
public JAXBElement<QuantityEventType> createEventListTypeQuantityEvent(QuantityEventType value) {
return new JAXBElement<QuantityEventType>(_EventListTypeQuantityEvent_QNAME, QuantityEventType.class,
EventListType.class, value);
}

/**
* Create an instance of {@link JAXBElement }{@code <}
* {@link AggregationEventType }{@code >}
*/
@XmlElementDecl(namespace = "", name = "AggregationEvent", scope = EventListType.class)
public JAXBElement<AggregationEventType> createEventListTypeAggregationEvent(AggregationEventType value) {
return new JAXBElement<AggregationEventType>(_EventListTypeAggregationEvent_QNAME, AggregationEventType.class,
EventListType.class, value);
}

}
(51-51/91)